hadoopmapreduce算法

⑴ hadoop和maprece是一种什么关系

hadoop是google的云计算系统的开源实现，谷歌集群系统主要包括三个部分：分布式文件系统GFS，分布式并行计算模型map/rece，以及分布式数据库Bigtable，hadoop也实现了这三个，GFS对应HDFS，hadoop的map/rece对应谷歌的map/rece模型，Hbase对应Bigtable。
也就是map/rece是谷歌提出的一种云计算模型，hadoop用java开源实现了

⑵ Hadoop和MapRece究竟分别是做什么用的

Hadoop是用来开发分布式程序的架构，是一个由Apache基金会所开发的分布式系统基础架构。用户可以在不了解分布式底层细节的情况下，开发分布式程序。

MapRece是用来做大规模并行数据处理的数据模型。方便了编程人员在不会分布式并行编程的情况下，将自己的程序运行在分布式系统上。

(2)hadoopmaprece算法扩展阅读

Hadoop是一个能够让用户轻松架构和使用的分布式计算平台。用户可以轻松地在Hadoop上开发和运行处理海量数据的应用程序。主要有以下几个优点 ：

1、高可靠性。Hadoop按位存储和处理数据的能力值得人们信赖 。

2、高扩展性。Hadoop是在可用的计算机集簇间分配数据并完成计算任务的，这些集簇可以方便地扩展到数以千计的节点中 。

3、高效性。Hadoop能够在节点之间动态地移动数据，并保证各个节点的动态平衡，因此处理速度非常快 。

4、高容错性。Hadoop能够自动保存数据的多个副本，并且能够自动将失败的任务重新分配。

5、低成本。与一体机、商用数据仓库以及QlikView、Yonghong Z-Suite等数据集市相比，hadoop是开源的，项目的软件成本因此会大大降低。

⑶ 请简要描述Hadoop计算框架MapRece的工作原理

分为2个步骤，map和rece，map专门负责对每个数据独立地同时地打标签，框架会对相同标签的数据分成一组，rece对分好的那些组数据做累计计算。我们只要分别实现map和rece就可以了

⑷ hadoop maprece可以完成下图功能吗需要怎么实现

把A作为map输出的key，value为自己实现的类似vectorwritable的类存 a c
rece时候有sum1，sum2……sumN分别为vectorwritable相同index的和，最后各除values.size
rece的输出value也为v e c to r w ri ta b le

⑸ hadoop maprece 进程有哪些

首先hadoop框架要求程序员将函数分成两部分，即map和rece函数。map阶段：就是将输入通过map函数处理得出中间结果并通过hadoop框架分配到不同的rece。rece阶段：就是将中间结果通过rece函数处理得到最后的结果。 以wordcount为例，在map阶段，map函数在每个单词后面加上一个1；在rece阶段，rece函数将相同单词后面的1都加起来。其中hadoop框架实现过程中的排序，分配等，当然这些也可以通过自定义的函数来控制。

⑹ Hadoop，MapRece，YARN和Spark的区别与联系

（1） Hadoop 1.0

第一代Hadoop，由分布式存储系统HDFS和分布式计算框架MapRece组成，其中，HDFS由一个NameNode和多个DataNode组成，MapRece由一个JobTracker和多个TaskTracker组成，对应Hadoop版本为Hadoop 1.x和0.21.X，0.22.x。

（2） Hadoop 2.0

第二代Hadoop，为克服Hadoop 1.0中HDFS和MapRece存在的各种问题而提出的。针对Hadoop 1.0中的单NameNode制约HDFS的扩展性问题，提出了HDFS Federation，它让多个NameNode分管不同的目录进而实现访问隔离和横向扩展；针对Hadoop 1.0中的MapRece在扩展性和多框架支持方面的不足，提出了全新的资源管理框架YARN(Yet Another Resource Negotiator)，它将JobTracker中的资源管理和作业控制功能分开，分别由组件ResourceManager和ApplicationMaster实现，其中，ResourceManager负责所有应用程序的资源分配，而ApplicationMaster仅负责管理一个应用程序。对应Hadoop版本为Hadoop 0.23.x和2.x。

（3） MapRece 1.0或者MRv1（MapReceversion 1）

