MapReduce

想要对MapReduce有一个快速的认识，可以先看对话讲解MapReduce，有趣。

MapReduce工作原理

MapReduce采用"分而治之"的思想，把对大规模数据集的操作，分发给一个主节点管理下的各个分节点共同完成，然后通过整合各个节点的中间结果，得到最终结果。简单地说，MapReduce就是"任务的分解与结果的汇总"。
在Hadoop中，用于执行MapReduce任务的机器角色有两个：一个是JobTracker；另一个是TaskTracker，JobTracker是用于调度工作的，TaskTracker是用于执行工作的。一个Hadoop集群中只有一台JobTracker。

在分布式计算中，MapReduce框架负责处理了并行编程中分布式存储、工作调度、负载均衡、容错均衡、容错处理以及网络通信等复杂问题，把处理过程高度抽象为两个函数：map和reduce，map负责把任务分解成多个任务，reduce负责把分解后多任务处理的结果汇总起来。

需要注意的是，用MapReduce来处理的数据集（或任务）必须具备这样的特点：待处理的数据集可以分解成许多小的数据集，而且每一个小数据集都可以完全并行地进行处理。

在Hadoop中，每个MapReduce任务都被初始化为一个Job，每个Job又可以分为两种阶段：map阶段和reduce阶段。这两个阶段分别用两个函数表示，即map函数和reduce函数。map函数接收一个<key,value>形式的输入，然后同样产生一个<key,value>形式的中间输出，Hadoop函数接收一个如<key,(list of values)>形式的输入，然后对这个value集合进行处理，每个reduce产生0或1个输出，reduce的输出也是<key,value>形式的。

MapReduce 角色

Client ：作业提交发起者。
JobTracker: 初始化作业，分配作业，与TaskTracker通信，协调整个作业。

TaskTracker：保持JobTracker通信，在分配的数据片段上执行MapReduce任务。 

分解后多任务处理的结果汇总起来。

任务的分配

客户端提交完成后，JobTracker会将作业加入队列，然后进行调度，默认的调度方法是FIFO调试方式。
TaskTracker和JobTracker之间的通信与任务的分配是通过心跳机制完成的。分解后多任务处理的结果汇总起来。

TaskTracker会主动向JobTracker询问是否有作业要做，如果自己可以做，那么就会申请到作业任务，这个任务可以使Map也可能是Reduce任务。

分解后多任务处理的结果汇总起来。

FIFO

Hadoop 中默认的调度器，它先按照作业的优先级高低，再按照到达时间的先后选 择被执行的作业

公平调度器

为任务分配资源的方法，其目的是随着时间的推移，让提交的作业获取等量的集群共享资源，让用户公平地共享集群。具体做法是：当集群上只有一个任务在运行时，它将使用整个集群，当有其他作业提交时，系统会将TaskTracker节点空间的时间片分配给这些新的作业，并保证每个任务都得到大概等量的CPU时间。

容量调度器

支持多个队列，每个队列可配置一定的资源量，每个队列采用 FIFO 调度策略，为了防止同一个用户的作业独占队列中的资源，该调度器会对同一用户提交的作业所 占资源量进行限定。调度时，首先按以下策略选择一个合适队列：计算每个队列中正在运行的任务数与其应该分得的计算资源之间的比值，选择一个该比值最小的队 列；然后按以下策略选择该队列中一个作业：按照作业优先级和提交时间顺序选择，同时考虑用户资源量限制和内存限制。但是不可剥夺式。

配置公平调度器
1.修改mapred-stie.xml 加入如下内容

<property>     <name>mapred.jobtracker.taskScheduler</name>     <value>org.apache.hadoop.mapred.FairScheduler</value>       </property>       <property>      <name>mapred.fairscheduler.allocation.file</name>     <value>/opt/hadoop/conf/allocations.xml</value>       </property>        <property>    <name>mapred.fairscheduler.poolnameproperty</name>      <value>pool.name</value></property>

2.在 Hadoop conf 下创建allocations.xml，内容为

<xml version="1.0"><alloctions>...</alloctions>

样例：

<pool name="sample_pool"><minMaps>5</minMaps><minReduces>5</minReduces><weight>2.0</weight></pool><user name="sample_user"><maxRunningJobs>6</maxRunningJobs></user><userMaxJobsDefault>3</userMaxJobsDefault>

