Hadoop WordCount 详解

mapreduce运行机制，这些按照时间顺序包括：输入分片（input split）、map阶段、combiner阶段、shuffle阶段和reduce阶段。

 

输入分片（input split）：InputSplit是Hadoop定义的用来传送给每个单独的map的数据，在进行map计算之前，mapreduce会根据输入文件计算输入分片（input split），每个输入分片（input split）针对一个map任务，InputSplit存储的并非数据本身，而是一个分片长度和一个记录数据位置的数组，输入分片（input split）往往和hdfs的block（块）关系很密切，假如我们设定hdfs的块的大小是64mb，如果我们输入有三个文件，大小分别是3mb、65mb和127mb，那么mapreduce会把3mb文件分为一个输入分片（input split），65mb则是两个输入分片（input split）而127mb也是两个输入分片（input split），换句话说我们如果在map计算前做输入分片调整，例如合并小文件，那么就会有5个map任务将执行，而且每个map执行的数据大小不均，这个也是mapreduce优化计算的一个关键点。

生成InputSplit的方法可以通过InputFormat()来设置。hadoop将数据给到map进行处理前会使用InputFormat对数据进行两方面的预处理：

1）对输入数据进行切分，生成一组split，一个split会分发给一个mapper进行处理。

2）针对每个split，InputFormat则调用getRecordReader()方法生成RecordReader，RecordReader再通过creatKey()，creatValue()方法创建可供map处理的<key,value>对。简而言之，InputFormat()方式是用来生成可供map处理的<key,value>对的。

最常见的InputFormat就是TextInputFormat，在split的读取方面,它是将给到的Split按行读取,以行首字节在文件中的偏移做key,以行数据做value传给map函数处理,这部分的逻辑是由它所创建并使用的RecordReader:LineRecordReader封装和实现的。

 

Hadoop预定义了多种方法将不同类型的输入数据转化为map能够处理的<key,value>对，它们都继承自InputFormat，分别是：

  BaileyBorweinPlouffe.BbpInputFormat

  ComposableInputFormat

  CompositeInputFormat

  DBInputFormat

  DistSum.Macheine.AbstractInputFormat

  FileInputFormat

  其中FileInputFormat又有多个子类，分别为：

  CombineFileInputFormat

  KeyValueTextInputFormat

  NLineInputFormat

  SequenceFileInputFormat

  TeraInputFormat

  TextInputFormat

  其中，TextInputFormat是Hadoop默认的输入方法，在TextInputFormat中，每个文件(或其一部分)都会单独地作为map的输入，而这是继承自FileInputFormat的。之后，每行数据都会生成一条记录，每条记录则表示为<key,value>形式：key值是每个数据的记录在数据分片中的字节偏移量，数据类型是LongWritable；value值是每行的内容，数据类型是Text。

  也就是说，输入数据会以如下的形式被传入map中：

  file1:

  0 Hello World and Hello Hadoop

  file2:

  0 Hello Hadoop and Hello World

  因为file1和file2都会被单独输入到一个map中，因为它们的key值都是0。

 

关于这部分逻辑,在一开始接触hadoop时会有一个常见的疑问:如果一个行被切分到两个split里(这几乎是一定会发生的情况),TextInputFormat是如何处理的?

参照：http://blog.csdn.net/bluishglc/article/details/9380087

 

图4-1 分割过程

    

map阶段：就是程序员编写好的map函数了，因此map函数效率相对好控制，而且一般map操作都是本地化操作也就是在数据存储节点上进行；

图4-2 执行map方法

 

combiner阶段：combiner阶段是程序员可以选择的，combiner其实也是一种reduce操作，因此我们看见WordCount类里是用reduce进行加载的。Combiner是一个本地化的reduce操作，它是map运算的后续操作，主要是在map计算出中间文件前做一个简单的合并重复key值的操作，例如我们对文件里的单词频率做统计，map计算时候如果碰到一个hadoop的单词就会记录为1，但是这篇文章里hadoop可能会出现n多次，那么map输出文件冗余就会很多，因此在reduce计算前对相同的key做一个合并操作，那么文件会变小，这样就提高了宽带的传输效率，毕竟hadoop计算力宽带资源往往是计算的瓶颈也是最为宝贵的资源，但是combiner操作是有风险的，使用它的原则是combiner的输入不会影响到reduce计算的最终输入，例如：如果计算只是求总数，最大值，最小值可以使用combiner，但是做平均值计算使用combiner的话，最终的reduce计算结果就会出错。

每一个map都可能会产生大量的本地输出，Combiner的作用就是对map端的输出先做一次合并，以减少在map和reduce节点之间的数据传输量，以提高网络IO性能，是MapReduce的一种优化手段之一。
        1）、Combiner最基本是实现本地key的聚合，对map输出的key排序、value进行迭代。如下所示：

引用
        map:(key1,value1) ——> list(key2,value2)
        conbine:(key2,list(value2)) ——> list(key2,value2)
        reduce:(key2,list(value2)) ——> list(key3,value3)
       

        2）、Combiner还有本地reduce功能（其本质上就是一个reduce）：

