hadoop DistributedCache

refer to :http://dongxicheng.org/mapreduce-nextgen/hadoop-distributedcache-details/

DistributedCache是Hadoop提供的文件缓存工具，它能够自动将指定的文件分发到各个节点上，缓存到本地，供用户程序读取使用。它具有以下几个特点：缓存的文件是只读的，修改这些文件内容没有意义；用户可以调整文件可见范围（比如只能用户自己使用，所有用户都可以使用等），进而防止重复拷贝现象；按需拷贝，文件是通过HDFS作为共享数据中心分发到各节点的，且只发给任务被调度到的节点。本文将介绍DistributedCache在Hadoop 1.0和2.0中的使用方法及实现原理。

Hadoop DistributedCache有以下几种典型的应用场景：1）分发字典文件，一些情况下Mapper或者Reducer需要用到一些外部字典，比如黑白名单、词表等；2）map-side join：当多表连接时，一种场景是一个表很大，一个表很小，小到足以加载到内存中，这时可以使用DistributedCache将小表分发到各个节点上，以供Mapper加载使用；3）自动化软件部署：有些情况下，MapReduce需依赖于特定版本的库，比如依赖于某个版本的PHP解释器，一种做法是让集群管理员把这个版本的PHP装到各个机器上，这通常比较麻烦，另一种方法是使用DistributedCache分发到各个节点上，程序运行完后，Hadoop自动将其删除。

Hadoop提供了两种DistributedCache使用方式，一种是通过API，在程序中设置文件路径，另外一种是通过命令行（-files，-archives或-libjars）参数告诉Hadoop，个人建议使用第二种方式，该方式可使用以下三个参数设置文件：

（1）-files：将指定的本地/hdfs文件分发到各个Task的工作目录下，不对文件进行任何处理；

（2）-archives：将指定文件分发到各个Task的工作目录下，并对名称后缀为“.jar”、“.zip”，“.tar.gz”、“.tgz”的文件自动解压，默认情况下，解压后的内容存放到工作目录下名称为解压前文件名的目录中，比如压缩包为dict.zip,则解压后内容存放到目录dict.zip中。为此，你可以给文件起个别名/软链接，比如dict.zip#dict，这样，压缩包会被解压到目录dict中。

（3）-libjars：指定待分发的jar包，Hadoop将这些jar包分发到各个节点上后，会将其自动添加到任务的CLASSPATH环境变量中。

前面提到，DistributedCache分发的文件是有可见范围的，有的文件可以只对当前程序可见，程序运行完后，直接删除；有的文件只对当前用户可见（该用户所有程序都可以访问）；有的文件对所有用户可见。DistributedCache会为每种资源（文件）计算一个唯一ID，以识别每个资源，从而防止资源重复下载，举个例子，如果文件可见范围是所有用户，则在每个节点上，第一个使用该文件的用户负责缓存该文件，之后的用户直接使用即可，无需重复下载。那么，Hadoop是怎样区分文件可见范围的呢？

在Hadoop 1.0版本中，Hadoop是以HDFS文件的属性作为标识判断文件可见性的，需要注意的是，待缓存的文件即使是在Hadoop提交作业的客户端上，也会首先上传到HDFS的某一目录下，再分发到各个节点上的，因此，HDFS是缓存文件的必经之路。对于经常使用的文件或者字典，建议放到HDFS上，这样可以防止每次重复下载，做法如下：

比如将数据保存在HDFS的/dict/public目录下，并将/dict和/dict/public两层目录的可执行权限全部打开（在Hadoop中，可执行权限的含义与linux中的不同，该权限只对目录有意义，表示可以查看该目录中的子目录），这样，里面所有的资源（文件）便是所有用户可用的，并且第一个用到的应用程序会将之缓存到各个节点上，之后所有的应用程序无需重复下载，可以在提交作业时通过以下命令指定：

-files hdfs:///dict/public/blacklist.txt, hdfs:///dict/public/whilelist.txt

如果有多个HDFS集群可以指定namenode的对外rpc地址：

