DistributedCache是Hadoop的一个分布式文件缓存类

DistributedCache是Hadoop的一个分布式文件缓存类，使用它有时候能完成一些比较方便的事，DistributedCache第一个比较方便的作用就是来完成分布式文件共享这件事，第二个比较有用的场景，就是在执行一些join操作时，将小表放入cache中，来提高连接效率。


那么，散仙今天要介绍的是如何使用DistributedCache来共享全局的缓存文件。

下面我们先通过一个表格来看下，在hadoop中，使用全局变量或全局文件共享的几种方法

序号	方法
1	使用Configuration的set方法，只适合数据内容比较小的场景
2	将共享文件放在HDFS上，每次都去读取，效率比较低
3	将共享文件放在DistributedCache里，在setup初始化一次后，即可多次使用，缺点是不支持修改操作，仅能读取

本篇散仙，将重点介绍，使用DistributedCache的方法，来共享一些全局配置文件，或变量，通过DistributedCache的addCacheFile方法，我们把HDFS上的一些文件，在hadoop任务启动时，就载入缓存里面，以供全局使用，使用这个方法时，我们需要注意几点，首先我们的本地文件，需要上传到HDFS上，然后再这个方法里，写入加载路径，接下来，我们就可以，在setup初始化时，读取出，其内容，然后在map或reduce方法，执行时，就可以实时的使用这个文件的一些内容了。

散仙，测试共享的一个文件内容如下：

代码如下，注意散仙在setup方法里，读取了文件内容，并打印：

Java代码  