3.重启 JobTracker
4.访问 http://jobTracker:50030/scheduler , 查看 FariScheduler 的 UI
5.提交任务测试

任务的执行

申请到任务后，TaskTracker会做如下事情：
1.拷贝代码到本地
2.拷贝任务的信息到本地
3.启动JVM运行任务 

状态与任务的更新

任务在运行过程中，首先会将自己的状态汇报给TaskTracker，然后由TaskTracker汇总告之JobTracker。任务进度是通过计数器来实现的。
作业的完成JobTracker是在接受到最后一个任务运行完成后，才会将任务标志为成功。
此时会做删除中间结果等善后处理工作。

错误处理

任务失败
MapReduce在设计之出，就假象任务会失败，所以做了很多工作，来保证容错。
1.子任务失败
2.子任务的JVM突然退出

TaskTracker失败
1.TaskTracker崩溃后会停止向Jobtracker发送心跳信息。
2.Jobtracker会将该TaskTracker从等待的任务池中移除。并将该TaskTracker上的任务，移动到其他地方去重新运行。
3.TaskTracker可以被JobTracker放入到黑名单，即使它没有失败。
JobTracker失败
单点故障，Hadoop新的0.23版本解决了这个问题。

Shuffle与排序

Mapreduce 的 map 结束后，把数据重新组织，作为 reduce 阶段的输入，该过程称之为 shuffle--- 洗牌，数据在 Map 与 Reduce 端都会做排序。Map 的输出是由collector控制的Rreduce的Shuffle过程，分成三个阶段：复制Map输出、排序合并、reduce处理，主要代码在reduce的 run函数.
Shuffle优化
首先Hadoop的Shuffle在某些情况并不是最优的，例如，如果需要对2集合合并，那么其实排序操作时不需要的。
我们可以通过调整参数来优化Shuffle
在Map端，针对io.sort.mb；在Reduce端，针对mapred.job.reduce.input.buffer.percent。

MapReduce的类型与格式

MapReduce的类型使用键值对作为输入类型(key,value)，输入输出的数据类型是通过输入输出的格式进行设定的。

输入格式

Hadoop通过InputSplit表示分片。一个分片并不是数据本身，而是对分片数据的引用。InputFormat接口负责生成分片。

文件输入

实现类：FileInputFormat
通过文件作为输入源的基类。
四个方法：
addInputPath()
addInputPaths()
setInputPath()
setInputPaths()
FileInputFormat会按HDFS块的大小来分割文件
避免分割
继承FileInputFormat 重载isSplitable()
return false

文本输入

实现类：TextInputFormat
TextInputFormat 是默认的输入格式。
包括：
KeyValueTextInputFormat
NLineInputFormat
XML
输入分片与HDFS块之间的关系，TextInputFormat的某一条记录可能跨块存在。

二进制输入

实现类：SequenceFileInputFormat
处理二进制数据
包括：
SequenceFileAsTextInputFormat
SequenceFileAsBinaryInputFormat

多文件输入

实现类：MultipleInputs
处理多种文件输入
包括：
addInputPath

数据库输入

实现类：DBInputFormat
注意使用，因为连接过多，数据库无法承受。

输出格式

文本输出

实现类：TextOutputFormat
默认的输出方式
 以 "key \t value" 的方式输出

二进制输出

基类： SequenceFileOutputFormat
实现类： SequenceFileAsTextOutputFormat
             MapFileOutputFormat
              SequenceFileAsBinaryOutputFormat

多文件输出

MutipleOutputFormatMutipleOutputs
两者的不同在于MutipleOutputs可以产生不同类型的输出

数据库格式输出

实现类

DBOutputFormat

其他

推测式执行

每一道作业的任务都有运行时间，而由于机器的异构性，可能会会造成某些任务会比所有任务的平均运行时间要慢很多。这时MapReduce会尝试在其他机器上重启慢的任务。为了是任务快速运行完成。该属性默认是启用的。

JVM重用

启动JVM是一个比较耗时的工作，所以在MapReduce中有JVM重用的机制。条件是统一个作业的任务。可以通过mapred.job.reuse.jvm.num.tasks定义重用次数，如果属性是-1那么为无限制。

