摘自：http://my.oschina.net/juliashine/blog/86063?from=20121111

本文译自 Mapreduce Patterns, Algorithms, and Use Cases


在这篇文章里总结了几种网上或者论文中常见的MapReduce模式和算法，并系统化的解释了这些技术的不同之处。所有描述性的文字和代码都使用了标准hadoop的MapReduce模型，包括Mappers, Reduces, Combiners, Partitioners,和 sorting。如下图所示。

 

基本MapReduce模式

计数与求和

问题陈述: 

有许多文档，每个文档都有一些字段组成。需要计算出每个字段在所有文档中的出现次数或者这些字段的其他什么统计值。例如，给定一个log文件，其中的每条记录都包含一个响应时间，需要计算出平均响应时间。

解决方案:

让我们先从简单的例子入手。在下面的代码片段里，Mapper每遇到指定词就把频次记1，Reducer一个个遍历这些词的集合然后把他们的频次加和。


    

      1 
     class
      Mapper 
      2 
      method Map(docid id, doc d) 
      3 
      
     for
      all term t 
     in
      doc d 
     do
      
      4 
      Emit(term t, count 
     1
     ) 
      5 
      
      6 
     class
      Reducer 
      7 
      method Reduce(term t, counts [c1, c2,...]) 
      8 
      sum 
     =
      
     0
      
      9 
      
     for
      all count c 
     in
      [c1, c2,...] 
     do
      
     10 
      sum 
     =
      sum 
     +
      c 
     11 
      Emit(term t, count sum)
    
 
   
 
   
这种方法的缺点显而易见，Mapper提交了太多无意义的计数。它完全可以通过先对每个文档中的词进行计数从而减少传递给Reducer的数据量:
 
   
 
    

    

     1 
     class
      Mapper 
     2 
      method Map(docid id, doc d) 
     3 
      H 
     =
      
     new
      AssociativeArray 
     4 
      
     for
      all term t 
     in
      doc d 
     do
      
     5 
      H{t} 
     =
      H{t} 
     +
      
     1
      
     6 
      
     for
      all term t 
     in
      H 
     do
      
     7 
      Emit(term t, count H{t})
    
 
   
 
   
如果要累计计数的的不只是单个文档中的内容，还包括了一个Mapper节点处理的所有文档，那就要用到Combiner了:
 
   
 
    

    

      1 
      
     class
      Mapper 
      2 
      method Map(docid id, doc d) 
      3 
      
     for
      all term t 
     in
      doc d 
     do
      
      4 
      Emit(term t, count 
     1
     ) 
      5 
      
      6 
      
     class
      Combiner 
      7 
      method Combine(term t, [c1, c2,...]) 
      8 
      sum 
     =
      
     0
      
      9 
      
     for
      all count c 
     in
      [c1, c2,...] 
     do
      
     10 
      sum 
     =
      sum 
     +
      c 
     11 
      Emit(term t, count sum) 
     12 
      
     13 
      
     class
      Reducer 
     14 
      method Reduce(term t, counts [c1, c2,...]) 
     15 
      sum 
     =
      
     0
      
     16 
      
     for
      all count c 
     in
      [c1, c2,...] 
     do
      
     17 
      sum 
     =
      sum 
     +
      c 
     18 
      Emit(term t, count sum)
    
 
   
 
   