第一代MapRece计算框架，它由两部分组成：编程模型（programming model）和运行时环境（runtime environment）。它的基本编程模型是将问题抽象成Map和Rece两个阶段，其中Map阶段将输入数据解析成key/value，迭代调用map()函数处理后，再以key/value的形式输出到本地目录，而Rece阶段则将key相同的value进行规约处理，并将最终结果写到HDFS上。它的运行时环境由两类服务组成：JobTracker和TaskTracker，其中，JobTracker负责资源管理和所有作业的控制，而TaskTracker负责接收来自JobTracker的命令并执行它。

（4）MapRece 2.0或者MRv2（MapRece version 2）或者NextGen MapRec

MapRece 2.0或者MRv2具有与MRv1相同的编程模型，唯一不同的是运行时环境。MRv2是在MRv1基础上经加工之后，运行于资源管理框架YARN之上的MRv1，它不再由JobTracker和TaskTracker组成，而是变为一个作业控制进程ApplicationMaster，且ApplicationMaster仅负责一个作业的管理，至于资源的管理，则由YARN完成。

简而言之，MRv1是一个独立的离线计算框架，而MRv2则是运行于YARN之上的MRv1。

（5）Hadoop-MapRece（一个离线计算框架）

Hadoop是google分布式计算框架MapRece与分布式存储系统GFS的开源实现，由分布式计算框架MapRece和分布式存储系统HDFS（Hadoop Distributed File System）组成，具有高容错性，高扩展性和编程接口简单等特点，现已被大部分互联网公司采用。

（6）Hadoop-YARN(Hadoop 2.0的一个分支，实际上是一个资源管理系统)

YARN是Hadoop的一个子项目（与MapRece并列），它实际上是一个资源统一管理系统，可以在上面运行各种计算框架（包括MapRece、Spark、Storm、MPI等）。当前Hadoop版本比较混乱，让很多用户不知所措。实际上，当前Hadoop只有两个版本：Hadoop 1.0和Hadoop 2.0，其中，Hadoop 1.0由一个分布式文件系统HDFS和一个离线计算框架MapRece组成，而Hadoop 2.0则包含一个支持NameNode横向扩展的HDFS，一个资源管理系统YARN和一个运行在YARN上的离线计算框架MapRece。相比于Hadoop 1.0，Hadoop 2.0功能更加强大，且具有更好的扩展性、性能，并支持多种计算框架。Borg/YARN/Mesos/Torca/Corona一类系统可以为公司构建一个内部的生态系统，所有应用程序和服务可以“和平而友好”地运行在该生态系统上。有了这类系统之后，你不必忧愁使用Hadoop的哪个版本，是Hadoop 0.20.2还是 Hadoop 1.0，你也不必为选择何种计算模型而苦恼，因此各种软件版本，各种计算模型可以一起运行在一台“超级计算机”上了。

从开源角度看，YARN的提出，从一定程度上弱化了多计算框架的优劣之争。YARN是在Hadoop MapRece基础上演化而来的，在MapRece时代，很多人批评MapRece不适合迭代计算和流失计算，于是出现了Spark和Storm等计算框架，而这些系统的开发者则在自己的网站上或者论文里与MapRece对比，鼓吹自己的系统多么先进高效，而出现了YARN之后，则形势变得明朗：MapRece只是运行在YARN之上的一类应用程序抽象，Spark和Storm本质上也是，他们只是针对不同类型的应用开发的，没有优劣之别，各有所长，合并共处，而且，今后所有计算框架的开发，不出意外的话，也应是在YARN之上。这样，一个以YARN为底层资源管理平台，多种计算框架运行于其上的生态系统诞生了。目前spark是一个非常流行的内存计算（或者迭代式计算，DAG计算）框架，在MapRece因效率低下而被广为诟病的今天，spark的出现不禁让大家眼前一亮。

从架构和应用角度上看，spark是一个仅包含计算逻辑的开发库（尽管它提供个独立运行的master/slave服务，但考虑到稳定后以及与其他类型作业的继承性，通常不会被采用），而不包含任何资源管理和调度相关的实现，这使得spark可以灵活运行在目前比较主流的资源管理系统上，典型的代表是mesos和yarn，我们称之为“spark on mesos”和“spark on yarn”。将spark运行在资源管理系统上将带来非常多的收益，包括：与其他计算框架共享集群资源；资源按需分配，进而提高集群资源利用率等。