跳过坏记录

数据的一些记录不符合规范，处理时抛出异常，MapReduce可以讲次记录标为坏记录。重启任务时会跳过该记录。默认情况下该属性是关闭的。

任务执行环境

Hadoop为Map与Reduce任务提供运行环境。
如：Map可以知道自己的处理的文件.。但是多个任务可能会同时写一个文件，所以应该将输出写到任务的临时文件夹。目录为：{mapred.out. put.dir}/temp/${mapred.task.id}

运行WordCount程序

单词计数是最简单也是最能体现MapReduce思想的程序之一，可以称为MapReduce版"Hello World"，该程序的完整代码可以在Hadoop安装包的"src/examples"目录下找到。单词计数主要完成功能是：统计一系列文本文件中每个单词出现的次数，如下图所示。
 
 
 

准备工作

现在以"hadoop"普通用户登录"Master.Hadoop"服务器。
1）创建本地示例文件
首先在"/home/hadoop"目录下创建文件夹"file"。
 
 
 
接着创建两个文本文件file1.txt和file2.txt，使file1.txt内容为"Hello World"，而file2.txt的内容为"Hello Hadoop"。
 
 
2）在HDFS上创建输入文件夹
 
 
3）上传本地file中文件到集群的input目录下
 
 

运行例子

1）在集群上运行WordCount程序
备注： 以input作为输入目录，output目录作为输出目录。
已经编译好的WordCount的Jar在"/usr/hadoop"下面，就是"hadoop-examples-1.0.0.jar"，所以在下面执行命令时记得把路径写全了，不然会提示找不到该Jar包。
 
 
 
2）MapReduce执行过程显示信息
 
 
Hadoop命令会启动一个JVM来运行这个MapReduce程序，并自动获得Hadoop的配置，同时把类的路径（及其依赖关系）加入到Hadoop的库中。以上就是Hadoop Job的运行记录，从这里可以看到，这个Job被赋予了一个ID号：job_201202292213_0002，而且得知输入文件有两个（Total inputpaths to process : 2），同时还可以了解map的输入输出记录（record数及字节数），以及reduce输入输出记录。比如说，在本例中，map的task数量是2个，reduce的task数量是一个。map的输入record数是2个，输出record数是4个等信息。
 

查看结果

1）查看HDFS上output目录内容
 
 
从上图中知道生成了三个文件，我们的结果在" part-r-00000 "中。
2）查看结果输出文件内容
 
 

WordCount源码分析

 

特别数据类型介绍

Hadoop提供了如下内容的数据类型，这些数据类型都实现了WritableComparable接口，以便用这些类型定义的数据可以被序列化进行网络传输和文件存储，以及进行大小比较。
 
   BooleanWritable：标准布尔型数值
   ByteWritable：单字节数值
   DoubleWritable：双字节数
   FloatWritable：浮点数
   IntWritable：整型数
   LongWritable：长整型数
   Text：使用UTF8格式存储的文本

   NullWritable：当<key,value>中的key或value为空时使用

分解后多任务处理的结果汇总起来。

·        来负责，而不是JobClient，它在新的API中已经荡然无存。

分解后多任务处理的结果汇总起来。

旧的WordCount分析

 新的WordCount分析

packageorg.apache.hadoop.examples;importjava.io.IOException; import java.util.Iterator; import java.util.StringTokenizer;importorg.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.FileInputFormat; import org.apache.hadoop.mapred.FileOutputFormat; import org.apache.hadoop.mapred.JobClient; import org.apache.hadoop.mapred.JobConf; import org.apache.hadoop.mapred.MapReduceBase; import org.apache.hadoop.mapred.Mapper; import org.apache.hadoop.mapred.OutputCollector; import org.apache.hadoop.mapred.Reducer; import org.apache.hadoop.mapred.Reporter; import org.apache.hadoop.mapred.TextInputFormat;   import org.apache.hadoop.mapred.TextOutputFormat;public classWordCount {   public static class Map extends MapReduceBase implements            Mapper<LongWritable, Text, Text, IntWritable> {         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 = newJobConf(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]));       JobClient.runJob(conf);     } }

3）主方法 Main 分析
 