1. package com.qin.testdistributed;  
2.   
3. import java.io.File;  
4. import java.io.FileReader;  
5. import java.io.IOException;  
6. import java.net.URI;  
7. import java.util.Scanner;  
8.   
9. import org.apache.hadoop.conf.Configuration;  
10. import org.apache.hadoop.filecache.DistributedCache;  
11. import org.apache.hadoop.fs.FSDataInputStream;  
12. import org.apache.hadoop.fs.FileSystem;  
13. import org.apache.hadoop.fs.Path;  
14. import org.apache.hadoop.io.IntWritable;  
15. import org.apache.hadoop.io.LongWritable;  
16. import org.apache.hadoop.io.Text;  
17. import org.apache.hadoop.mapred.JobConf;  
18. import org.apache.hadoop.mapreduce.Job;  
19. import org.apache.hadoop.mapreduce.Mapper;  
20. import org.apache.hadoop.mapreduce.Reducer;  
21. import org.apache.hadoop.mapreduce.lib.db.DBConfiguration;  
22. import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;  
23. import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
24. import org.apache.log4j.pattern.LogEvent;  
25.    
26. import org.slf4j.Logger;  
27. import org.slf4j.LoggerFactory;  
28.   
29. import com.qin.operadb.WriteMapDB;  
30.    
31.   
32. /** 
33.  * 测试hadoop的全局共享文件 
34.  * 使用DistributedCached 
35.  *  
36.  * 大数据技术交流群： 37693216 
37.  * @author qindongliang 
38.  *  
39.  * ***/  
40. public class TestDistributed {  
41.       
42.       
43.     private static Logger logger=LoggerFactory.getLogger(TestDistributed.class);  
44.       
45.       
46.       
47.       
48.       
49.     private static class FileMapper extends Mapper<LongWritable, Text, Text, IntWritable>{  
50.           
51.             Path path[]=null;  
52.               
53.         /** 
54.          * Map函数前调用 
55.          *  
56.          * */  
57.         @Override  
58.         protected void setup(Context context)  
59.                 throws IOException, InterruptedException {  
60.           logger.info("开始启动setup了哈哈哈哈");  
61.             // System.out.println("运行了.........");  
62.           Configuration conf=context.getConfiguration();  
63.            path=DistributedCache.getLocalCacheFiles(conf);  
64.            System.out.println("获取的路径是：  "+path[0].toString());  
65.          //  FileSystem fs = FileSystem.get(conf);  
66.            FileSystem fsopen= FileSystem.getLocal(conf);  
67.          FSDataInputStream in = fsopen.open(path[0]);  
68.           // System.out.println(in.readLine());  
69. //         for(Path tmpRefPath : path) {  
70. //             if(tmpRefPath.toString().indexOf("ref.png") != -1) {  
71. //                 in = reffs.open(tmpRefPath);  
72. //                 break;  
73. //             }  
74. //         }  
75.              
76.      // FileReader reader=new FileReader("file://"+path[0].toString());  
77. //      File f=new File("file://"+path[0].toString());  
78.       // FSDataInputStream in=fs.open(new Path(path[0].toString()));  
79.          Scanner scan=new Scanner(in);  
80.            while(scan.hasNext()){  
81.                System.out.println(Thread.currentThread().getName()+"扫描的内容:  "+scan.next());  
82.            }  
83.            scan.close();  
84. //        
85.         // System.out.println("size: "+path.length);  
86.               
87.               
88.         }  
89.           
90.           
91.         @Override  
92.         protected void map(LongWritable key, Text value,Context context)  
93.                 throws IOException, InterruptedException {  
94.            
95.         //  System.out.println("map    aaa");  
96.             //logger.info("Map里的任务");  
97.             System.out.println("map里输出了");  
98.         //  logger.info();  
99.             context.write(new Text(""), new IntWritable(0));  
100.   
101.           
102.         }  
103.    
104.           
105.          @Override  
106.         protected void cleanup(Context context)  
107.                 throws IOException, InterruptedException {  
108.           
109.                
110.              logger.info("清空任务了。。。。。。");  
111.         }  
112.           
113.     }  
114.       
115.       
116.     private static class  FileReduce extends Reducer<Object, Object, Object, Object>{  
117.           
118.           
119.         @Override  
120.         protected void reduce(Object arg0, Iterable<Object> arg1,  
121.                  Context arg2)throws IOException, InterruptedException {  
122.                
123.               
124.             System.out.println("我是reduce里面的东西");  
125.         }  
126.     }  
127.       
128.       
129.       
130.     public static void main(String[] args)throws Exception {  
131.           
132.           
133.         JobConf conf=new JobConf(TestDistributed.class);  
134.         //conf.set("mapred.local.dir", "/root/hadoop");  
135.          //Configuration conf=new Configuration();  
136.           
137.         // conf.set("mapred.job.tracker","192.168.75.130:9001");  
138.         //读取person中的数据字段  
139.            //conf.setJar("tt.jar");  
140.            
141.         //注意这行代码放在最前面，进行初始化，否则会报  
142.          String inputPath="hdfs://192.168.75.130:9000/root/input";        
143.          String outputPath="hdfs://192.168.75.130:9000/root/outputsort";  
144.            
145.         Job job=new Job(conf, "a");  
146.         DistributedCache.addCacheFile(new URI("hdfs://192.168.75.130:9000/root/input/f1.txt"), job.getConfiguration());  
147.         job.setJarByClass(TestDistributed.class);  
148.         System.out.println("运行模式：  "+conf.get("mapred.job.tracker"));  
149.         /**设置输出表的的信息  第一个参数是job任务，第二个参数是表名，第三个参数字段项**/  
150.        FileSystem fs=FileSystem.get(job.getConfiguration());  
151.           
152.           Path pout=new Path(outputPath);  
153.           if(fs.exists(pout)){  
154.               fs.delete(pout, true);  
155.               System.out.println("存在此路径, 已经删除......");  
156.           }   
157.          /**设置Map类**/  
158.         // job.setOutputKeyClass(Text.class);  
159.          //job.setOutputKeyClass(IntWritable.class);  
160.           job.setMapOutputKeyClass(Text.class);  
161.           job.setMapOutputValueClass(IntWritable.class);  
162.          job.setMapperClass(FileMapper.class);  
163.          job.setReducerClass(FileReduce.class);  
164.          FileInputFormat.setInputPaths(job, new Path(inputPath));  //输入路径  
165.          FileOutputFormat.setOutputPath(job, new Path(outputPath));//输出路径    
166.           
167.         System.exit(job.waitForCompletion(true) ? 0 : 1);    
168.           
169.           
170.           
171.     }  
172.       
173.       
174.       
175.   
176. }  

package com.qin.testdistributed;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.net.URI;
import java.util.Scanner;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.filecache.DistributedCache;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.db.DBConfiguration;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.log4j.pattern.LogEvent;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.qin.operadb.WriteMapDB;
 