FrameWork On YARN

运行在YARN上的框架，包括MapRece-On-YARN, Spark-On-YARN, Storm-On-YARN和Tez-On-YARN。

（1）MapRece-On-YARN：YARN上的离线计算；

（2）Spark-On-YARN：YARN上的内存计算；

（3）Storm-On-YARN：YARN上的实时/流式计算；

（4）Tez-On-YARN：YARN上的DAG计算

⑺ 如何在hadoop环境下执行maprece任务

之前学习了一段时间的hadoop的相关知识 ，学习理论基础的时候要同时实际操作才能对它更熟练，废话不多说来说说在hadoop上运行一个最简单的wordscount的程序

首先我先贴上这个程序的源代码 供大家参考 代码分为三个部分写的Run、 map阶段、 rece阶段

Map：

[java]view plain

• <spanstyle="font-family:KaiTi_GB2312;font-size:18px;">packagewordsCount;

• importjava.io.IOException;

• importjava.util.StringTokenizer;

• importorg.apache.hadoop.io.IntWritable;

• importorg.apache.hadoop.io.LongWritable;

• importorg.apache.hadoop.io.Text;

• importorg.apache.hadoop.maprece.Mapper;

• <LongWritable,Text,Text,IntWritable>{

• @Override

• protectedvoidmap(LongWritablekey,Textvalue,Mapper<LongWritable,Text,Text,IntWritable>.Contextcontext)

• throwsIOException,InterruptedException{

• Stringline=value.toString();

• StringTokenizerst=newStringTokenizer(line);

• while(st.hasMoreTokens()){

• Stringword=st.nextToken();

• context.write(newText(word),newIntWritable(1));

• }

• }

• }</span>


Rece：

[java]view plain

• <spanstyle="font-family:KaiTi_GB2312;font-size:18px;">packagewordsCount;

• importjava.io.IOException;

• importorg.apache.hadoop.io.IntWritable;

• importorg.apache.hadoop.io.Text;

• importorg.apache.hadoop.maprece.Recer;

• <Text,IntWritable,Text,IntWritable>{

• @Override

• protectedvoidrece(Textkey,Iterable<IntWritable>iterator,

• Recer<Text,IntWritable,Text,IntWritable>.Contextcontext)throwsIOException,InterruptedException{

• //TODO自动生成的方法存根

• intsum=0;

• for(IntWritablei:iterator){

• sum=sum+i.get();

• }

• context.write(key,newIntWritable(sum));

• }

• }</span>

Run：

[java]view plain

• <spanstyle="font-family:KaiTi_GB2312;font-size:18px;">packagewordsCount;

• importorg.apache.hadoop.conf.Configuration;

• importorg.apache.hadoop.fs.Path;

• importorg.apache.hadoop.io.IntWritable;

• importorg.apache.hadoop.io.Text;

• importorg.apache.hadoop.maprece.Job;

• importorg.apache.hadoop.maprece.lib.input.FileInputFormat;

• importorg.apache.hadoop.maprece.lib.input.TextInputFormat;

• importorg.apache.hadoop.maprece.lib.output.FileOutputFormat;

• importorg.apache.hadoop.maprece.lib.output.TextOutputFormat;

• publicclassRun{

• publicstaticvoidmain(String[]args)throwsException{

• //TODO自动生成的方法存根

• Configurationconfiguration=newConfiguration();

• Jobjob=newJob(configuration);

• job.setJarByClass(Run.class);

• job.setJobName("wordscount!");

• job.setOutputKeyClass(Text.class);

• job.setOutputValueClass(IntWritable.class);

• job.setInputFormatClass(TextInputFormat.class);

• job.setOutputFormatClass(TextOutputFormat.class);

• job.setMapperClass(WordsMapper.class);

• job.setRecerClass(WordsRece.class);

• FileInputFormat.addInputPath(job,newPath("hdfs://192.168.1.111:9000/user/input/wc/"));

• FileOutputFormat.setOutputPath(job,newPath("hdfs://192.168.1.111:9000/user/result/"));

• job.waitForCompletion(true);

• }

• }</span>