-files hdfs://host:port/dict/public/blacklist.txt, hdfs://host:port/dict/public/whilelist.txt

DistributedCache会将blacklist.txt和whilelist.txt两个文件缓存到各个节点的一个公共目录下，并在需要时，在任务的工作目录下建立一个指向这两个文件的软连接。

如果可执行权限没有打开，则默认只对该应用程序的拥有者可见，该用户所有应用程序可共享这些文件。

一旦你对/dict/public下的某个文件进行了修改，则下次有作业用到对应文件时，会发现文件被修改过了，进而自动重新缓存文件。

对于一些频繁使用的字典，不建议存放在客户端，每次通过-files指定，这样的文件，每次都要经历以下流程：上传到HDFS上—》缓存到各个节点上—》之后不再使用这些文件，直到被清除，也就是说，这样的文件，只会被这次运行的应用程序使用，如果再次运行同样的应用程序，即使文件没有被修改，也会重新经历以上流程，非常耗费时间，尤其是字典非常多，非常大时。

DistributedCache内置缓存置换算法，一旦缓存（文件数目达到一定上限或者文件总大小超过某一上限）满了之后，会踢除最久没有使用的文件。

在Hadopo 2.0中，自带的MapReduce框架仍支持1.0的这种DistributedCache使用方式，但DistributedCache本身是由YARN实现的，不再集成到MapReduce中。YARN还提供了很多相关编程接口供用户调用，有兴趣的可以阅读源代码。

下面介绍Hadoop 2.0中，DistributedCache通过命令行分发文件的基本使用方式：

（1）运行Hadoop自带的example例子， dict.txt会被缓存到各个Task的工作目录下，因此，直接像读取本地文件一样，在Mapper和Reducer中，读取dict.txt即可：

1 2 3 4 5 6

bin /Hadoop jar \ share /hadoop/mapreduce/hadoop-mapreduce-examples-2 .2.0.jar \ wordcount \ -files hdfs: ///dict/public/dict .txt \ /test/input \ /test/output

（2）Hadoop Streaming例子，需要通过-files指定mapper和reducer可执行文件或者脚本文件，这些文件就是通过DistributedCache分发到各个节点上的。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#!/bin/bash HADOOP_HOME= /opt/yarn-client INPUT_PATH= /test/input/data OUTPUT_PATH= /test/output/data echo "Clearing output path: $OUTPUT_PATH" $HADOOP_HOME /bin/hadoop fs -rmr $OUTPUT_PATH   ${HADOOP_HOME} /bin/hadoop jar\     ${HADOOP_HOME} /share/hadoop/tools/lib/hadoop-streaming-2 .2.0.jar\    -D mapred.reduce.tasks=2\    -files mapper,reducer\    -input $INPUT_PATH\    -output $OUTPUT_PATH\    -mapper mapper\    -reducer reducer

（3）接下给出一个缓存压缩文件的例子，假设压缩文件为dict.zip，里面存的数据为：

1 2 3 4

data /1 .txt data /2 .txt mapper.list reducer.list

通过-archives参数指定dict.zip后，该文件被解压后，将被缓存（实际上是软连接）到各个Task的工作目录下的dict.zip目录下，组织结构如下：

1 2 3 4 5 6

dict.zip/      data/          1.txt          2.txt      mapper.list      reducer.list

你可以在Mapper或Reducer程序中，使用类似下面的代码读取解压后的文件：

 

1 2 3

File file2 = read(“dict.zip/data/1.txt”, “r”); ……. File file3 = read(“dict.zip/mapper.list”, “r”);

如果你想直接将内容解压到Task工作目录下，而不是子目录dict.zip中，可以用“-files”（注意，不要使用-archives，“-files”指定的文件不会被解压）指定dict.zip，并自己在程序中实现解压缩：

1 2 3 4

#include <cstdlib> ……. system (“unzip –q dict.zip”); //C++代码 ……

总之，Hadoop DistributedCache是一个非常好用的工具，合理的使用它能够解决很多非常困难的问题。