引用
        map:(key1,value1) ——> list(key2,value2)
        conbine:(key2,list(value2)) ——> list(key3,value3)
        reduce:(key3,list(value3)) ——> list(key4,value4)
       

 

得到map方法输出的<key,value>对后，Mapper会将它们按照key值进行排序，并执行Combine过程，将key至相同value值累加，得到Mapper的最终输出结果。如图4-3所示。

 

图4-3 Map端排序及Combine过程

 

 

Partion阶段：partition是分割map每个节点的结果，按照key分别映射给不同的reduce，也是可以自定义的。这里其实可以理解归类。
我们对于错综复杂的数据归类。比如在动物园里有牛羊鸡鸭鹅，他们都是混在一起的，但是到了晚上他们就各自牛回牛棚，羊回羊圈，鸡回鸡窝。partition的作用就是把这些数据归类。只不过在写程序的时候，mapreduce使用哈希HashPartitioner帮我们归类了。这个我们也可以自定义。

Partion阶段的详细解析：

http://www.cnblogs.com/xwdreamer/archive/2011/10/27/2296943.html

shuffle阶段：shuffle阶段通俗理解为shuffle就是map和reduce之间的过程，包含了两端的combine和partition。

将map的输出作为reduce的输入的过程就是shuffle了，这个是mapreduce优化的重点地方。这里我不讲怎么优化shuffle阶段，讲讲shuffle阶段的原理，因为大部分的书籍里都没讲清楚shuffle阶段。Shuffle一开始就是map阶段做输出操作，一般mapreduce计算的都是海量数据，map输出时候不可能把所有文件都放到内存操作，因此map写入磁盘的过程十分的复杂，更何况map输出时候要对结果进行排序，内存开销是很大的，map在做输出时候会在内存里开启一个环形内存缓冲区，这个缓冲区专门用来输出的，默认大小是100mb，并且在配置文件里为这个缓冲区设定了一个阀值，默认是0.80（这个大小和阀值都是可以在配置文件里进行配置的），同时map还会为输出操作启动一个守护线程，如果缓冲区的内存达到了阀值的80%时候，这个守护线程就会把内容写到磁盘上，这个过程叫spill，另外的20%内存可以继续写入要写进磁盘的数据，写入磁盘和写入内存操作是互不干扰的，如果缓存区被撑满了，那么map就会阻塞写入内存的操作，让写入磁盘操作完成后再继续执行写入内存操作，前面我讲到写入磁盘前会有个排序操作，这个是在写入磁盘操作时候进行，不是在写入内存时候进行的，如果我们定义了combiner函数，那么排序前还会执行combiner操作。每次spill操作也就是写入磁盘操作时候就会写一个溢出文件，也就是说在做map输出有几次spill就会产生多少个溢出文件，等map输出全部做完后，map会合并这些输出文件。这个过程里还会有一个Partitioner操作，对于这个操作很多人都很迷糊，其实Partitioner操作和map阶段的输入分片（Input split）很像，一个Partitioner对应一个reduce作业，如果我们mapreduce操作只有一个reduce操作，那么Partitioner就只有一个，如果我们有多个reduce操作，那么Partitioner对应的就会有多个，Partitioner因此就是reduce的输入分片，这个程序员可以编程控制，主要是根据实际key和value的值，根据实际业务类型或者为了更好的reduce负载均衡要求进行，这是提高reduce效率的一个关键所在。到了reduce阶段就是合并map输出文件了，Partitioner会找到对应的map输出文件，然后进行复制操作，复制操作时reduce会开启几个复制线程，这些线程默认个数是5个，程序员也可以在配置文件更改复制线程的个数，这个复制过程和map写入磁盘过程类似，也有阀值和内存大小，阀值一样可以在配置文件里配置，而内存大小是直接使用reduce的tasktracker的内存大小，复制时候reduce还会进行排序操作和合并文件操作，这些操作完了就会进行reduce计算了。

源代码：

package com.fresh;

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

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;