Run里面的输入和输出路径根据自己的来修改

这个程序就不用去讲解了吧 到处都能找到

首先在hadoop上运行这个程序用两个方法

方法一：将自己的编译软件与hadoop相连（我用的是MyEclipse去链接hadoop），直接运行程序。MyEclipse连接hadoop的教程待会我会在文章结尾处给出一个链接供大家参考。




查看结果你可通过在你的Eclipse连接好hadoop查看，还可以通过在hdfs文件系统的网页去查看（localhost：50070）。

还有一个很重要的一步就是，运行之前保证你的hadoop已经启动了，可以通过jps来查看你的进程中是否已经启动hadoop集群

⑻ hadoop的maprece常见算法案例有几种

基本MapRece模式

计数与求和
问题陈述:
有许多文档，每个文档都有一些字段组成。需要计算出每个字段在所有文档中的出现次数或者这些字段的其他什么统计值。例如，给定一个log文件，其中的每条记录都包含一个响应时间，需要计算出平均响应时间。
解决方案:
让我们先从简单的例子入手。在下面的代码片段里，Mapper每遇到指定词就把频次记1，Recer一个个遍历这些词的集合然后把他们的频次加和。

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 Recer
7 method Rece(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提交了太多无意义的计数。它完全可以通过先对每个文档中的词进行计数从而减少传递给Recer的数据量:

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 Recer
14 method Rece(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，其本身作为值传递给 Recer。 Recer 取得按照属性值分组的条目，然后可以处理或者保存。如果是在构建倒排索引，那么 每个条目相当于一个词而属性值就是词所在的文档ID。
应用：倒排索引， ETL
过滤 (文本查找)，解析和校验
问题陈述:
假设有很多条记录，需要从其中找出满足某个条件的所有记录，或者将每条记录传换成另外一种形式（转换操作相对于各条记录独立，即对一条记录的操作与其他记录无关）。像文本解析、特定值抽取、格式转换等都属于后一种用例。
解决方案:
非常简单，在Mapper 里逐条进行操作，输出需要的值或转换后的形式。
应用：日志分析，数据查询，ETL，数据校验

分布式任务执行

问题陈述:
大型计算可以分解为多个部分分别进行然后合并各个计算的结果以获得最终结果。
解决方案: 将数据切分成多份作为每个 Mapper 的输入，每个Mapper处理一份数据，执行同样的运算，产生结果，Recer把多个Mapper的结果组合成一个。
案例研究： 数字通信系统模拟
像 WiMAX 这样的数字通信模拟软件通过系统模型来传输大量的随机数据，然后计算传输中的错误几率。 每个 Mapper 处理样本 1/N 的数据，计算出这部分数据的错误率，然后在 Recer 里计算平均错误率。
应用：工程模拟，数字分析，性能测试
排序
问题陈述:
有许多条记录，需要按照某种规则将所有记录排序或是按照顺序来处理记录。
解决方案: 简单排序很好办 – Mappers 将待排序的属性值为键，整条记录为值输出。 不过实际应用中的排序要更加巧妙一点， 这就是它之所以被称为MapRece 核心的原因（“核心”是说排序？因为证明Hadoop计算能力的实验是大数据排序？还是说Hadoop的处理过程中对key排序的环节？）。在实践中，常用组合键来实现二次排序和分组。
MapRece 最初只能够对键排序， 但是也有技术利用可以利用Hadoop 的特性来实现按值排序。想了解的话可以看这篇博客。
按照BigTable的概念，使用 MapRece来对最初数据而非中间数据排序，也即保持数据的有序状态更有好处，必须注意这一点。换句话说，在数据插入时排序一次要比在每次查询数据的时候排序更高效。
应用：ETL，数据分析

非基本 MapRece 模式

迭代消息传递 (图处理)

问题陈述：
假设一个实体网络，实体之间存在着关系。 需要按照与它比邻的其他实体的属性计算出一个状态。这个状态可以表现为它和其它节点之间的距离， 存在特定属性的邻接点的迹象， 邻域密度特征等等。
解决方案：
网络存储为系列节点的结合，每个节点包含有其所有邻接点ID的列表。按照这个概念，MapRece 迭代进行，每次迭代中每个节点都发消息给它的邻接点。邻接点根据接收到的信息更新自己的状态。当满足了某些条件的时候迭代停止，如达到了最大迭代次数（网络半径）或两次连续的迭代几乎没有状态改变。从技术上来看，Mapper 以每个邻接点的ID为键发出信息，所有的信息都会按照接受节点分组，recer 就能够重算各节点的状态然后更新那些状态改变了的节点。下面展示了这个算法：

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 Recer
8 method Rece(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)

一个节点的状态可以迅速的沿着网络传全网，那些被感染了的节点又去感染它们的邻居，整个过程就像下面的图示一样：

案例研究： 沿分类树的有效性传递
问题陈述：
这个问题来自于真实的电子商务应用。将各种货物分类，这些类别可以组成一个树形结构，比较大的分类（像男人、女人、儿童）可以再分出小分类（像男裤或女装），直到不能再分为止（像男式蓝色牛仔裤）。这些不能再分的基层类别可以是有效（这个类别包含有货品）或者已无效的（没有属于这个分类的货品）。如果一个分类至少含有一个有效的子分类那么认为这个分类也是有效的。我们需要在已知一些基层分类有效的情况下找出分类树上所有有效的分类。
解决方案：
这个问题可以用上一节提到的框架来解决。我们咋下面定义了名为 getMessage和 calculateState 的方法：

1 class N
2 State in {True = 2, False = 1, null = 0},
3 initialized 1 or 2 for end-of-line categories, 0 otherwise
4 method getMessage(object N)
5 return N.State
6 method calculateState(state s, data [d1, d2,...])
7 return max( [d1, d2,...] )

案例研究：广度优先搜索
问题陈述：需要计算出一个图结构中某一个节点到其它所有节点的距离。
解决方案： Source源节点给所有邻接点发出值为0的信号，邻接点把收到的信号再转发给自己的邻接点，每转发一次就对信号值加1：

1 class N
2 State is distance,
3 initialized 0 for source node, INFINITY for all other nodes
4 method getMessage(N)
5 return N.State + 1
6 method calculateState(state s, data [d1, d2,...])
7 min( [d1, d2,...] )

案例研究：网页排名和 Mapper 端数据聚合
这个算法由Google提出，使用权威的PageRank算法，通过连接到一个网页的其他网页来计算网页的相关性。真实算法是相当复杂的，但是核心思想是权重可以传播，也即通过一个节点的各联接节点的权重的均值来计算节点自身的权重。

1 class N
2 State is PageRank
3 method getMessage(object N)
4 return N.State / N.OutgoingRelations.size()
5 method calculateState(state s, data [d1, d2,...])
6 return ( sum([d1, d2,...]) )

要指出的是上面用一个数值来作为评分实际上是一种简化，在实际情况下，我们需要在Mapper端来进行聚合计算得出这个值。下面的代码片段展示了这个改变后的逻辑 （针对于 PageRank 算法）：

1 class Mapper
2 method Initialize
3 H = new AssociativeArray
4 method Map(id n, object N)
5 p = N.PageRank / N.OutgoingRelations.size()
6 Emit(id n, object N)
7 for all id m in N.OutgoingRelations do
8 H{m} = H{m} + p
9 method Close
10 for all id n in H do
11 Emit(id n, value H{n})
12
13 class Recer
14 method Rece(id m, [s1, s2,...])
15 M = null
16 p = 0
17 for all s in [s1, s2,...] do
18 if IsObject(s) then
19 M = s
20 else
21 p = p + s
22 M.PageRank = p
23 Emit(id m, item M)

应用：图分析，网页索引

值去重 （对唯一项计数）
问题陈述: 记录包含值域F和值域 G，要分别统计相同G值的记录中不同的F值的数目 (相当于按照 G分组).
这个问题可以推而广之应用于分面搜索（某些电子商务网站称之为Narrow Search）
Record 1: F=1, G={a, b}
Record 2: F=2, G={a, d, e}
Record 3: F=1, G={b}
Record 4: F=3, G={a, b}

Result:
a -> 3 // F=1, F=2, F=3
b -> 2 // F=1, F=3
d -> 1 // F=2
e -> 1 // F=2

解决方案 I:
第一种方法是分两个阶段来解决这个问题。第一阶段在Mapper中使用F和G组成一个复合值对，然后在Recer中输出每个值对，目的是为了保证F值的唯一性。在第二阶段，再将值对按照G值来分组计算每组中的条目数。
第一阶段：

1 class Mapper
2 method Map(null, record [value f, categories [g1, g2,...]])
3 for all category g in [g1, g2,...]
4 Emit(record [g, f], count 1)
5
6 class Recer
7 method Rece(record [g, f], counts [n1, n2, ...])
8 Emit(record [g, f], null )

第二阶段：

1 class Mapper
2 method Map(record [f, g], null)
3 Emit(value g, count 1)
4
5 class Recer
6 method Rece(value g, counts [n1, n2,...])
7 Emit(value g, sum( [n1, n2,...] ) )

解决方案 II:
第二种方法只需要一次MapRece 即可实现，但扩展性不强。算法很简单-Mapper 输出值和分类，在Recer里为每个值对应的分类去重然后给每个所属的分类计数加1，最后再在Recer结束后将所有计数加和。这种方法适用于只有有限个分类，而且拥有相同F值的记录不是很多的情况。例如网络日志处理和用户分类，用户的总数很多，但是每个用户的事件是有限的，以此分类得到的类别也是有限的。值得一提的是在这种模式下可以在数据传输到Recer之前使用Combiner来去除分类的重复值。

1 class Mapper
2 method Map(null, record [value f, categories [g1, g2,...] )
3 for all category g in [g1, g2,...]
4 Emit(value f, category g)
5
6 class Recer
7 method Initialize
8 H = new AssociativeArray : category -> count
9 method Rece(value f, categories [g1, g2,...])
10 [g1', g2',..] = ExcludeDuplicates( [g1, g2,..] )
11 for all category g in [g1', g2',...]
12 H{g} = H{g} + 1
13 method Close
14 for all category g in H do
15 Emit(category g, count H{g})

应用：日志分析，用户计数
互相关
问题陈述：有多个各由若干项构成的组，计算项两两共同出现于一个组中的次数。假如项数是N，那么应该计算N*N。
这种情况常见于文本分析（条目是单词而元组是句子），市场分析（购买了此物的客户还可能购买什么）。如果N*N小到可以容纳于一台机器的内存，实现起来就比较简单了。
配对法
第一种方法是在Mapper中给所有条目配对，然后在Recer中将同一条目对的计数加和。但这种做法也有缺点：
使用 combiners 带来的的好处有限，因为很可能所有项对都是唯一的
不能有效利用内存

1 class Mapper
2 method Map(null, items [i1, i2,...] )
3 for all item i in [i1, i2,...]
4 for all item j in [i1, i2,...]
5 Emit(pair [i j], count 1)
6
7 class Recer
8 method Rece(pair [i j], counts [c1, c2,...])
9 s = sum([c1, c2,...])
10 Emit(pair[i j], count s)

Stripes Approach（条方法？不知道这个名字怎么理解）
第二种方法是将数据按照pair中的第一项来分组，并维护一个关联数组，数组中存储的是所有关联项的计数。The second approach is to group data by the first item in pair and maintain an associative array (“stripe”) where counters for all adjacent items are accumulated. Recer receives all stripes for leading item i, merges them, and emits the same result as in the Pairs approach.
中间结果的键数量相对较少，因此减少了排序消耗。
可以有效利用 combiners。
可在内存中执行，不过如果没有正确执行的话也会带来问题。
实现起来比较复杂。
一般来说， “stripes” 比 “pairs” 更快

1 class Mapper
2 method Map(null, items [i1, i2,...] )
3 for all item i in [i1, i2,...]
4 H = new AssociativeArray : item -> counter
5 for all item j in [i1, i2,...]
6 H{j} = H{j} + 1
7 Emit(item i, stripe H)
8
9 class Recer
10 method Rece(item i, stripes [H1, H2,...])
11 H = new AssociativeArray : item -> counter
12 H = merge-sum( [H1, H2,...] )
13 for all item j in H.keys()
14 Emit(pair [i j], H{j})

应用：文本分析，市场分析
参考资料：Lin J. Dyer C. Hirst G. Data Intensive Processing MapRece
用MapRece 表达关系模式
在这部分我们会讨论一下怎么使用MapRece来进行主要的关系操作。
筛选（Selection）

1 class Mapper
2 method Map(rowkey key, tuple t)
3 if t satisfies the predicate
4 Emit(tuple t, null)

投影（Projection）
投影只比筛选稍微复杂一点，在这种情况下我们可以用Recer来消除可能的重复值。

1 class Mapper
2 method Map(rowkey key, tuple t)
3 tuple g = project(t) // extract required fields to tuple g
4 Emit(tuple g, null)
5
6 class Recer

⑼ hadoop和maprece是一种什么关系

hadoop是依据maprece的原理，用Java语言实现的分布式处理机制。

Hadoop是一个能够对大量数据进行分布式处理的软件框架，实现了Google的MapRece编程模型和框架，能够把应用程序分割成许多的小的工作单元，并把这些单元放到任何集群节点上执行。

MapRece是Hadoop中的一个数据运算核心模块，MapRece通过JobClient生成任务运行文件，并在JobTracker进行调度指派TaskTracker完成任务。

(9)hadoopmaprece算法扩展阅读

1、MapRece分布式计算框架原型：

MapRece分布式计算模型是由Google提出，主要用于搜索领域，解决海量数据的计算问题Apache对其做了开源实现，整合在hadoop中实现通用分布式数据计算。

MR由两个阶段组成：Map和Rece，用户只需要实现map()和rece()两个函数，即可实现分布式计算，非常简单。大大简化了分布式并发处理程序的开发。

Map阶段就是进行分段处理。

Rece阶段就是进行汇总处理。汇总之后还可以进行数据的一系列美化操作，然后再输出。

2、MapRece组件介绍：

JobClient：用于把用户的作业任务生成Job的运行包，并存放到HDFS中。

JobinProgress：把Job运行包分解成MapTask和ReceTask并存放于TaskTracker中。

JobTracker(Master)：进行调度管理TaskTracker执行任务。

TaskTracker(Slave)：执行分配下来的Map计算或Rece计算任务。

⑽ Hadoop MapRee是如何实现计算向数据靠拢

大规模数据处理时，MapRece在三个层面上的基本构思：如何对付大数据处理：分而治之。对相互间不具有计算依赖关系的大数据，实现并行最自然的办法就是采取分而治之的策略。上升到抽象模型：Mapper与Recer。MPI等并行计算方法缺少高层并行编程模型，为了克服这一缺陷，MapRece借鉴了Lisp函数式语言中的思想，用Map和Rece两个函数提供了高层的并行编程抽象模型。上升到构架：统一构架，为程序员隐藏系统层细节。MPI等并行计算方法缺少统一的计算框架支持，程序员需要考虑数据存储、划分、分发、结果收集、错误恢复等诸多细节；为此，MapRece设计并提供了统一的计算框架，为程序员隐藏了绝大多数系统层面的处理细节。MapRece借鉴了函数式程序设计语言Lisp中的思想，定义了如下的Map和Rece两个抽象的编程接口，由用户去编程实现：map：(k1;v1)[(k2;v2)]输入：键值对(k1;v1)表示的数据。处理：文档数据记录[(k2;v2)](如文本文件中的行，或数据表格中的行)将以“键值对”形式传入map函数；map函数将处理这些键值对，并以另一种键。值对形式输出处理的一组键值对中间结果。输出：键值对[(k2;v2)]表示的一组中间数据。rece:(k2;[v2])[(k3;v3)]输入：由map输出的一组键值对[(k2;v2)]将被进行合并处理将同样主键下的不同数值合并到一个列表[v2]中，故rece的输入为(k2;[v2])处理：对传入的中间结果列表数据进行某种整理或进一步的处理,并产生最终的某种形式的结果输出[(k3;v3)]。输出：最终输出结果[(k3;v3)]。Map和Rece为程序员提供了一个清晰的操作接口抽象描述。