应用：Log 分析, 数据查询
 
   
整理归类
 
   
问题陈述:
 
   
有一系列条目，每个条目都有几个属性，要把具有同一属性值的条目都保存在一个文件里，或者把条目按照属性值分组。 最典型的应用是倒排索引。
 
   
解决方案：
 
   
解决方案很简单。 在 Mapper 中以每个条目的所需属性值作为 key，其本身作为值传递给 Reducer。 Reducer 取得按照属性值分组的条目，然后可以处理或者保存。如果是在构建倒排索引，那么 每个条目相当于一个词而属性值就是词所在的文档ID。
 
   
应用：倒排索引， ETL
 
   
过滤 (文本查找)，解析和校验
 
   
问题陈述:
 
   
假设有很多条记录，需要从其中找出满足某个条件的所有记录，或者将每条记录传换成另外一种形式（转换操作相对于各条记录独立，即对一条记录的操作与其他记录无关）。像文本解析、特定值抽取、格式转换等都属于后一种用例。
 
   
解决方案:
 
   
非常简单，在Mapper 里逐条进行操作，输出需要的值或转换后的形式。
 
   
应用：日志分析，数据查询，ETL，数据校验
 
   
分布式任务执行
 
   
问题陈述:
 
   
大型计算可以分解为多个部分分别进行然后合并各个计算的结果以获得最终结果。
 
   
解决方案:  将数据切分成多份作为每个 Mapper 的输入，每个Mapper处理一份数据，执行同样的运算，产生结果，Reducer把多个Mapper的结果组合成一个。
 
   
案例研究： 数字通信系统模拟
 
   
像 WiMAX 这样的数字通信模拟软件通过系统模型来传输大量的随机数据，然后计算传输中的错误几率。 每个 Mapper 处理样本 1/N  的数据，计算出这部分数据的错误率，然后在 Reducer 里计算平均错误率。
 
   
应用：工程模拟，数字分析，性能测试
 
   
排序
 
   
问题陈述:
 
   
有许多条记录，需要按照某种规则将所有记录排序或是按照顺序来处理记录。
 
   
解决方案: 简单排序很好办 – Mappers 将待排序的属性值为键，整条记录为值输出。 不过实际应用中的排序要更加巧妙一点， 这就是它之所以被称为MapReduce 核心的原因（“核心”是说排序？因为证明Hadoop计算能力的实验是大数据排序？还是说Hadoop的处理过程中对key排序的环节？）。在实践中，常用组合键来实现二次排序和分组。
 
   
MapReduce 最初只能够对键排序， 但是也有技术利用可以利用Hadoop 的特性来实现按值排序。想了解的话可以看这篇博客。
 
   
按照BigTable的概念，使用 MapReduce来对最初数据而非中间数据排序，也即保持数据的有序状态更有好处，必须注意这一点。换句话说，在数据插入时排序一次要比在每次查询数据的时候排序更高效。
 
   
应用：ETL，数据分析
 
   
非基本 MapReduce 模式
 
   
迭代消息传递 (图处理)
 
   
问题陈述：
 
   
假设一个实体网络，实体之间存在着关系。 需要按照与它比邻的其他实体的属性计算出一个状态。这个状态可以表现为它和其它节点之间的距离， 存在特定属性的邻接点的迹象， 邻域密度特征等等。
 
   
解决方案：
 
   
网络存储为系列节点的结合，每个节点包含有其所有邻接点ID的列表。按照这个概念，MapReduce 迭代进行，每次迭代中每个节点都发消息给它的邻接点。邻接点根据接收到的信息更新自己的状态。当满足了某些条件的时候迭代停止，如达到了最大迭代次数（网络半径）或两次连续的迭代几乎没有状态改变。从技术上来看，Mapper 以每个邻接点的ID为键发出信息，所有的信息都会按照接受节点分组，reducer 就能够重算各节点的状态然后更新那些状态改变了的节点。下面展示了这个算法：
 
   
 
    

    

      1 
     class
      Mapper 
      2 
      method Map(id n, 
     object
      N) 
      3 
      Emit(id n, 
     object
      N) 
      4 
      
     for
      all id m 
     in
      N.OutgoingRelations 
     do
      
      5 
      Emit(id m, message getMessage(N)) 
      6 
      
      7 
     class
      Reducer 
      8 
      method Reduce(id m, [s1, s2,...]) 
      9 
      M 
     =
      
     null
      
     10 
      messages 
     =
      [] 
     11 
      
     for
      all s 
     in
      [s1, s2,...] 
     do
      
     12 
      
     if
      IsObject(s) then 
     13 
      M 
     =
      s 
     14 
      
     else
      
     //
      s is a message
      
     15 
      messages.add(s) 
     16 
      M.State 
     =
      calculateState(messages) 
     17 
      Emit(id m, item M)
    
 
   
 
   
一个节点的状态可以迅速的沿着网络传全网，那些被感染了的节点又去感染它们的邻居，整个过程就像下面的图示一样：