WordCount.javaHadoop的分布式缓存机制使得一个job的所有map或reduce可以访问同一份文件。在任务提交后，hadoop将由-files和-archive选项指定的文件复制到HDFS上（JobTracker的文件系统）。在任务运行前，TaskTracker从JobTracker文件系统复制文件到本地磁盘作为缓存，这样任务就可以访问这些文件。对于job来说，它并不关心文件是从哪儿来的。在使用DistributedCache时，对于本地化文件的访问，通常使用Symbolic Link来访问，这样更方便。通过 URI hdfs://namenode/test/input/file1#myfile 指定的文件在当前工作目录中被符号链接为myfile。这样job里面可直接通过myfile来访问文件，而不用关心该文件在本地的具体路径。

示例如下：

 

package org.myorg;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.net.URI;
import java.util.StringTokenizer;

import java.io.IOException;
import java.util.*;

import org.apache.hadoop.filecache.DistributedCache;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.conf.*;
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapred.*;
import org.apache.hadoop.util.*;

public  class WordCount
{
     public  static  void UseDistributedCacheBySymbolicLink()  throws Exception
    {
        FileReader reader =  new FileReader("god.txt");
        BufferedReader br =  new BufferedReader(reader);
        String s1 =  null;
         while ((s1 = br.readLine()) !=  null)
        {
            System.out.println(s1);
        }
        br.close();
        reader.close();
    }
    

     public  static  class Map  extends MapReduceBase  implements Mapper<LongWritable, Text, Text, IntWritable>
    {

         public  void configure(JobConf job)
        {
            System.out.println("Now, use the distributed cache and syslink");
             try {
                UseDistributedCacheBySymbolicLink();
            }
             catch (Exception e)
            {
                e.printStackTrace();
            }

        }

         private  final  static IntWritable one =  new IntWritable(1);
         private Text word =  new Text();

         public  void map(LongWritable key, Text value, OutputCollector<Text, IntWritable> output, Reporter reporter)  throws IOException
        {
            String line = value.toString();
            StringTokenizer tokenizer =  new StringTokenizer(line);
             while (tokenizer.hasMoreTokens())
            {
                word.set(tokenizer.nextToken());
                output.collect(word, one);
            }
        }
    }

     public  static  class Reduce  extends MapReduceBase  implements Reducer<Text, IntWritable, Text, IntWritable>
    {
         public  void reduce(Text key, Iterator<IntWritable> values, OutputCollector<Text, IntWritable> output, Reporter reporter)  throws IOException
        {
             int sum = 0;
             while (values.hasNext())
            {
                sum += values.next().get();
            }
            output.collect(key,  new IntWritable(sum));
        }
    }

     public  static  void main(String[] args)  throws Exception
    {
        JobConf conf =  new JobConf(WordCount. class);
        conf.setJobName("wordcount");

        conf.setOutputKeyClass(Text. class);
        conf.setOutputValueClass(IntWritable. class);

        conf.setMapperClass(Map. class);
        conf.setCombinerClass(Reduce. class);
        conf.setReducerClass(Reduce. class);

        conf.setInputFormat(TextInputFormat. class);
        conf.setOutputFormat(TextOutputFormat. class);

        FileInputFormat.setInputPaths(conf,  new Path(args[0]));
        FileOutputFormat.setOutputPath(conf,  new Path(args[1]));

        DistributedCache.createSymlink(conf);
        String path = "/xuxm_dev_test_61_pic/in/WordCount.java";
        Path filePath =  new Path(path);
        String uriWithLink = filePath.toUri().toString() + "#" + "god.txt";
        DistributedCache.addCacheFile( new URI(uriWithLink), conf);

        JobClient.runJob(conf);
    }

} 

   执行方法参考http://hadoop.apache.org/common/docs/r0.19.2/cn/mapred_tutorial.html#%E4%BE%8B%E5%AD%90%EF%BC%9AWordCount+v1.0

 

　　程序运行的结果是在jobtracker中的task的log可以看到打印后的/xuxm_dev_test_61_pic/in/WordCount.java文件的内容。