/**
 * 测试hadoop的全局共享文件
 * 使用DistributedCached
 * 
 * 大数据技术交流群： 37693216
 * @author qindongliang
 * 
 * ***/
public class TestDistributed {
	
	
	private static Logger logger=LoggerFactory.getLogger(TestDistributed.class);
	
	
	
	
	
	private static class FileMapper extends Mapper<LongWritable, Text, Text, IntWritable>{
		
	     	Path path[]=null;
	     	
		/**
		 * Map函数前调用
		 * 
		 * */
		@Override
		protected void setup(Context context)
				throws IOException, InterruptedException {
		  logger.info("开始启动setup了哈哈哈哈");
		    // System.out.println("运行了.........");
		  Configuration conf=context.getConfiguration();
		   path=DistributedCache.getLocalCacheFiles(conf);
	       System.out.println("获取的路径是：  "+path[0].toString());
	     //  FileSystem fs = FileSystem.get(conf);
	       FileSystem fsopen= FileSystem.getLocal(conf);
	     FSDataInputStream in = fsopen.open(path[0]);
	      // System.out.println(in.readLine());
//	       for(Path tmpRefPath : path) {
//	           if(tmpRefPath.toString().indexOf("ref.png") != -1) {
//	               in = reffs.open(tmpRefPath);
//	               break;
//	           }
//	       }
	       
     // FileReader reader=new FileReader("file://"+path[0].toString());
//      File f=new File("file://"+path[0].toString());
      // FSDataInputStream in=fs.open(new Path(path[0].toString()));
	     Scanner scan=new Scanner(in);
	       while(scan.hasNext()){
	    	   System.out.println(Thread.currentThread().getName()+"扫描的内容:  "+scan.next());
	       }
	       scan.close();
//		
		// System.out.println("size: "+path.length);
			
			
		}
		
		
		@Override
		protected void map(LongWritable key, Text value,Context context)
				throws IOException, InterruptedException {
		 
		//	System.out.println("map    aaa");
			//logger.info("Map里的任务");
			System.out.println("map里输出了");
		//	logger.info();
			context.write(new Text(""), new IntWritable(0));

		
		}
 
		
		 @Override
		protected void cleanup(Context context)
				throws IOException, InterruptedException {
		
			 
			 logger.info("清空任务了。。。。。。");
		}
		
	}
	
	
	private static class  FileReduce extends Reducer<Object, Object, Object, Object>{
		
		
		@Override
		protected void reduce(Object arg0, Iterable<Object> arg1,
				 Context arg2)throws IOException, InterruptedException {
			 
			
			System.out.println("我是reduce里面的东西");
		}
	}
	
	
	
	public static void main(String[] args)throws Exception {
		
		
		JobConf conf=new JobConf(TestDistributed.class);
		//conf.set("mapred.local.dir", "/root/hadoop");
		 //Configuration conf=new Configuration();
		
	    // conf.set("mapred.job.tracker","192.168.75.130:9001");
		//读取person中的数据字段
	  	   //conf.setJar("tt.jar");
		 
		//注意这行代码放在最前面，进行初始化，否则会报
		 String inputPath="hdfs://192.168.75.130:9000/root/input";	    
		 String outputPath="hdfs://192.168.75.130:9000/root/outputsort";
		 
		Job job=new Job(conf, "a");
		DistributedCache.addCacheFile(new URI("hdfs://192.168.75.130:9000/root/input/f1.txt"), job.getConfiguration());
		job.setJarByClass(TestDistributed.class);
		System.out.println("运行模式：  "+conf.get("mapred.job.tracker"));
		/**设置输出表的的信息  第一个参数是job任务，第二个参数是表名，第三个参数字段项**/
	   FileSystem fs=FileSystem.get(job.getConfiguration());
		
		  Path pout=new Path(outputPath);
		  if(fs.exists(pout)){
			  fs.delete(pout, true);
			  System.out.println("存在此路径, 已经删除......");
		  } 
		 /**设置Map类**/
		// job.setOutputKeyClass(Text.class);
		 //job.setOutputKeyClass(IntWritable.class);
		  job.setMapOutputKeyClass(Text.class);
		  job.setMapOutputValueClass(IntWritable.class);
		 job.setMapperClass(FileMapper.class);
	     job.setReducerClass(FileReduce.class);
		 FileInputFormat.setInputPaths(job, new Path(inputPath));  //输入路径
         FileOutputFormat.setOutputPath(job, new Path(outputPath));//输出路径  
		
		System.exit(job.waitForCompletion(true) ? 0 : 1);  
		
		
		
	}
	
	
	

}