public staticvoid 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]));   JobClient.runJob(conf); }

 
首先讲解一下 Job 的 初始化过程 。 main 函数调用 Jobconf 类来对 MapReduce Job 进行初始化，然后调用 setJobName() 方法命名这个 Job 。对Job进行合理的命名有助于 更快 地找到Job，以便在JobTracker和Tasktracker的页面中对其进行 监视 。
 
JobConf conf =new JobConf(WordCount. class ); conf.setJobName("wordcount" );
 
接着设置Job输出结果<key,value>的中key和value数据类型，因为结果是<单词,个数>，所以key设置为"Text"类型，相当于Java中String类型。Value设置为"IntWritable"，相当于Java中的int类型。
 
conf.setOutputKeyClass(Text.class);
conf.setOutputValueClass(IntWritable.class);
 
然后设置Job处理的Map（拆分）、Combiner（中间结果合并）以及Reduce（合并）的相关处理类。这里用Reduce类来进行Map产生的中间结果合并，避免给网络数据传输产生压力。
 
conf.setMapperClass(Map.class);
conf.setCombinerClass(Reduce.class);
conf.setReducerClass(Reduce.class);
 
接着就是调用setInputPath()和setOutputPath()设置输入输出路径。
 
conf.setInputFormat(TextInputFormat.class);
conf.setOutputFormat(TextOutputFormat.class);
 
（1）InputFormat和InputSplit
InputSplit是Hadoop定义的用来 传送 给每个 单独 的 map 的 数据 ，InputSplit 存储的并 非 数据本身 ， 而是一个 分片长度 和一个 记录数据位置 的 数组 。 生成InputSplit的方法 可以通过 InputFormat() 来 设置 。
当数据传送给 map 时，map会将输入 分片 传送到 InputFormat ，InputFormat则 调用 方法 getRecordReader() 生成 RecordReader ， RecordReader再通过 creatKey()、 creatValue() 方法 创建 可供map处理的 <key,value> 对。简而言之，InputFormat()方法是用来生成可供map处理的<key,value>对的。
Hadoop预定义了多种方法将不同类型的输入数据转化为map能够处理的<key,value>对，它们都继承自InputFormat，分别是：
 
   InputFormat
       |
       |---BaileyBorweinPlouffe.BbpInputFormat
       |---ComposableInputFormat
       |---CompositeInputFormat
       |---DBInputFormat
       |---DistSum.Machine.AbstractInputFormat
       |---FileInputFormat
           |---CombineFileInputFormat
           |---KeyValueTextInputFormat
           |---NLineInputFormat
           |---SequenceFileInputFormat
           |---TeraInputFormat
           |---TextInputFormat
 
其中 TextInputFormat 是Hadoop 默认 的输入方法，在TextInputFormat中，每个文件（或其一部分）都会单独地作为map的输入，而这个是继承自FileInputFormat的。之后，每行数据都会生成一条记录，每条记录则表示成<key,value>形式：
·        key值是每个数据的记录在 数据分片 中 字节偏移量 ，数据类型是 LongWritable ；
value值是每行的内容，数据类型是 Text 。
（2）OutputFormat
每一种 输 入 格式 都有一种 输 出 格式 与其对应。默认的输出格式是TextOutputFormat ，这种输出方式与输入类似，会将每条记录以一行的形式存入文本文件。不过，它的 键和值 可以是 任意形式 的，因为程序 内容 会调用 toString() 方法将键和值转换为 String 类型再输出。
 
3）Map类中map方法分析
 

public staticclass Map extends MapReduceBase implements         Mapper<LongWritable, Text, Text,IntWritable> {     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)             throwsIOException {         String line = value.toString();         StringTokenizer tokenizer = newStringTokenizer(line);         while (tokenizer.hasMoreTokens()) {            word.set(tokenizer.nextToken());             output.collect(word,one);         }     } }

 
Map类 继承自 MapReduceBase ，并且它实现了 Mapper接口 ，此接口是一个 规范类型 ，它有4种形式的参数，分别用来指定map的 输入 key值类型、 输入 value值类型、 输出 key值类型和 输出 value值类型。在本例中，因为使用的是TextInputFormat，它的输出key值是LongWritable类型，输出value值是Text类型，所以map的输入类型为<LongWritable,Text>。在本例中需要输出<word,1>这样的形式，因此输出的key值类型是Text，输出的value值类型是IntWritable。
实现此接口类还需要实现map方法，map方法会具体负责对输入进行操作，在本例中，map方法对输入的行以空格为单位进行切分，然后使用 OutputCollect 收集输出的<word,1>。
 