public class Wordcount {
     public static class TokenizerMapper extends
               Mapper<Object, Text, Text, IntWritable> {
          // 规定map中用到的数据类型，这里的Text相当于jdk中的String IntWritable相当于jdk的int类型，
          // 这样做的原因主要是为了hadoop的数据序化而做的。

          private final static IntWritable one = new IntWritable(1);
          // 声时一个IntWritable变量，作计数用，每出现一个key，给其一个value=1的值
          private Text word = new Text();// 用来暂存map输出中的key值，Text类型的

          public void map(Object key, Text value, Context context)
                    throws IOException, InterruptedException {
               // 这就是map函数，它是和Mapper抽象类中的相对应的，此处的Object key,Text value的类型和上边的Object,
               // Text是相对应的，而且最好一样，不然的话，多数情况运行时会报错。
               StringTokenizer itr = new StringTokenizer(value.toString());
               // Hadoop读入的value是以行为单位的，其key为该行所对应的行号，因为我们要计算每个单词的数目，(此处的行号为字节的数目，即该行首字母在该文件中所处的字符位置)
               // 此处的<key,value>值为<0,Hello World>
               // 默认以空格作为间隔，故用StringTokenizer辅助做字符串的拆分，也可以用string.split("")来作分隔。
               System.out.println("value:"+value.toString());
               System.out.println("key:"+key.toString());
              
               while (itr.hasMoreTokens()) { // 遍历一下每行字符串中的单词
                    word.set(itr.nextToken()); // 出现一个单词就给它设成一个key并将其值设为1
                    //此处word为各个单词
                    //如Hello World hello hadoop 等
                    System.out.println("word:"+word.toString());
                    context.write(word, one); // 输出设成的key/value值
                    // 上面就是map打散的过程
                    //输出结果为
                    //value:Hello World
                    //key:0
                    //word:Hello
                    //word:World
                    //value:Hello hadoop
                    //key:16
                    //word:Hello
                    //word:hadoop
               }
          }
     }

     public static class IntSumReducer extends
               Reducer<Text, IntWritable, Text, IntWritable> {
          // reduce的静态类，这里和Map中的作用是一样的，设定输入/输出的值的类型
          private IntWritable result = new IntWritable();

          public void reduce(Text key, Iterable<IntWritable> values,
                    Context context) throws IOException, InterruptedException {
               int sum = 0;
               for (IntWritable val : values) {
                    System.out.print("val:"+val+" ");
                    System.out.println();
                    // 由于map的打散，这里会得到如，{key,values}={"hello",{1,1,....}},这样的集合
                    sum += val.get();
                    // 这里需要逐一将它们的value取出来予以相加，取得总的出现次数，即为汇和
               }
               result.set(sum); // 将values的和取得，并设成result对应的值
               context.write(key, result);
               // 此时的key即为map打散之后输出的key，没有变化，变化的时result,以前得到的是一个数字的集合，
               // 已经给算出和了，并做为key/value输出。
          }
     }

     public static void main(String[] args) throws Exception {
         
          Configuration conf = new Configuration(); // 取得系统的参数
         
          conf.set("mapred.job.tracker", "10.254.188.101:50030");
          //String[] otherArgs = new GenericOptionsParser(conf, args)
          //          .getRemainingArgs();
         
          String[] ioArgs=new String[]{"hdfs://10.254.188.101:8020/user/hadoop/in/","hdfs://10.254.188.101:8020/user/hadoop/out"};
          String[] otherArgs = new GenericOptionsParser(conf, ioArgs).getRemainingArgs();
         
          if (otherArgs.length != 2) {
               // 判断一下命令行输入路径/输出路径是否齐全，即是否为两个参数
               System.err.println("Usage: wordcount <in> <out>");
               System.exit(2); // 若非两个参数，即退出
          }
         
          FileSystem fileSystem = FileSystem.get(new URI(ioArgs[1]),conf);
          Path outpath = new Path(ioArgs[1]);
          if(fileSystem.exists(outpath))
               fileSystem.delete(outpath,true);
         
          Job job = new Job(conf, "word count");
          // 此程序的执行，在hadoop看来是一个Job，故进行初始化job操作
          job.setJarByClass(Wordcount.class);
          // 可以认为成，此程序要执行MyWordCount.class这个字节码文件
          job.setMapperClass(TokenizerMapper.class);
          // 在这个job中，我用TokenizerMapper这个类的map函数
          job.setCombinerClass(IntSumReducer.class);
          job.setReducerClass(IntSumReducer.class);
          // 在这个job中，我用IntSumReducer这个类的reduce函数
          job.setOutputKeyClass(Text.class);
          // 在reduce的输出时，key的输出类型为Text
          job.setOutputValueClass(IntWritable.class);
          // 在reduce的输出时,value的输出类型为IntWritable
          FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
          // 初始化要计算word的文件的路径
          FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
          // 初始化要计算word的文件的之后的结果的输出路径
          System.exit(job.waitForCompletion(true) ? 0 : 1);
          // 提交job到hadoop上去执行了，意思是指如果这个job真正的执行完了则主函数退出了，若没有真正的执行完就退出了。
     }

参考资料：

http://www.linuxidc.com/Linux/2013-04/82751p2.htm

http://www.cnblogs.com/zhengyuhong/p/3958370.html

http://blog.csdn.net/moxiaomomo/article/details/15676575

http://zhidao.baidu.com/link?url=3RqQ33twD6OdAxNyGQC_ztmlvnNvvus_zloTfJTlIpqmXTi2ZLJOkTWE85TmU1q2mcaj9QswBlpE-SSk3VkQ4q

http://www.cnblogs.com/xwdreamer/archive/2011/10/27/2296943.html

http://www.aboutyun.com/thread-7104-1-1.html

http://bbs.csdn.net/topics/390536510

http://www.01yun.com/web/20130329/286636.html

源代码：