在web页面上，查询日志输入情况，如下截图所示


当然，我们也可以根据web上的路径，到对应的日志目录下，查找日志的内容，看到上图就说明，我们上传的共享文件，读取成功了，只要在setup方法里面进行初始化后，对我们的程序来说，就是全局共享了，然后我们就可以结合我们的业务逻辑，来处理一些事了。



最后，在简单总结一下：DistributedCache文件共享的模式，只能在集群的环境中使用，如果在Local模式下测试，就会报如下的文件找不到异常：

Java代码  

1. 运行模式：  local  
2. 存在此路径, 已经删除......  
3. WARN - NativeCodeLoader.<clinit>(52) | Unable to load native-hadoop library for your platform... using builtin-java classes where applicable  
4. WARN - JobClient.copyAndConfigureFiles(746) | Use GenericOptionsParser for parsing the arguments. Applications should implement Tool for the same.  
5. WARN - JobClient.copyAndConfigureFiles(870) | No job jar file set.  User classes may not be found. See JobConf(Class) or JobConf#setJar(String).  
6. INFO - FileInputFormat.listStatus(237) | Total input paths to process : 1  
7. WARN - LoadSnappy.<clinit>(46) | Snappy native library not loaded  
8. INFO - TrackerDistributedCacheManager.downloadCacheObject(423) | Creating f1.txt in /root/hadoop1.2/hadooptmp/mapred/local/archive/-4778653900406898379_1788685676_88844454/192.168.75.130/root/input-work--1953076903080970848 with rwxr-xr-x  
9. INFO - TrackerDistributedCacheManager.downloadCacheObject(463) | Cached hdfs://192.168.75.130:9000/root/input/f1.txt as /root/hadoop1.2/hadooptmp/mapred/local/archive/-4778653900406898379_1788685676_88844454/192.168.75.130/root/input/f1.txt  
10. INFO - TrackerDistributedCacheManager.localizePublicCacheObject(486) | Cached hdfs://192.168.75.130:9000/root/input/f1.txt as /root/hadoop1.2/hadooptmp/mapred/local/archive/-4778653900406898379_1788685676_88844454/192.168.75.130/root/input/f1.txt  
11. INFO - JobClient.monitorAndPrintJob(1380) | Running job: job_local697121855_0001  
12. INFO - LocalJobRunner$Job.run(340) | Waiting for map tasks  
13. INFO - LocalJobRunner$Job$MapTaskRunnable.run(204) | Starting task: attempt_local697121855_0001_m_000000_0  
14. INFO - Task.initialize(534) |  Using ResourceCalculatorPlugin : null  
15. INFO - MapTask.runNewMapper(729) | Processing split: hdfs://192.168.75.130:9000/root/input/f1.txt:0+31  
16. INFO - MapTask$MapOutputBuffer.<init>(949) | io.sort.mb = 100  
17. INFO - MapTask$MapOutputBuffer.<init>(961) | data buffer = 79691776/99614720  
18. INFO - MapTask$MapOutputBuffer.<init>(962) | record buffer = 262144/327680  
19. INFO - TestDistributed$FileMapper.setup(60) | 开始启动setup了哈哈哈哈  
20. 获取的路径是：  /root/hadoop1.2/hadooptmp/mapred/local/archive/-4778653900406898379_1788685676_88844454/192.168.75.130/root/input/f1.txt  
21. INFO - MapTask$MapOutputBuffer.flush(1289) | Starting flush of map output  
22. INFO - LocalJobRunner$Job.run(348) | Map task executor complete.  
23. WARN - LocalJobRunner$Job.run(435) | job_local697121855_0001  
24. java.lang.Exception: java.io.FileNotFoundException: File /root/hadoop1.2/hadooptmp/mapred/local/archive/-4778653900406898379_1788685676_88844454/192.168.75.130/root/input/f1.txt does not exist.  
25.     at org.apache.hadoop.mapred.LocalJobRunner$Job.run(LocalJobRunner.java:354)  
26. Caused by: java.io.FileNotFoundException: File /root/hadoop1.2/hadooptmp/mapred/local/archive/-4778653900406898379_1788685676_88844454/192.168.75.130/root/input/f1.txt does not exist.  
27.     at org.apache.hadoop.fs.RawLocalFileSystem.getFileStatus(RawLocalFileSystem.java:402)  
28.     at org.apache.hadoop.fs.FilterFileSystem.getFileStatus(FilterFileSystem.java:255)  
29.     at org.apache.hadoop.fs.ChecksumFileSystem$ChecksumFSInputChecker.<init>(ChecksumFileSystem.java:125)  
30.     at org.apache.hadoop.fs.ChecksumFileSystem.open(ChecksumFileSystem.java:283)  
31.     at org.apache.hadoop.fs.FileSystem.open(FileSystem.java:427)  
32.     at com.qin.testdistributed.TestDistributed$FileMapper.setup(TestDistributed.java:67)  
33.     at org.apache.hadoop.mapreduce.Mapper.run(Mapper.java:142)  
34.     at org.apache.hadoop.mapred.MapTask.runNewMapper(MapTask.java:764)  
35.     at org.apache.hadoop.mapred.MapTask.run(MapTask.java:364)  
36.     at org.apache.hadoop.mapred.LocalJobRunner$Job$MapTaskRunnable.run(LocalJobRunner.java:223)  
37.     at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471)  
38.     at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:334)  
39.     at java.util.concurrent.FutureTask.run(FutureTask.java:166)  
40.     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1110)  
41.     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)  
42.     at java.lang.Thread.run(Thread.java:722)  
43. INFO - JobClient.monitorAndPrintJob(1393) |  map 0% reduce 0%  
44. INFO - JobClient.monitorAndPrintJob(1448) | Job complete: job_local697121855_0001  
45. INFO - Counters.log(585) | Counters: 0  