4）Reduce类中reduce方法分析
 

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

 
Reduce类 也是继承自 MapReduceBase 的，需要实现Reducer接口。Reduce类以map的输出作为输入，因此Reduce的输入类型是<Text，Intwritable>。而Reduce的输出是 单词 和 它的数目 ，因此，它的输出类型是<Text,IntWritable>。Reduce类也要实现reduce方法，在此方法中，reduce函数将输入的key值作为输出的key值，然后将获得多个value值加起来，作为输出的值。

packageorg.apache.hadoop.examples;import java.io.IOException;importjava.util.StringTokenizer;importorg.apache.hadoop.conf.Configuration;importorg.apache.hadoop.fs.Path;importorg.apache.hadoop.io.IntWritable;importorg.apache.hadoop.io.Text;importorg.apache.hadoop.mapreduce.Job;importorg.apache.hadoop.mapreduce.Mapper;importorg.apache.hadoop.mapreduce.Reducer;importorg.apache.hadoop.mapreduce.lib.input.FileInputFormat;importorg.apache.hadoop.mapreduce.lib.output.FileOutputFormat;importorg.apache.hadoop.util.GenericOptionsParser;public classWordCount {    public staticclass  TokenizerMapper extendsMapper<Object, Text, Text, IntWritable>{        private finalstatic IntWritable one = new IntWritable(1);        private Textword = new Text();         public voidmap(Object key, Text value, Context context) throwsIOException, InterruptedException {            StringTokenizeritr = new StringTokenizer(value.toString());            while(itr.hasMoreTokens()) {                word.set(itr.nextToken());                context.write(word,one);            }        }    }<pre name="code" class="java">    

public staticclass IntSumReducer extends Reducer<Text,IntWritable,Text,IntWritable>{ privateIntWritable result = new IntWritable(); public voidreduce(Text key, Iterable<IntWritable> values,Context context) throwsIOException, InterruptedException { int sum = 0; for (IntWritableval : values) { sum +=val.get(); } result.set(sum); context.write(key,result); } } public staticvoid main (String[] args) throws Exception { Configurationconf = new Configuration(); String[]otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs(); if (otherArgs.length!= 2) { System.err.println("Usage:wordcount <in> <out>"); System.exit(2); } Job job = newJob(conf, "word count"); job.setJarByClass(WordCount.class); job.setMapperClass(TokenizerMapper.class); job.setCombinerClass(IntSumReducer.class); job.setReducerClass(IntSumReducer.class); job.setOutputKeyClass(Text.class); job.setOutputValueClass(IntWritable.class); FileInputFormat.addInputPath(job,new Path(otherArgs[0])); FileOutputFormat.setOutputPath(job,new Path(otherArgs[1])); System.exit(job.waitForCompletion(true) 0 : 1); }}

   1）Map过程 