运行模式：  local
存在此路径, 已经删除......
WARN - NativeCodeLoader.<clinit>(52) | Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
WARN - JobClient.copyAndConfigureFiles(746) | Use GenericOptionsParser for parsing the arguments. Applications should implement Tool for the same.
WARN - JobClient.copyAndConfigureFiles(870) | No job jar file set.  User classes may not be found. See JobConf(Class) or JobConf#setJar(String).
INFO - FileInputFormat.listStatus(237) | Total input paths to process : 1
WARN - LoadSnappy.<clinit>(46) | Snappy native library not loaded
INFO - TrackerDistributedCacheManager.downloadCacheObject(423) | Creating f1.txt in /root/hadoop1.2/hadooptmp/mapred/local/archive/-4778653900406898379_1788685676_88844454/192.168.75.130/root/input-work--1953076903080970848 with rwxr-xr-x
INFO - TrackerDistributedCacheManager.downloadCacheObject(463) | Cached hdfs://192.168.75.130:9000/root/input/f1.txt as /root/hadoop1.2/hadooptmp/mapred/local/archive/-4778653900406898379_1788685676_88844454/192.168.75.130/root/input/f1.txt
INFO - TrackerDistributedCacheManager.localizePublicCacheObject(486) | Cached hdfs://192.168.75.130:9000/root/input/f1.txt as /root/hadoop1.2/hadooptmp/mapred/local/archive/-4778653900406898379_1788685676_88844454/192.168.75.130/root/input/f1.txt
INFO - JobClient.monitorAndPrintJob(1380) | Running job: job_local697121855_0001
INFO - LocalJobRunner$Job.run(340) | Waiting for map tasks
INFO - LocalJobRunner$Job$MapTaskRunnable.run(204) | Starting task: attempt_local697121855_0001_m_000000_0
INFO - Task.initialize(534) |  Using ResourceCalculatorPlugin : null
INFO - MapTask.runNewMapper(729) | Processing split: hdfs://192.168.75.130:9000/root/input/f1.txt:0+31
INFO - MapTask$MapOutputBuffer.<init>(949) | io.sort.mb = 100
INFO - MapTask$MapOutputBuffer.<init>(961) | data buffer = 79691776/99614720
INFO - MapTask$MapOutputBuffer.<init>(962) | record buffer = 262144/327680
INFO - TestDistributed$FileMapper.setup(60) | 开始启动setup了哈哈哈哈
获取的路径是：  /root/hadoop1.2/hadooptmp/mapred/local/archive/-4778653900406898379_1788685676_88844454/192.168.75.130/root/input/f1.txt
INFO - MapTask$MapOutputBuffer.flush(1289) | Starting flush of map output
INFO - LocalJobRunner$Job.run(348) | Map task executor complete.
WARN - LocalJobRunner$Job.run(435) | job_local697121855_0001
java.lang.Exception: java.io.FileNotFoundException: File /root/hadoop1.2/hadooptmp/mapred/local/archive/-4778653900406898379_1788685676_88844454/192.168.75.130/root/input/f1.txt does not exist.
	at org.apache.hadoop.mapred.LocalJobRunner$Job.run(LocalJobRunner.java:354)
Caused by: java.io.FileNotFoundException: File /root/hadoop1.2/hadooptmp/mapred/local/archive/-4778653900406898379_1788685676_88844454/192.168.75.130/root/input/f1.txt does not exist.
	at org.apache.hadoop.fs.RawLocalFileSystem.getFileStatus(RawLocalFileSystem.java:402)
	at org.apache.hadoop.fs.FilterFileSystem.getFileStatus(FilterFileSystem.java:255)
	at org.apache.hadoop.fs.ChecksumFileSystem$ChecksumFSInputChecker.<init>(ChecksumFileSystem.java:125)
	at org.apache.hadoop.fs.ChecksumFileSystem.open(ChecksumFileSystem.java:283)
	at org.apache.hadoop.fs.FileSystem.open(FileSystem.java:427)
	at com.qin.testdistributed.TestDistributed$FileMapper.setup(TestDistributed.java:67)
	at org.apache.hadoop.mapreduce.Mapper.run(Mapper.java:142)
	at org.apache.hadoop.mapred.MapTask.runNewMapper(MapTask.java:764)
	at org.apache.hadoop.mapred.MapTask.run(MapTask.java:364)
	at org.apache.hadoop.mapred.LocalJobRunner$Job$MapTaskRunnable.run(LocalJobRunner.java:223)
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471)
	at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:334)
	at java.util.concurrent.FutureTask.run(FutureTask.java:166)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1110)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
	at java.lang.Thread.run(Thread.java:722)
INFO - JobClient.monitorAndPrintJob(1393) |  map 0% reduce 0%
INFO - JobClient.monitorAndPrintJob(1448) | Job complete: job_local697121855_0001
INFO - Counters.log(585) | Counters: 0

如果你很幸运，在1.x的hadoop里看到如下所示的异常，那么你应该考虑如下的几个问题，第一，是不是以Local模式启动的MR任务，第二读取时的路径是不是有问题，使用DistributedCache共享的文件，会在我们每个节点上配置的目录里面找到对应的共享文件：

Xml代码  

1. <?xml version="1.0"?>  
2. <?xml-stylesheet type="text/xsl" href="configuration.xsl"?>  
3.   
4. <!-- Put site-specific property overrides in this file. -->  
5.   
6. <configuration>  
7. <!-- jobtracker的master地址-->  
8. <property>   
9. <name>mapred.job.tracker</name>   
10. <value>192.168.75.130:9001</value>   
11. </property>  
12. <property>  
13. <!-- hadoop的日志输出指定目录-->  
14. <name>mapred.local.dir</name>  
15. <value>/root/hadoop1.2/mylogs</value>  
16. </property>  
17.   
18. </configuration>  

<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>

<!-- Put site-specific property overrides in this file. -->

<configuration>
<!-- jobtracker的master地址-->
<property> 
<name>mapred.job.tracker</name> 
<value>192.168.75.130:9001</value> 
</property>
<property>
<!-- hadoop的日志输出指定目录-->
<name>mapred.local.dir</name>
<value>/root/hadoop1.2/mylogs</value>
</property>

</configuration>

共享的文件，会被下载到每个节点上的指定的文件夹里找到。
散仙找的一个的路径：
/root/hadoop1.2/mylogs/taskTracker/distcache/2726204645197711229_1788685676_88844454/192.168.75.130/root/input
其他的节点上也一样，只不过IP地址不一样，截图如下：



至此，我们就可以使用轻松的来使用DistributedCache来共享一些比较大的文件，或压缩包了。