public staticclass  TokenizerMapper extendsMapper<Object, Text, Text, IntWritable>{private finalstatic IntWritable one = new IntWritable(1);private Textword = new Text();public voidmap(Object key, Text value, Context context) throwsIOException, InterruptedException {StringTokenizeritr = new StringTokenizer(value.toString());while(itr.hasMoreTokens()) {word.set(itr.nextToken());context.write(word,one);  }}

 
Map过程需要继承org.apache.hadoop.mapreduce包中 Mapper 类，并 重写 其map方法。通过在map方法中添加两句把key值和value值输出到控制台的代码，可以发现map方法中value值存储的是文本文件中的一行（以回车符为行结束标记），而key值为该行的首字母相对于文本文件的首地址的偏移量。然后StringTokenizer类将每一行拆分成为一个个的单词，并将<word,1>作为map方法的结果输出，其余的工作都交有MapReduce框架 处理。
 
   2）Reduce过程 

public staticclass  IntSumReducer extendsReducer<Text,IntWritable,Text,IntWritable> {  privateIntWritable result = new IntWritable();  public voidreduce(Text key, Iterable<IntWritable> values,Context context) throwsIOException, InterruptedException {    int sum = 0;    for (IntWritableval : values) {      sum +=val.get();   }   result.set(sum);   context.write(key,result); }}

 
Reduce过程需要继承org.apache.hadoop.mapreduce包中 Reducer 类，并 重写 其reduce方法。Map过程输出<key,values>中key为单个单词，而values是对应单词的计数值所组成的列表，Map的输出就是Reduce的输入，所以reduce方法只要遍历values并求和，即可得到某个单词的总次数。
 
     3）执行MapReduce任务
 

public staticvoid  main (String[] args) throws Exception {  Configurationconf = new Configuration();  String[]otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();  if(otherArgs.length != 2) {     System.err.println("Usage:wordcount <in> <out>");     System.exit(2);  }  Job job = newJob(conf, "word count");  job.setJarByClass(WordCount.class);  job.setMapperClass(TokenizerMapper.class);  job.setCombinerClass(IntSumReducer.class);  job.setReducerClass(IntSumReducer.class);  job.setOutputKeyClass(Text.class);  job.setOutputValueClass(IntWritable.class);  FileInputFormat.addInputPath(job,new Path(otherArgs[0]));  FileOutputFormat.setOutputPath(job,new Path(otherArgs[1]));  System.exit(job.waitForCompletion(true) 0 : 1);}

 
在MapReduce中，由Job对象负责管理和运行一个计算任务，并通过Job的一些方法对任务的参数进行相关的设置。此处设置了使用TokenizerMapper完成Map过程中的处理和使用IntSumReducer完成Combine和Reduce过程中的处理。还设置了Map过程和Reduce过程的输出类型：key的类型为Text，value的类型为IntWritable。任务的输出和输入 路径 则由命令行参数指定，并由FileInputFormat和FileOutputFormat分别设定。完成相应任务的参数设定后，即可调用 job.waitForCompletion() 方法执行任务。

WordCount处理过程

本节将对WordCount进行更详细的讲解。详细执行步骤如下：
 
1）将文件拆分成splits，由于测试用的文件较小，所以每个文件为一个split，并将文件按行分割形成<key,value>对，如图4-1所示。这一步由MapReduce框架自动完成，其中偏移量（即key值）包括了回车所占的字符数（Windows和Linux环境会不同）。

 
2）将分割好的<key,value>对交给用户定义的map方法进行处理，生成新的<key,value>对，如图4-2所示。
 

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

 
4）Reducer先对从Mapper接收的数据进行排序，再交由用户自定义的reduce方法进行处理，得到新的<key,value>对，并作为WordCount的输出结果，如图4-4所示。

 
5、MapReduce新旧改变
Hadoop最新版本的MapReduce Release 0.20.0的API包括了一个全新的Mapreduce JAVA API，有时候也称为上下文对象。
新的API类型上不兼容以前的API，所以，以前的应用程序需要重写才能使新的API发挥其作用。
新的API和旧的API之间有下面几个明显的区别。
·        新的API倾向于使用抽象类，而不是接口，因为这更容易扩展。例如，你可以添加一个方法(用默认的实现)到一个抽象类而不需修改类之前的实现方法。在新的API中，Mapper和Reducer是抽象类。
·        新的API是在org.apache.hadoop.mapreduce包(和子包)中的。之前版本的API则是放在org.apache.hadoop.mapred中的。
·        新的API广泛使用context object(上下文对象)，并允许用户代码与MapReduce系统进行通信。例如，MapContext基本上充当着JobConf的OutputCollector和Reporter的角色。
·        新的API同时支持"推"和"拉"式的迭代。在这两个新老API中，键/值记录对被推mapper中，但除此之外，新的API允许把记录从map()方法中拉出，这也适用于reducer。"拉"式的一个有用的例子是分批处理记录，而不是一个接一个。
·        新的API统一了配置。旧的API有一个特殊的JobConf对象用于作业配置，这是一个对于Hadoop通常的Configuration对象的扩展。在新的API中，这种区别没有了，所以作业配置通过Configuration来完成。作业控制的执行由Job类来负责，而不是JobClient，它在新的API中已经荡然无存。
 

http://www.tuicool.com/articles/aqU7Rb
http://www.aboutyun.com/forum.phpmod=viewthread&tid=6723&page=1