C++博客-mysileng-随笔分类-Hadoop

hadoop0.20.2在eclipse中的编译

鑫龙 — Mon, 24 Jun 2013 10:58:00 GMT

1. 下载Hadoop源代码
Hadoop 各成员源代码下载地址：http://svn.apache.org/repos/asf/hadoop，请使用SVN下载，在SVN浏览器中将trunk目录下的源代码check-out 出来即可。请注意只check-out出SVN 上的tag 目录下的内容，如：
http://svn.apache.org/repos/asf/hadoop/common/tag/release-0.20.2，

2. 准备编译环境

2.1. 系统

CentOS5.5

2.2. Hadoop代码版本
hadoop-0.20.2-release

2.3. 联网
编译Hadoop 会依赖很多第三方库，但编译工具Ant 会自动从网上下载缺少的库，所以必须保证机器能够访问Internet。
2.4. java
编译Hadoop要用JDK1.6 以上，网址：http://java.sun.com/javase/downloads/index.jsp。
安装好之后，请设置好JAVA_HOME 环境变量。
2.5. Ant
需要使用Ant 工具来编译Hadoop，可以从：http://ant.apache.org/ivy/download.cgi 下载Ant

安装好之后，请设置好ANT_HOME 环境变量。

2.6. Eclipse

Eclipse 则可以从http://www.eclipse.org/downloads/上下载。

3. 编译Hadoop

3.1. 编译Hadoop
步骤1) 在Elipse 的Package 视图中单击右键，选择New->Java Project，如下图所示：

在上图所示的对话框中，点击Browse 按钮，选择hadoop-0.20.2 源代码目录，并设置Projectname 为hadoop-0.20.2-dev。工程导入完成后，进入Eclipse 主界面，可以看到hadoop-0.20.2 已经导入进来，但可以看到目录上有红叉叉，是因为Elipse默认使用了Java Builder，而不是Ant Builder，所以下一步就是设置使用Ant Builder。

步骤3) 设置Builder 为Ant：右键hadoop-0.20.2-dev>Properties->Builders:

点击Browse File System 按钮，选择hadoop-0.20.2源代码目录下的build.xml 文件，并设置Name 为Ant_Builder（Name 可以改成其它的，但建议使用Ant_Builder，因为这样名副其实），操作结果如下图所示：

Hadoop 各成员都需要编译成jar，所以做如下图所示的一个修改：

上面完成后，回到Builder 的主对话框，再将对话框中的Java Builder 下移，并将它前面的勾去掉。
进入Eclipse 主界面，由于之前选择了Manual Build，所以需要人工方式驱动编译，编译成功后，可以看到BUILDSUCCESSFUL 字样。

　请注意：如果上图所示的菜单中的BuildAutomatically 被勾中，则在common的右键菜单中可能不会出现Build 子菜单。
在编译过程中，Ant 会自动从网上下载所依赖的库。hadoop-0.20.2 编译成功结束后，可以在build 目录下找到编译后生成的文件hadoop-core-0.20.2-dev.jar。

3.2编译过程中出现错误

1、可能有时候因为eclipse版本或者操作系统版本的问题使得hadoop提供的eclipse plugin不太好用。
解决方法：
1）修改$HADOOP_HOME/src/contrib/build-contrib.xml
增加一行：
上句后面的/home/gushui/eclipse由自己的$ECLIPSE_HOME代替

2）修改$HADOOP_HOME/src/contrib/eclipse-plugin/src/java/org/apache/hadoop/eclipse/launch/HadoopApplicationLaunchShortcut.java
注释掉原来的//importorg.eclipse.jdt.internal.debug.ui.launcher.JavaApplicationLaunchShortcut;
改为importorg.eclipse.jdt.debug.ui.launchConfigurations.JavaApplicationLaunchShortcut;

2、报错：

Buildfailed

Cannot write to the specified tarfile!

解决方法：

hadoop-0.20.2-dev目录下的Build.xml中

注销掉，运行成功。

参考 http://blog.csdn.net/basicthinker/article/details/6174442

参考： http://hi.baidu.com/xxjjyy2008/blog/item/7b5ed10f20e6a9346059f335.html

参考：http://hadoop.hadoopor.com/thread-941-1-1.html

http://trac.nchc.org.tw/cloud/wiki/waue/2010/0211

转自http://www.cnblogs.com/zyumeng/archive/2013/03/22/2975165.html

鑫龙 2013-06-24 18:58 发表评论

在HADOOP中使用MRUNIT进行单元测试

鑫龙 — Wed, 03 Apr 2013 03:27:00 GMT

本文地址：博客园逖靖寒 http://gpcuster.cnblogs.com

前提

1. 了解JUnit4.x的使用。
2. 了解Mock的概念在单元测试中的应用。
3. 了解Hadoop中MapReduce的编程模型。

如果您对Junit和Mock不了解，可以先阅读[翻译]Unit testing with JUnit 4.x and EasyMock in Eclipse - Tutorial。

如果您对Hadoop中MapReduce的编程模型不了解，可以先阅读Map/Reduce Tutorial。

介绍

MRUnit是一款由Couldera公司开发的专门针对Hadoop中编写MapReduce单元测试的框架。

它可以用于0.18.x版本中的经典org.apache.hadoop.mapred.*的模型，也能在0.20.x版本org.apache.hadoop.mapreduce.*的新模型中使用。

官方的介绍如下：

MRUnit is a unit test library designed to facilitate easy integration between your MapReduce development process and standard development and testing tools such as JUnit. MRUnit contains mock objects that behave like classes you interact with during MapReduce execution (e.g., InputSplit and OutputCollector) as well as test harness "drivers" that test your program's correctness while maintaining compliance with the MapReduce semantics. Mapper and Reducer implementations can be tested individually, as well as together to form a full MapReduce job.

安装

在目前Hadoop的发行版中，并没有默认包含MRUnit。你需要去Couldera公司的官网中去下载一个由他们再次发行的版本。

推荐的版本为：hadoop-0.20.1+133.tar.gz。

下载这个文件后，你将在hadoop-0.20.1+133\contrib\mrunit目录中找到我们需要的jar包：hadoop-0.20.1+133-mrunit.jar。

为了使用MRUnit，我们需要将hadoop-0.20.1+133-mrunit.jar和Junit4.x使用的jar包：junit.jar都添加到我们开发Hadoop程序项目的classpath中。

示例

代码是最好的文档，我们先看一个简单的map单元测试示例，代码如下：

package gpcuster.cnblogs.com;

import junit.framework.TestCase;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.lib.IdentityMapper;
import org.junit.Before;
import org.junit.Test;
import org.apache.hadoop.mrunit.MapDriver;

public class TestExample extends TestCase {

  private Mapper mapper;
  private MapDriver driver;

  @Before
  public void setUp() {
    mapper = new IdentityMapper();
    driver = new MapDriver(mapper);
  }

  @Test
  public void testIdentityMapper() {
    driver.withInput(new Text("foo"), new Text("bar"))
            .withOutput(new Text("foo"), new Text("bar"))
            .runTest();
  }
}

在这段示例代码中，我们使用的map是org.apache.hadoop.mapred.lib.IdentityMapper。这是一个非常简单的map函数：输入什么，就输出什么。

org.apache.hadoop.mrunit.MapDriver是我们从MRUnit框架中导入的一个专门用于测试map的类。

我们通过withInput指定输入的参数，通过withOutput指定我们期望的输出，然后通过runTest运行我们的测试。

功能

1. 测试Map，我们可以使用MapDriver。
2. 测试Reduce，我们可以使用ReduceDriver。
3. 测试一个完整的MapReduce，我们可以使用MapReduceDriver。
4. 测试多个MapReduce组合而成的操作，我们可以使用PipelineMapReduceDriver。

实现

MRUnit框架非常精简，其核心的单元测试依赖于JUnit。

由于我们编写的MapReduce函数中包含有一个OutputCollector的对象，所以MRUnit自己实现了一套Mock对象来控制OutputCollector的操作。

局限

通过阅读MRUnit的源代码我们会发现：

1. 不支持MapReduce框架中的分区和排序操作：从Map输出的值经过shuffle处理后直接就导入Reduce中了。
2. 不支持Streaming实现的MapReduce操作。

虽然MRUnit有这些局限，但是足以完成大多数的需求。

参考资料

http://www.cloudera.com/hadoop-mrunit

本文地址：博客园逖靖寒 http://gpcuster.cnblogs.com

鑫龙 2013-04-03 11:27 发表评论

Mapreduce-Partition分析

鑫龙 — Mon, 01 Apr 2013 13:10:00 GMT

摘要: 转自:http://blog.oddfoo.net/2011/04/17/mapreduce-partition%E5%88%86%E6%9E%90-2/Partition所处的位置Partition位置Partition主要作用就是将map的结果发送到相应的reduce。这就对partition有两个要求：1）均衡负载，尽量的将工作均匀的分配给不同的reduce。2）效率，分配速度一定要快。Ma... 阅读全文

鑫龙 2013-04-01 21:10 发表评论

hadoop namenode启动过程详细剖析及瓶颈分析

鑫龙 — Thu, 28 Mar 2013 10:52:00 GMT

NameNode中几个关键的数据结构

FSImage

Namenode会将HDFS的文件和目录元数据存储在一个叫fsimage的二进制文件中，每次保存fsimage之后到下次保存之间的所有hdfs操作，将会记录在editlog文件中，当editlog达到一定的大小（bytes，由fs.checkpoint.size参数定义）或从上次保存过后一定时间段过后（sec，由fs.checkpoint.period参数定义），namenode会重新将内存中对整个HDFS的目录树和文件元数据刷到fsimage文件中。Namenode就是通过这种方式来保证HDFS中元数据信息的安全性。

Fsimage是一个二进制文件，当中记录了HDFS中所有文件和目录的元数据信息，在我的hadoop的HDFS版中，该文件的中保存文件和目录的格式如下：

当namenode重启加载fsimage时，就是按照如下格式协议从文件流中加载元数据信息。从fsimag的存储格式可以看出，fsimage保存有如下信息：

1. 首先是一个image head，其中包含：

a) imgVersion(int)：当前image的版本信息

b) namespaceID(int)：用来确保别的HDFS instance中的datanode不会误连上当前NN。

c) numFiles(long)：整个文件系统中包含有多少文件和目录

d) genStamp(long)：生成该image时的时间戳信息。

2. 接下来便是对每个文件或目录的源数据信息，如果是目录，则包含以下信息：

a) path(String)：该目录的路径，如”/user/build/build-index”

b) replications(short)：副本数（目录虽然没有副本，但这里记录的目录副本数也为3）

c) mtime(long)：该目录的修改时间的时间戳信息

d) atime(long)：该目录的访问时间的时间戳信息

e) blocksize(long)：目录的blocksize都为0

f) numBlocks(int)：实际有多少个文件块，目录的该值都为-1，表示该item为目录

g) nsQuota(long)：namespace Quota值，若没加Quota限制则为-1

h) dsQuota(long)：disk Quota值，若没加限制则也为-1

i) username(String)：该目录的所属用户名

j) group(String)：该目录的所属组

k) permission(short)：该目录的permission信息，如644等，有一个short来记录。

3. 若从fsimage中读到的item是一个文件，则还会额外包含如下信息：

a) blockid(long)：属于该文件的block的blockid，

b) numBytes(long)：该block的大小

c) genStamp(long)：该block的时间戳

当该文件对应的numBlocks数不为1，而是大于1时，表示该文件对应有多个block信息，此时紧接在该fsimage之后的就会有多个blockid，numBytes和genStamp信息。

因此，在namenode启动时，就需要对fsimage按照如下格式进行顺序的加载，以将fsimage中记录的HDFS元数据信息加载到内存中。

BlockMap

从以上fsimage中加载如namenode内存中的信息中可以很明显的看出，在fsimage中，并没有记录每一个block对应到哪几个datanodes的对应表信息，而只是存储了所有的关于namespace的相关信息。而真正每个block对应到datanodes列表的信息在hadoop中并没有进行持久化存储，而是在所有datanode启动时，每个datanode对本地磁盘进行扫描，将本datanode上保存的block信息汇报给namenode，namenode在接收到每个datanode的块信息汇报后，将接收到的块信息，以及其所在的datanode信息等保存在内存中。HDFS就是通过这种块信息汇报的方式来完成 block -> datanodes list的对应表构建。Datanode向namenode汇报块信息的过程叫做blockReport，而namenode将block -> datanodes list的对应表信息保存在一个叫BlocksMap的数据结构中。

BlocksMap的内部数据结构如下：

如上图显示，BlocksMap实际上就是一个Block对象对BlockInfo对象的一个Map表，其中Block对象中只记录了blockid，block大小以及时间戳信息，这些信息在fsimage中都有记录。而BlockInfo是从Block对象继承而来，因此除了Block对象中保存的信息外，还包括代表该block所属的HDFS文件的INodeFile对象引用以及该block所属datanodes列表的信息（即上图中的DN1，DN2，DN3，该数据结构会在下文详述）。

因此在namenode启动并加载fsimage完成之后，实际上BlocksMap中的key，也就是Block对象都已经加载到BlocksMap中，每个key对应的value(BlockInfo)中，除了表示其所属的datanodes列表的数组为空外，其他信息也都已经成功加载。所以可以说：fsimage加载完毕后，BlocksMap中仅缺少每个块对应到其所属的datanodes list的对应关系信息。所缺这些信息，就是通过上文提到的从各datanode接收blockReport来构建。当所有的datanode汇报给namenode的blockReport处理完毕后，BlocksMap整个结构也就构建完成。

BlockMap中datanode列表数据结构

在BlockInfo中，将该block所属的datanodes列表保存在一个Object[]数组中，但该数组不仅仅保存了datanodes列表，还包含了额外的信息。实际上该数组保存了如下信息：

上图表示一个block包含有三个副本，分别放置在DN1，DN2和DN3三个datanode上，每个datanode对应一个三元组，该三元组中的第二个元素，即上图中prev block所指的是该block在该datanode上的前一个BlockInfo引用。第三个元素，也就是上图中next Block所指的是该block在该datanode上的下一个BlockInfo引用。每个block有多少个副本，其对应的BlockInfo对象中就会有多少个这种三元组。

Namenode采用这种结构来保存block->datanode list的目的在于节约namenode内存。由于namenode将block->datanodes的对应关系保存在了内存当中，随着HDFS中文件数的增加，block数也会相应的增加，namenode为了保存block->datanodes的信息已经耗费了相当多的内存，如果还像这种方式一样的保存datanode->block list的对应表，势必耗费更多的内存，而且在实际应用中，要查一个datanode上保存的block list的应用实际上非常的少，大部分情况下是要根据block来查datanode列表，所以namenode中通过上图的方式来保存block->datanode list的对应关系，当需要查询datanode->block list的对应关系时，只需要沿着该数据结构中next Block的指向关系，就能得出结果，而又无需保存datanode->block list在内存中。

NameNode启动过程

fsimage加载过程

Fsimage加载过程完成的操作主要是为了：

1. 从fsimage中读取该HDFS中保存的每一个目录和每一个文件

2. 初始化每个目录和文件的元数据信息

3. 根据目录和文件的路径，构造出整个namespace在内存中的镜像

4. 如果是文件，则读取出该文件包含的所有blockid，并插入到BlocksMap中。

整个加载流程如下图所示：

如上图所示，namenode在加载fsimage过程其实非常简单，就是从fsimage中不停的顺序读取文件和目录的元数据信息，并在内存中构建整个namespace，同时将每个文件对应的blockid保存入BlocksMap中，此时BlocksMap中每个block对应的datanodes列表暂时为空。当fsimage加载完毕后，整个HDFS的目录结构在内存中就已经初始化完毕，所缺的就是每个文件对应的block对应的datanode列表信息。这些信息需要从datanode的blockReport中获取，所以加载fsimage完毕后，namenode进程进入rpc等待状态，等待所有的datanodes发送blockReports。

blockReport阶段

每个datanode在启动时都会扫描其机器上对应保存hdfs block的目录下(dfs.data.dir)所保存的所有文件块，然后通过namenode的rpc调用将这些block信息以一个long数组的方式发送给namenode，namenode在接收到一个datanode的blockReport rpc调用后，从rpc中解析出block数组，并将这些接收到的blocks插入到BlocksMap表中，由于此时BlocksMap缺少的仅仅是每个block对应的datanode信息，而namenoe能从report中获知当前report上来的是哪个datanode的块信息，所以，blockReport过程实际上就是namenode在接收到块信息汇报后，填充BlocksMap中每个block对应的datanodes列表的三元组信息的过程。其流程如下图所示:

当所有的datanode汇报完block，namenode针对每个datanode的汇报进行过处理后，namenode的启动过程到此结束。此时BlocksMap中block->datanodes的对应关系已经初始化完毕。如果此时已经达到安全模式的推出阈值，则hdfs主动退出安全模式，开始提供服务。

启动过程数据采集和瓶颈分析

对namenode的整个启动过程有了详细了解之后，就可以对其启动过程中各阶段各函数的调用耗时进行profiling的采集，数据的profiling仍然分为两个阶段，即fsimage加载阶段和blockReport阶段。

fsimage加载阶段性能数据采集和瓶颈分析

以下是对建库集群真实的fsimage加载过程的的性能采集数据：

从上图可以看出，fsimage的加载过程那个中，主要耗时的操作分别分布在FSDirectory.addToParent，FSImage.readString，以及PermissionStatus.read三个操作，这三个操作分别占用了加载过程的73%，15%以及8%，加起来总共消耗了整个加载过程的96%。而其中FSImage.readString和PermissionStatus.read操作都是从fsimage的文件流中读取数据（分别是读取String和short）的操作，这种操作优化的空间不大，但是通过调整该文件流的Buffer大小来提高少许性能。而FSDirectory.addToParent的调用却占用了整个加载过程的73%，所以该调用中的优化空间比较大。

以下是addToParent调用中的profiling数据：

从以上数据可以看出addToParent调用占用的73%的耗时中，有66%都耗在了INode.getPathComponents调用上，而这66%分别有36%消耗在INode.getPathNames调用，30%消耗在INode.getPathComponents调用。这两个耗时操作的具体分布如以下数据所示：

可以看出，消耗了36%的处理时间的INode.getPathNames操作，全部都是在通过String.split函数调用来对文件或目录路径进行切分。另外消耗了30%左右的处理时间在INode.getPathComponents中，该函数中最终耗时都耗在获取字符串的byte数组的java原生操作中。

blockReport阶段性能数据采集和瓶颈分析

由于blockReport的调用是通过datanode调用namenode的rpc调用，所以在namenode进入到等待blockreport阶段后，会分别开启rpc调用的监听线程和rpc调用的处理线程。其中rpc处理和rpc鉴定的调用耗时分布如下图所示：

而其中rpc的监听线程的优化是另外一个话题，在其他的issue中再详细讨论，且由于blockReport的操作实际上是触发的rpc处理线程，所以这里只关心rpc处理线程的性能数据。

在namenode处理blockReport过程中的调用耗时性能数据如下：

可以看出，在namenode启动阶段，处理从各个datanode汇报上来的blockReport耗费了整个rpc处理过程中的绝大部分时间(48/49)，blockReport处理逻辑中的耗时分布如下图：

从上图数据中可以发现，blockReport阶段中耗时分布主要耗时在FSNamesystem.addStoredBlock调用以及DatanodeDescriptor.reportDiff过程中，分别耗时37/48和10/48，其中FSNamesystem.addStoredBlock所进行的操作时对每一个汇报上来的block，将其于汇报上来的datanode的对应关系初始化到namenode内存中的BlocksMap表中。所以对于每一个block就会调用一次该方法。所以可以看到该方法在整个过程中调用了774819次，而另一个耗时的操作，即DatanodeDescriptor.reportDiff，该操作的过程在上文中有详细介绍，主要是为了将该datanode汇报上来的blocks跟namenode内存中的BlocksMap中进行对比，以决定那个哪些是需要添加到BlocksMap中的block，哪些是需要添加到toRemove队列中的block，以及哪些是添加到toValidate队列中的block。由于这个操作需要针对每一个汇报上来的block去查询BlocksMap，以及namenode中的其他几个map，所以该过程也非常的耗时。而且从调用次数上可以看出，reportDiff调用在启动过程中仅调用了14次(有14个datanode进行块汇报)，却耗费了10/48的时间。所以reportDiff也是整个blockReport过程中非常耗时的瓶颈所在。

同时可以看到，出了reportDiff，addStoredBlock的调用耗费了37%的时间，也就是耗费了整个blockReport时间的37/48，该方法的调用目的是为了将从datanode汇报上来的每一个block插入到BlocksMap中的操作。从该方法调用的运行数据如下图所示：

从上图可以看出，addStoredBlock中，主要耗时的两个阶段分别是FSNamesystem.countNode和DatanodeDescriptor.addBlock，后者是java中的插表操作，而FSNamesystem.countNode调用的目的是为了统计在BlocksMap中，每一个block对应的各副本中，有几个是live状态，几个是decommission状态，几个是Corrupt状态。而在namenode的启动初始化阶段，用来保存corrput状态和decommission状态的block的map都还是空状态，并且程序逻辑中要得到的仅仅是出于live状态的block数，所以，这里的countNoes调用在namenode启动初始化阶段并无需统计每个block对应的副本中的corrrput数和decommission数，而仅仅需要统计live状态的block副本数即可，这样countNodes能够在namenode启动阶段变得更轻量，以节省启动时间。

瓶颈分析总结

从profiling数据和瓶颈分歧情况来看，fsimage加载阶段的瓶颈除了在分切路径的过程中不够优以外，其他耗时的地方几乎都是在java原生接口的调用中，如从字节流读数据，以及从String对象中获取byte[]数组的操作。

而blockReport阶段的耗时其实很大的原因是跟当前的namenode设计以及内存结构有关，比较明显的不优之处就是在namenode启动阶段的countNode和reportDiff的必要性，这两处在namenode初始化时的blockReport阶段有一些不必要的操作浪费了时间。可以针对namenode启动阶段将必要的操作抽取出来，定制成namenode启动阶段才调用的方式，以优化namenode启动性能。

Ref: http://blog.csdn.net/ae86_fc/article/details/5842020

鑫龙 2013-03-28 18:52 发表评论

hadoop二次排序 (Map/Reduce中分区和分组的问题)

鑫龙 — Mon, 25 Mar 2013 11:38:00 GMT

1.二次排序概念：

首先按照第一字段排序，然后再对第一字段相同的行按照第二字段排序，注意不能破坏第一次排序的结果。

如：输入文件：

20 21
50 51
50 52
50 53
50 54
60 51
60 53
60 52
60 56
60 57
70 58
60 61
70 54
70 55
70 56
70 57
70 58
1 2
3 4
5 6
7 82
203 21
50 512
50 522
50 53
530 54
40 511
20 53
20 522
60 56
60 57
740 58
63 61
730 54
71 55
71 56
73 57
74 58
12 211
31 42
50 62
7 8

输出（需要分割线）：

------------------------------------------------
1       2
------------------------------------------------
3       4
------------------------------------------------
5       6
------------------------------------------------
7       8
7       82
------------------------------------------------
12      211
------------------------------------------------
20      21
20      53
20      522
------------------------------------------------
31      42
------------------------------------------------
40      511
------------------------------------------------
50      51
50      52
50      53
50      53
50      54
50      62
50      512
50      522
------------------------------------------------
60      51
60      52
60      53
60      56
60      56
60      57
60      57
60      61
------------------------------------------------
63      61
------------------------------------------------
70      54
70      55
70      56
70      57
70      58
70      58
------------------------------------------------
71      55
71      56
------------------------------------------------
73      57
------------------------------------------------
74      58
------------------------------------------------
203     21
------------------------------------------------
530     54
------------------------------------------------
730     54
------------------------------------------------
740     58

2.工作原理

使用如下map和reduce：（特别注意输入输出类型，其中IntPair为自定义类型）

public static class Map extends Mapper
public static class Reduce extends Reducer

在map阶段，使用job.setInputFormatClass(TextInputFormat)做为输入格式。注意输出应该符合自定义Map中定义的输出。最终是生成一个List。在map阶段的最后，会先调用job.setPartitionerClass对这个List进行分区，每个分区映射到一个reducer。每个分区内又调用job.setSortComparatorClass设置的key比较函数类排序。可以看到，这本身就是一个二次排序。如果没有通过job.setSortComparatorClass设置key比较函数类，则使用key的实现的compareTo方法。在随后的例子中，第一个例子中，使用了IntPair实现的compareTo方法，而在下一个例子中，专门定义了key比较函数类。

在reduce阶段，reducer接收到所有映射到这个reducer的map输出后，也是会调用job.setSortComparatorClass设置的key比较函数类对所有数据对排序。然后开始构造一个key对应的value迭代器。这时就要用到分组，使用jobjob.setGroupingComparatorClass设置的分组函数类。只要这个比较器比较的两个key相同，他们就属于同一个组，它们的value放在一个value迭代器，而这个迭代器的key使用属于同一个组的所有key的第一个key。最后就是进入Reducer的reduce方法，reduce方法的输入是所有的（key和它的value迭代器）。同样注意输入与输出的类型必须与自定义的Reducer中声明的一致。

3，具体步骤

（1）自定义key

在mr中，所有的key是需要被比较和排序的，并且是二次，先根据partitione，再根据大小。而本例中也是要比较两次。先按照第一字段排序，然后再对第一字段相同的按照第二字段排序。根据这一点，我们可以构造一个复合类IntPair，他有两个字段，先利用分区对第一字段排序，再利用分区内的比较对第二字段排序。
所有自定义的key应该实现接口WritableComparable，因为是可序列的并且可比较的。并重载方法：

//反序列化，从流中的二进制转换成IntPair
public void readFields(DataInput in) throws IOException
//序列化，将IntPair转化成使用流传送的二进制
public void write(DataOutput out)
//key的比较
public int compareTo(IntPair o)
//另外新定义的类应该重写的两个方法
//The hashCode() method is used by the HashPartitioner (the default partitioner in MapReduce)
public int hashCode()
public boolean equals(Object right)

（2）由于key是自定义的，所以还需要自定义一下类：
（2.1）分区函数类。这是key的第一次比较。

public static class FirstPartitioner extends Partitioner

在job中使用setPartitionerClasss设置Partitioner。
（2.2）key比较函数类。这是key的第二次比较。这是一个比较器，需要继承WritableComparator（也就是实现RawComprator接口）。

（这个就是前面说的第二种方法，但是在第三部分的代码中并没有实现此函数，而是直接使用compareTo方法进行比较，所以也就不许下面一行的设置）
在job中使用setSortComparatorClass设置key比较函数类。

public static class KeyComparator extends WritableComparator

2.3）分组函数类。在reduce阶段，构造一个key对应的value迭代器的时候，只要first相同就属于同一个组，放在一个value迭代器。这是一个比较器，需要继承WritableComparator。

public static class GroupingComparator extends WritableComparator

分组函数类也必须有一个构造函数，并且重载 public int compare(WritableComparable w1, WritableComparable w2)
分组函数类的另一种方法是实现接口RawComparator。
在job中使用setGroupingComparatorClass设置分组函数类。
另外注意的是，如果reduce的输入与输出不是同一种类型，则不要定义Combiner也使用reduce，因为Combiner的输出是reduce的输入。除非重新定义一个Combiner。

转自：http://www.cnblogs.com/dandingyy/archive/2013/03/08/2950703.html

鑫龙 2013-03-25 19:38 发表评论

hadoop面试时可能遇到的问题

鑫龙 — Mon, 18 Mar 2013 05:03:00 GMT

面试hadoop可能被问到的问题，你能回答出几个 ?

1、hadoop运行的原理?

2、mapreduce的原理?

3、HDFS存储的机制?

4、举一个简单的例子说明mapreduce是怎么来运行的 ?

5、面试的人给你出一些问题,让你用mapreduce来实现？

比如:现在有10个文件夹,每个文件夹都有1000000个url.现在让你找出top1000000url。

6、hadoop中Combiner的作用?

Src： http://p-x1984.javaeye.com/blog/859843

Q1. Name the most common InputFormats defined in Hadoop? Which one is default ?
Following 2 are most common InputFormats defined in Hadoop
- TextInputFormat
- KeyValueInputFormat
- SequenceFileInputFormat

Q2. What is the difference between TextInputFormatand KeyValueInputFormat class
TextInputFormat: It reads lines of text files and provides the offset of the line as key to the Mapper and actual line as Value to the mapper
KeyValueInputFormat: Reads text file and parses lines into key, val pairs. Everything up to the first tab character is sent as key to the Mapper and the remainder of the line is sent as value to the mapper.

Q3. What is InputSplit in Hadoop

When a hadoop job is run, it splits input files into chunks and assign each split to a mapper to process. This is called Input Split

Q4. How is the splitting of file invoked in Hadoop Framework

It is invoked by the Hadoop framework by running getInputSplit()method of the Input format class (like FileInputFormat) defined by the user

Q5. Consider case scenario: In M/R system,

- HDFS block size is 64 MB

- Input format is FileInputFormat

- We have 3 files of size 64K, 65Mb and 127Mb

then how many input splits will be made by Hadoop framework?

Hadoop will make 5 splits as follows

- 1 split for 64K files

- 2 splits for 65Mb files

- 2 splits for 127Mb file

Q6. What is the purpose of RecordReader in Hadoop

The InputSplithas defined a slice of work, but does not describe how to access it. The RecordReaderclass actually loads the data from its source and converts it into (key, value) pairs suitable for reading by the Mapper. The RecordReader instance is defined by the InputFormat

Q7. After the Map phase finishes, the hadoop framework does "Partitioning, Shuffle and sort". Explain what happens in this phase?

- Partitioning

Partitioning is the process of determining which reducer instance will receive which intermediate keys and values. Each mapper must determine for all of its output (key, value) pairs which reducer will receive them. It is necessary that for any key, regardless of which mapper instance generated it, the destination partition is the same

- Shuffle

After the first map tasks have completed, the nodes may still be performing several more map tasks each. But they also begin exchanging the intermediate outputs from the map tasks to where they are required by the reducers. This process of moving map outputs to the reducers is known as shuffling.

- Sort

Each reduce task is responsible for reducing the values associated with several intermediate keys. The set of intermediate keys on a single node is automatically sorted by Hadoop before they are presented to the Reducer

Q9. If no custom partitioner is defined in the hadoop then how is data partitioned before its sent to the reducer

The default partitioner computes a hash value for the key and assigns the partition based on this result

Q10. What is a Combiner

The Combiner is a "mini-reduce" process which operates only on data generated by a mapper. The Combiner will receive as input all data emitted by the Mapper instances on a given node. The output from the Combiner is then sent to the Reducers, instead of the output from the Mappers.

Q11. Give an example scenario where a cobiner can be used and where it cannot be used

There can be several examples following are the most common ones

- Scenario where you can use combiner

Getting list of distinct words in a file

- Scenario where you cannot use a combiner

Calculating mean of a list of numbers

Q12. What is job tracker

Job Tracker is the service within Hadoop that runs Map Reduce jobs on the cluster

Q13. What are some typical functions of Job Tracker

The following are some typical tasks of Job Tracker

- Accepts jobs from clients

- It talks to the NameNode to determine the location of the data

- It locates TaskTracker nodes with available slots at or near the data

- It submits the work to the chosen Task Tracker nodes and monitors progress of each task by receiving heartbeat signals from Task tracker

Q14. What is task tracker

Task Tracker is a node in the cluster that accepts tasks like Map, Reduce and Shuffle operations - from a JobTracker

Q15. Whats the relationship between Jobs and Tasks in Hadoop

One job is broken down into one or many tasks in Hadoop.

Q16. Suppose Hadoop spawned 100 tasks for a job and one of the task failed. What willhadoop do ?

It will restart the task again on some other task tracker and only if the task fails more than 4 (default setting and can be changed) times will it kill the job

Q17. Hadoop achieves parallelism by dividing the tasks across many nodes, it is possible for a few slow nodes to rate-limit the rest of the program and slow down the program. What mechanism Hadoop provides to combat this

Speculative Execution

Q18. How does speculative execution works in Hadoop

Job tracker makes different task trackers process same input. When tasks complete, they announce this fact to the Job Tracker. Whichever copy of a task finishes first becomes the definitive copy. If other copies were executing speculatively, Hadoop tells the Task Trackers to abandon the tasks and discard their outputs. The Reducers then receive their inputs from whichever Mapper completed successfully, first.

Q19. Using command line in Linux, how will you

- see all jobs running in the hadoop cluster

- kill a job

- hadoop job -list

- hadoop job -kill jobid

Q20. What is Hadoop Streaming

Streaming is a generic API that allows programs written in virtually any language to be used asHadoop Mapper and Reducer implementations

Q21. What is the characteristic of streaming API that makes it flexible run map reduce jobs in languages like perl, ruby, awk etc.

Hadoop Streaming allows to use arbitrary programs for the Mapper and Reducer phases of a Map Reduce job by having both Mappers and Reducers receive their input on stdin and emit output (key, value) pairs on stdout.

Q22. Whats is Distributed Cache in Hadoop
Distributed Cache is a facility provided by the Map/Reduce framework to cache files (text, archives, jars and so on) needed by applications during execution of the job. The framework will copy the necessary files to the slave node before any tasks for the job are executed on that node.

Q23. What is the benifit of Distributed cache, why can we just have the file in HDFS and have the application read it
This is because distributed cache is much faster. It copies the file to all trackers at the start of the job. Now if the task tracker runs 10 or 100 mappers or reducer, it will use the same copy of distributed cache. On the other hand, if you put code in file to read it from HDFS in the MR job then every mapper will try to access it from HDFS hence if a task tracker run 100 map jobs then it will try to read this file 100 times from HDFS. Also HDFS is not very efficient when used like this.

Q.24 What mechanism does Hadoop framework provides to synchronize changes made in Distribution Cache during runtime of the application
This is a trick questions. There is no such mechanism. Distributed Cache by design is read only during the time of Job execution

Q25. Have you ever used Counters in Hadoop. Give us an example scenario
Anybody who claims to have worked on a Hadoop project is expected to use counters

Q26. Is it possible to provide multiple input to Hadoop? If yes then how can you give multiple directories as input to the Hadoop job
Yes, The input format class provides methods to add multiple directories as input to a Hadoop job

Q27. Is it possible to have Hadoop job output in multiple directories. If yes then how
Yes, by using Multiple Outputs class

Q28. What will a hadoop job do if you try to run it with an output directory that is already present? Will it
- overwrite it
- warn you and continue
- throw an exception and exit
The hadoop job will throw an exception and exit.

Q29. How can you set an arbitary number of mappers to be created for a job in Hadoop
This is a trick question. You cannot set it

Q30. How can you set an arbitary number of reducers to be created for a job in Hadoop
You can either do it progamatically by using method setNumReduceTasksin the JobConfclass or set it up as a configuration setting

Src:http://xsh8637.blog.163.com/blog/#m=0&t=1&c=fks_084065087084081065083083087095086082081074093080080069

鑫龙 2013-03-18 13:03 发表评论

基于Hadoop Sequencefile的小文件解决方案

鑫龙 — Mon, 04 Mar 2013 11:28:00 GMT

基于Hadoop Sequencefile的小文件解决方案

一、概述

小文件是指文件size小于HDFS上block大小的文件。这样的文件会给hadoop的扩展性和性能带来严重问题。首先，在HDFS中，任何block，文件或者目录在内存中均以对象的形式存储，每个对象约占150byte，如果有1000 0000个小文件，每个文件占用一个block，则namenode大约需要2G空间。如果存储1亿个文件，则namenode需要20G空间。这样namenode内存容量严重制约了集群的扩展。其次，访问大量小文件速度远远小于访问几个大文件。HDFS最初是为流式访问大文件开发的，如果访问大量小文件，需要不断的从一个datanode跳到另一个datanode，严重影响性能。最后，处理大量小文件速度远远小于处理同等大小的大文件的速度。每一个小文件要占用一个slot，而task启动将耗费大量时间甚至大部分时间都耗费在启动task和释放task上。

二、Hadoop自带的解决方案

对于小文件问题，Hadoop本身也提供了几个解决方案，分别为：Hadoop Archive，Sequence file和CombineFileInputFormat。

（1） Hadoop Archive

Hadoop Archive或者HAR，是一个高效地将小文件放入HDFS块中的文件存档工具，它能够将多个小文件打包成一个HAR文件，这样在减少namenode内存使用的同时，仍然允许对文件进行透明的访问。

使用HAR时需要两点，第一，对小文件进行存档后，原文件并不会自动被删除，需要用户自己删除；第二，创建HAR文件的过程实际上是在运行一个mapreduce作业，因而需要有一个hadoop集群运行此命令。

该方案需人工进行维护，适用管理人员的操作，而且har文件一旦创建，Archives便不可改变，不能应用于多用户的互联网操作。

（2） Sequence file

sequence file由一系列的二进制key/value组成，如果为key小文件名，value为文件内容，则可以将大批小文件合并成一个大文件。

Hadoop-0.21.0中提供了SequenceFile，包括Writer，Reader和SequenceFileSorter类进行写，读和排序操作。如果hadoop版本低于0.21.0的版本，实现方法可参见[3]。

该方案对于小文件的存取都比较自由，不限制用户和文件的多少，但是SequenceFile文件不能追加写入，适用于一次性写入大量小文件的操作。

（3）CombineFileInputFormat

CombineFileInputFormat是一种新的inputformat，用于将多个文件合并成一个单独的split，另外，它会考虑数据的存储位置。

该方案版本比较老，网上资料甚少，从资料来看应该没有第二种方案好。

三、小文件问题解决方案

在原有HDFS基础上添加一个小文件处理模块，具体操作流程如下:

1. 当用户上传文件时，判断该文件是否属于小文件，如果是，则交给小文件处理模块处理，否则，交给通用文件处理模块处理。

2. 在小文件模块中开启一定时任务，其主要功能是当模块中文件总size大于HDFS上block大小的文件时，则通过SequenceFile组件以文件名做key，相应的文件内容为value将这些小文件一次性写入hdfs模块。

3. 同时删除已处理的文件，并将结果写入数据库。

4. 当用户进行读取操作时，可根据数据库中的结果标志来读取文件。

转自:http://lxm63972012.iteye.com/blog/1429011

鑫龙 2013-03-04 19:28 发表评论

hadoop jar xxxx.jar的流程

鑫龙 — Sat, 02 Mar 2013 09:28:00 GMT

jar -cvf xxx.jar .
hadopp jar xxx.jar clalss-name [input] [output]
----------------------------------------------------------------------
hadoop jar hadoop-0.20.2-examples.jar [class name]的实质是:

1.利用hadoop这个脚本启动一个jvm进程;

2.jvm进程去运行org.apache.hadoop.util.RunJar这个java类;

3.org.apache.hadoop.util.RunJar解压hadoop-0.20.2-examples.jar到hadoop.tmp.dir/hadoop-unjar*/目录下;

4.org.apache.hadoop.util.RunJar动态的加载并运行Main-Class或指定的Class;

5.Main-Class或指定的Class中设定Job的各项属性

6.提交job到JobTracker上并监视运行情况。

注意：以上都是在jobClient上执行的。

运行jar文件的时候，jar会被解压到hadoop.tmp.dir/hadoop-unjar*/目录下（如：/home/hadoop/hadoop-fs/dfs/temp/hadoop-unjar693919842639653083, 注意：这个目录是JobClient的目录，不是JobTracker的目录）。解压后的文件为：

drwxr-xr-x 2 hadoop hadoop 4096 Jul 30 15:40 META-INF

drwxr-xr-x 3 hadoop hadoop 4096 Jul 30 15:40 org

有图有真相：

提交job的实质是：

生成${job-id}/job.xml文件到hdfs://${mapred.system.dir}/（比如hdfs://bcn152:9990/home/hadoop/hadoop-fs/dfs/temp/mapred/system/job_201007301137_0012/job.xml），job的描述包括jar文件的路径，map|reduce类路径等等.

上传${job-id}/job.jar文件到hdfs://${mapred.system.dir}/（比如hdfs://bcn152:9990/home/hadoop/hadoop-fs/dfs/temp/mapred/system/job_201007301137_0012/job.jar）

有图有真相：

生成job之后，通过static JobClient.runJob()就会向jobTracker提交job:

JobClient jc = new JobClient(job);

RunningJob rj = jc.submitJob(job);

之后JobTracker就会调度此job，

提交job之后，使用下面的代码获取job的进度：

try {

if (!jc.monitorAndPrintJob(job, rj)) {

throw new IOException("Job failed!");

}

} catch (InterruptedException ie) {

Thread.currentThread().interrupt();

}

鑫龙 2013-03-02 17:28 发表评论

hadoop 序列化源码浅析 (转)

鑫龙 — Tue, 15 Jan 2013 13:48:00 GMT

摘要: 转自：http://my.oschina.net/tuzibuluo/blog?catalog=1278261.Writable接口 Hadoop 并没有使用 JAVA 的序列化，而是引入了自己实的序列化系统， package org.apache.hadoop.io 这个... 阅读全文

鑫龙 2013-01-15 21:48 发表评论

HADOOP_CLASSPATH设置(转)

鑫龙 — Fri, 28 Dec 2012 12:44:00 GMT

在写hadoop程序编译时，往往需要HADOOP_CLASSPATH路径，可通过以下方式进行在编译脚本中设置：

for f in $HADOOP_HOME/hadoop-*.jar; do
CLASSPATH=${CLASSPATH}:$f
done

for f in $HADOOP_HOME/lib/*.jar; do
CLASSPATH=${CLASSPATH}:$f
done

for f in $HIVE_HOME/lib/*.jar; do
CLASSPATH=${CLASSPATH}:$f
done

转自：http://blog.sina.com.cn/s/blog_62a9902f01017x7j.html

鑫龙 2012-12-28 20:44 发表评论

CentOS 5.5 安装hadoop-0.21.0(转)

鑫龙 — Tue, 25 Dec 2012 12:54:00 GMT

倒腾了一天，终于在CentOS上装上了hadoop-0.21.0，特此记录，以备后用。

操作系统：CentOS 5.5

Hadoop：hadoop-0.21.0
JDK：1.6.0_17
namenode主机名:master，namenode的IP:192.168.90.91
datanode主机名:slave，datanode的IP:192.168.90.94

第一步：安装并启动ssh服务

CentOS 5.5安装完毕之后以及默认启动了sshd服务，可以在“系统”－>“管理”->“服务”中查看sshd服务是否启动。当然了，如果机器上没有安装ssh服务，则执行命令sudo yum install ssh来安装。安装rsync，它是一个远程数据同步工具，可通过 LAN/WAN 快速同步多台主机间的文件，执行命令sudo yum install rsync。修改每个节点的/etc/hosts文件，将 namenode和datanode的IP信息加入到该文件的尾部：

192.168.90.91 master
192.168.90.94 slave

第二步，配置SSH服务

（1），（2）是针对每一台机器

（1）创建hadoop用户名与用户组

运行命令su - root，注意，不是命令su root，后者不能携带root用户的参数信息，是不能执行创建用户组和用户命令的。执行命令：groupadd hadoop和命令useradd -g hadoop hadoop。注意不能在/home目录下创建hadoop目录，否则创建hadoop用户会失败。创建好用户以后最好是重新启动计算机，以hadoop用户登录系统。这样在之后的操作中就不需要su到hadoop用户下，而且也不会纠缠于文件的owner问题。

（2）生成ssh密钥

如果是其他用户登录的则切换到hadoop用户下，执行命令su - hadoop，在/home/hadoop目录下执行命令：ssh-keygen -t rsa（一路回车，选择默认的保存路径），密钥生成成功之后，进入.ssh目录，执行cd .ssh，执行命令：cp id_rsa.pub authorized_keys。这个时候运行ssh localhost，让系统记住用户，之后ssh localhost就不需要再输入密码了。

（3）交换公钥

将namenode上的公钥拷贝到datanode，在hadoop用户的用户目录下（/home/hadoop）下执行命令ssh-copy-id -i $HOME/.ssh/id_rsa.pub hadoop@slave。同理，也可以将datanode上的公钥拷贝到namenode，但这不是必须的。这样两台机器在hadoop用户下互相ssh就不需要密码了。

第三步，安装JDK1.6或以上（每台机器）

（1）执行命令yum install jdk

（2）如果第一步没有找到源码包，那么就需要到官网上下载了，https://cds.sun.com/is-bin/INTERSHOP.enfinity/WFS/CDS-CDS_Developer-Site/en_US/-/USD/ViewProductDetail-Start?ProductRef=jdk-6u22-oth-JPR@CDS-CDS_Developer。

（3）新建目录/usr/java，将源码包jdk-6u22-linux-i586.bin复制到该目录下，执行命令chmod a+x jdk-6u22-linux-i586.bin
使当前用户拥有对jdk-6u22-linux-i586.bin的执行权限。执行命令sudo ./jdk-6u22-linux-i586.bin进行安装

（4）修改/etc/profile来添加环境变量，/etc/profile中设置的环境变量就像Windows下环境变量中的系统变量一样，所有用户都可以使用。
      用文本编辑器打开/etc/profile
      # vi /etc/profile
      在最后加入以下几行：
      export JAVA_HOME=/usr/java/jdk1.6.0_22
      export CLASSPATH=.:$JAVA_HOME/jre/lib/rt.jar:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
      export PATH=$PATH:$JAVA_HOME/bin
      这样我们就设置好了JDK，在centos下 source /etc/profile 就可以生效了.

运行命令java -version可以判断是否安装成功

第四步，安装hadoop

原来现在才开始安装hadoop，准备工作也作得太多了，废话少说。

（1）新建目录/usr/local/hadoop，将hadoop-0.21.0.tar.gz解压缩到该目录下，执行命令sudo tar -xvzf hadoop-0.21.0.tar.gz，修改/etc/profile文件，将hadoop的安装目录append到文件最后：

export HADOOP_HOME=/usr/local/hadoop/hadoop-0.21.0
export PATH=$HADOOP_HOME/bin:$PATH
（2）配置/conf/hadoop-env.sh文件，修改java_home环境变量
export JAVA_HOME=/usr/java/jdk1.6.0_22/
export HADOOP_CLASSPATH=.
（3）配置 core-site.xml 文件


            hadoop.tmp.dir
            /usr/local/hadoop/hadoop-0.21.0/tmp
           (注意，请先在 hadoopinstall 目录下建立 tmp 文件夹)
            A base for other temporary directories.



            fs.default.name
      hdfs://master:54310


（4）配置 hdfs-site.xml 文件


            dfs.replication
            1（这里共两台机器，如果将主节点也配置为datanode，则这里可以写2）


（5）配置 mapred-site.xml 文件


            mapred.job.tracker
            master:54311


（6）配置 conf/masters 文件，加入 namenode 的 ip 地址
master
（7）配置 slaves 文件, 加入所有 datanode 的 ip 地址

slave

(如果之前的hdfs-site.xml文件中的拷贝数设置为2，则需要将master也加入到slaves文件中)

（8）将 namenode 上配置好的 hadoop 所在文件夹 hadoop－0.21.0 复制到
datanode 的/usr/lcoal/hadoop/目录下（实际上 masters,slavers 文件时不必要的，复制了也
没问题）。
（9）配置datanode的/etc/profile 文件，在文件尾append下列内容：
export HADOOP_HOME=/usr/local/hadoop/hadoop-0.21.0
export PATH=$HADOOP_HOME/bin:$PATH

第五步，启动hadoop
首先记得关闭系统的防火墙，root用户下执行命令/etc/init.d/iptables stop，运行命令/etc/init.d/iptables status检查防火墙状态。hadoop用户下，在namenode的/usr/local/hadoop/hadoop-0.21.0/bin目录下打开终端，执行命令hadoop namenode -format，格式化目录节点。注意，/usr/local/hadoop/hadoop-0.21.0/tmp目录是可以写的，否则在格式化时会出现异常。执行命令start-all.sh启动hadoop集群，执行命令jps查看进程，执行命令hadoop dfsadmin -report查看状态。在浏览器中输入http://master:50070以web方式查看集群状态。查看jobtraker的运行状态：http://www.ibm.com/developerworks/cn/linux/l-hadoop-2/index.html
PS：格式化namenode的时候最好将节点的tmp目录清空、删除logs目录中的文件。

到这里，基于CentOS5.5的hadoop集群搭建完毕！

参考资料：http://www.ibm.com/developerworks/cn/linux/l-hadoop-2/index.html

鑫龙 2012-12-25 20:54 发表评论

从Hadoop框架与MapReduce模式中谈海量数据处理（含淘宝技术架构）(转)

鑫龙 — Sun, 23 Dec 2012 11:55:00 GMT

从hadoop框架与MapReduce模式中谈海量数据处理

前言

几周前，当我最初听到，以致后来初次接触Hadoop与MapReduce这两个东西，我便稍显兴奋，觉得它们很是神秘，而神秘的东西常能勾起我的兴趣，在看过介绍它们的文章或论文之后，觉得Hadoop是一项富有趣味和挑战性的技术，且它还牵扯到了一个我更加感兴趣的话题：海量数据处理。

由此，最近凡是空闲时，便在看“Hadoop”，“MapReduce”“海量数据处理”这方面的论文。但在看论文的过程中，总觉得那些论文都是浅尝辄止，常常看的很不过瘾，总是一个东西刚要讲到紧要处，它便结束了，让我好生“愤懑”。

尽管我对这个Hadoop与MapReduce知之甚浅，但我还是想记录自己的学习过程，说不定，关于这个东西的学习能督促我最终写成和“经典算法研究系列”一般的一系列文章。

Ok，闲话少说。本文从最基本的mapreduce模式，Hadoop框架开始谈起，然后由各自的架构引申开来，谈到海量数据处理，最后谈谈淘宝的海量数据产品技术架构，以为了兼备浅出与深入之效，最终，希望得到读者的喜欢与支持。谢谢。

由于本人是初次接触这两项技术，文章有任何问题，欢迎不吝指正。再谢一次。Ok，咱们开始吧。

第一部分、mapreduce模式与hadoop框架深入浅出

架构扼要

想读懂此文，读者必须先要明确以下几点，以作为阅读后续内容的基础知识储备：

Mapreduce是一种模式。
Hadoop是一种框架。
Hadoop是一个实现了mapreduce模式的开源的分布式并行编程框架。

所以，你现在，知道了什么是mapreduce，什么是hadoop，以及这两者之间最简单的联系，而本文的主旨即是，一句话概括：在hadoop的框架上采取mapreduce的模式处理海量数据。下面，咱们可以依次深入学习和了解mapreduce和hadoop这两个东西了。

Mapreduce模式

前面说了，mapreduce是一种模式，一种什么模式呢?一种云计算的核心计算模式，一种分布式运算技术，也是简化的分布式编程模式，它主要用于解决问题的程序开发模型，也是开发人员拆解问题的方法。

Ok，光说不上图，没用。如下图所示，mapreduce模式的主要思想是将自动分割要执行的问题（例如程序）拆解成map（映射）和reduce（化简）的方式，流程图如下图1所示：

在数据被分割后通过Map 函数的程序将数据映射成不同的区块，分配给计算机机群处理达到分布式运算的效果，在通过Reduce 函数的程序将结果汇整，从而输出开发者需要的结果。

MapReduce 借鉴了函数式程序设计语言的设计思想，其软件实现是指定一个Map 函数，把键值对(key/value)映射成新的键值对(key/value)，形成一系列中间结果形式的key/value 对，然后把它们传给Reduce(规约)函数，把具有相同中间形式key 的value 合并在一起。Map 和Reduce 函数具有一定的关联性。函数描述如表1 所示：

MapReduce致力于解决大规模数据处理的问题，因此在设计之初就考虑了数据的局部性原理，利用局部性原理将整个问题分而治之。MapReduce集群由普通PC机构成，为无共享式架构。在处理之前，将数据集分布至各个节点。处理时，每个节点就近读取本地存储的数据处理（map），将处理后的数据进行合并（combine）、排序（shuffle and sort）后再分发（至reduce节点），避免了大量数据的传输，提高了处理效率。无共享式架构的另一个好处是配合复制（replication）策略，集群可以具有良好的容错性，一部分节点的down机对集群的正常工作不会造成影响。

ok，你可以再简单看看下副图，整幅图是有关hadoop的作业调优参数及原理，图的左边是MapTask运行示意图，右边是ReduceTask运行示意图：

如上图所示，其中map阶段，当map task开始运算，并产生中间数据后并非直接而简单的写入磁盘，它首先利用内存buffer来对已经产生的buffer进行缓存，并在内存buffer中进行一些预排序来优化整个map的性能。而上图右边的reduce阶段则经历了三个阶段，分别Copy->Sort->reduce。我们能明显的看出，其中的Sort是采用的归并排序，即merge sort。

了解了什么是mapreduce，接下来，咱们可以来了解实现了mapreduce模式的开源框架—hadoop。

Hadoop框架

前面说了，hadoop是一个框架，一个什么样的框架呢?Hadoop 是一个实现了MapReduce 计算模型的开源分布式并行编程框架，程序员可以借助Hadoop 编写程序，将所编写的程序运行于计算机机群上，从而实现对海量数据的处理。

此外，Hadoop 还提供一个分布式文件系统(HDFS）及分布式数据库（HBase）用来将数据存储或部署到各个计算节点上。所以，你可以大致认为：Hadoop=HDFS（文件系统，数据存储技术相关）+HBase（数据库）+MapReduce（数据处理）。Hadoop 框架如图2 所示：

借助Hadoop 框架及云计算核心技术MapReduce 来实现数据的计算和存储，并且将HDFS 分布式文件系统和HBase 分布式数据库很好的融入到云计算框架中，从而实现云计算的分布式、并行计算和存储，并且得以实现很好的处理大规模数据的能力。

Hadoop的组成部分

我们已经知道，Hadoop是Google的MapReduce一个Java实现。MapReduce是一种简化的分布式编程模式，让程序自动分布到一个由普通机器组成的超大集群上并发执行。Hadoop主要由HDFS、MapReduce和HBase等组成。具体的hadoop的组成如下图：

由上图，我们可以看到：

1、 Hadoop HDFS是Google GFS存储系统的开源实现，主要应用场景是作为并行计算环境（MapReduce）的基础组件，同时也是BigTable（如HBase、HyperTable）的底层分布式文件系统。HDFS采用master/slave架构。一个HDFS集群是有由一个Namenode和一定数目的Datanode组成。Namenode是一个中心服务器，负责管理文件系统的namespace和客户端对文件的访问。Datanode在集群中一般是一个节点一个，负责管理节点上它们附带的存储。在内部，一个文件其实分成一个或多个block，这些block存储在Datanode集合里。如下图所示（HDFS体系结构图）：

2、 Hadoop MapReduce是一个使用简易的软件框架，基于它写出来的应用程序能够运行在由上千个商用机器组成的大型集群上，并以一种可靠容错的方式并行处理上TB级别的数据集。

一个MapReduce作业（job）通常会把输入的数据集切分为若干独立的数据块，由 Map任务（task）以完全并行的方式处理它们。框架会对Map的输出先进行排序，然后把结果输入给Reduce任务。通常作业的输入和输出都会被存储在文件系统中。整个框架负责任务的调度和监控，以及重新执行已经失败的任务。如下图所示（Hadoop MapReduce处理流程图）：

3、 Hive是基于Hadoop的一个数据仓库工具，处理能力强而且成本低廉。

主要特点：
存储方式是将结构化的数据文件映射为一张数据库表。提供类SQL语言，实现完整的SQL查询功能。可以将SQL语句转换为MapReduce任务运行，十分适合数据仓库的统计分析。
不足之处：
采用行存储的方式（SequenceFile）来存储和读取数据。效率低：当要读取数据表某一列数据时需要先取出所有数据然后再提取出某一列的数据，效率很低。同时，它还占用较多的磁盘空间。
由于以上的不足，有人（查礼博士）介绍了一种将分布式数据处理系统中以记录为单位的存储结构变为以列为单位的存储结构，进而减少磁盘访问数量，提高查询处理性能。这样，由于相同属性值具有相同数据类型和相近的数据特性，以属性值为单位进行压缩存储的压缩比更高，能节省更多的存储空间。如下图所示（行列存储的比较图）：

4、 HBase

HBase是一个分布式的、面向列的开源数据库，它不同于一般的关系数据库,是一个适合于非结构化数据存储的数据库。另一个不同的是HBase基于列的而不是基于行的模式。HBase使用和 BigTable非常相同的数据模型。用户存储数据行在一个表里。一个数据行拥有一个可选择的键和任意数量的列，一个或多个列组成一个ColumnFamily，一个Fmaily下的列位于一个HFile中，易于缓存数据。表是疏松的存储的，因此用户可以给行定义各种不同的列。在HBase中数据按主键排序，同时表按主键划分为多个HRegion，如下图所示（HBase数据表结构图）：

Ok，行文至此，看似洋洋洒洒近千里，但若给读者造成阅读上的负担，则不是我本意。接下来的内容，我不会再引用诸多繁杂的专业术语，以给读者心里上造成不良影响。

我再给出一副图，算是对上文所说的hadoop框架及其组成部分做个总结，如下图所示，便是hadoop的内部结构，我们可以看到，海量的数据交给hadoop处理后，在hadoop的内部中，正如上文所述：hadoop提供一个分布式文件系统（HDFS）及分布式数据库（Hbase）用来存储或部署到各个计算点上，最终在内部采取mapreduce的模式对其数据进行处理，然后输出处理结果：

第二部分、淘宝海量数据产品技术架构解读—学习海量数据处理经验

在上面的本文的第一部分中，我们已经对mapreduce模式及hadoop框架有了一个深入而全面的了解。不过，如果一个东西，或者一个概念不放到实际应用中去，那么你对这个理念永远只是停留在理论之内，无法向实践迈进。

Ok，接下来，本文的第二部分，咱们以淘宝的数据魔方技术架构为依托，通过介绍淘宝的海量数据产品技术架构，来进一步学习和了解海量数据处理的经验。

淘宝海量数据产品技术架构

如下图2-1所示，即是淘宝的海量数据产品技术架构，咱们下面要针对这个架构来一一剖析与解读。

相信，看过本博客内其它文章的细心读者，定会发现，图2-1最初见于本博客内的此篇文章：从几幅架构图中偷得半点海量数据处理经验之上，同时，此图2-1最初发表于《程序员》8月刊，作者：朋春。

在此之前，有一点必须说明的是：本文下面的内容大都是参考自朋春先生的这篇文章：淘宝数据魔方技术架构解析所写，我个人所作的工作是对这篇文章的一种解读与关键技术和内容的抽取，以为读者更好的理解淘宝的海量数据产品技术架构。与此同时，还能展示我自己读此篇的思路与感悟，顺带学习，何乐而不为呢?。

Ok，不过，与本博客内之前的那篇文章（几幅架构图中偷得半点海量数据处理经验）不同，本文接下来，要详细阐述这个架构。我也做了不少准备工作（如把这图2-1打印了下来，经常琢磨）：

图2-1 淘宝海量数据产品技术架构

好的，如上图所示，我们可以看到，淘宝的海量数据产品技术架构，分为以下五个层次，从上至下来看，它们分别是：数据源，计算层，存储层，查询层和产品层。我们来一一了解这五层：

数据来源层。存放着淘宝各店的交易数据。在数据源层产生的数据，通过DataX，DbSync和Timetunel准实时的传输到下面第2点所述的“云梯”。
计算层。在这个计算层内，淘宝采用的是hadoop集群，这个集群，我们暂且称之为云梯，是计算层的主要组成部分。在云梯上，系统每天会对数据产品进行不同的mapreduce计算。
存储层。在这一层，淘宝采用了两个东西，一个使MyFox，一个是Prom。MyFox是基于MySQL的分布式关系型数据库的集群，Prom是基于hadoop Hbase技术的（读者可别忘了，在上文第一部分中，咱们介绍到了这个hadoop的组成部分之一，Hbase—在hadoop之内的一个分布式的开源数据库）的一个NoSQL的存储集群。
查询层。在这一层中，有一个叫做glider的东西，这个glider是以HTTP协议对外提供restful方式的接口。数据产品通过一个唯一的URL来获取到它想要的数据。同时，数据查询即是通过MyFox来查询的。下文将具体介绍MyFox的数据查询过程。
产品层。简单理解，不作过多介绍。

接下来，咱们重点来了解第三层-存储层中的MyFox与Prom，然后会稍带分析下glide的技术架构，最后，再了解下缓存。文章即宣告结束。

我们知道，关系型数据库在我们现在的工业生产中有着广泛的引用，它包括Oracle，MySQL、DB2、Sybase和SQL Server等等。

MyFOX

淘宝选择了MySQL的MyISAM引擎作为底层的数据存储引擎。且为了应对海量数据，他们设计了分布式MySQL集群的查询代理层-MyFOX。

如下图所示，是MySQL的数据查询过程：

图2-2 MyFOX的数据查询过程

在MyFOX的每一个节点中，存放着热节点和冷节点两种节点数据。顾名思义，热节点存放着最新的，被访问频率较高的数据；冷节点，存放着相对而来比较旧的，访问频率比较低的数据。而为了存储这两种节点数据，出于硬件条件和存储成本的考虑，你当然会考虑选择两种不同的硬盘，来存储这两种访问频率不同的节点数据。如下图所示：

图2-3 MyFOX节点结构

“热节点”，选择每分钟15000转的SAS硬盘，按照一个节点两台机器来计算，单位数据的存储成本约为4.5W/TB。相对应地，“冷数据”我们选择了每分钟7500转的SATA硬盘，单碟上能够存放更多的数据，存储成本约为1.6W/TB。

Prom

出于文章篇幅的考虑，本文接下来不再过多阐述这个Prom了。如下面两幅图所示，他们分别表示的是Prom的存储结构以及Prom查询过程：
图2-4 Prom的存储结构

图2-5 Prom查询过程

glide的技术架构

图2-6 glider的技术架构

在这一层-查询层中，淘宝主要是基于用中间层隔离前后端的理念而考虑。Glider这个中间层负责各个异构表之间的数据JOIN和UNION等计算，并且负责隔离前端产品和后端存储，提供统一的数据查询服务。

缓存

除了起到隔离前后端以及异构“表”之间的数据整合的作用之外，glider的另外一个不容忽视的作用便是缓存管理。我们有一点须了解，在特定的时间段内，我们认为数据产品中的数据是只读的，这是利用缓存来提高性能的理论基础。

在上文图2-6中我们看到，glider中存在两层缓存，分别是基于各个异构“表”（datasource）的二级缓存和整合之后基于独立请求的一级缓存。除此之外，各个异构“表”内部可能还存在自己的缓存机制。

图2-7 缓存控制体系

图2-7向我们展示了数据魔方在缓存控制方面的设计思路。用户的请求中一定是带了缓存控制的“命令”的，这包括URL中的query string，和HTTP头中的“If-None-Match”信息。并且，这个缓存控制“命令”一定会经过层层传递，最终传递到底层存储的异构“表”模块。

缓存系统往往有两个问题需要面对和考虑：缓存穿透与失效时的雪崩效应。

缓存穿透是指查询一个一定不存在的数据，由于缓存是不命中时被动写的，并且出于容错考虑，如果从存储层查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。至于如何有效地解决缓存穿透问题，最常见的则是采用布隆过滤器（这个东西，在我的此篇文章中有介绍：），将所有可能存在的数据哈希到一个足够大的bitmap中，一个一定不存在的数据会被这个bitmap拦截掉，从而避免了对底层存储系统的查询压力。

而在数据魔方里，淘宝采用了一个更为简单粗暴的方法，如果一个查询返回的数据为空（不管是数据不存在，还是系统故障），我们仍然把这个空结果进行缓存，但它的过期时间会很短，最长不超过五分钟。

2、缓存失效时的雪崩效应尽管对底层系统的冲击非常可怕。但遗憾的是，这个问题目前并没有很完美的解决方案。大多数系统设计者考虑用加锁或者队列的方式保证缓存的单线程（进程）写，从而避免失效时大量的并发请求落到底层存储系统上。

在数据魔方中，淘宝设计的缓存过期机制理论上能够将各个客户端的数据失效时间均匀地分布在时间轴上，一定程度上能够避免缓存同时失效带来的雪崩效应。

本文参考：

基于云计算的海量数据存储模型，侯建等。
基于hadoop的海量日志数据处理，王小森
基于hadoop的大规模数据处理系统，王丽兵。
淘宝数据魔方技术架构解析，朋春。
Hadoop作业调优参数整理及原理，guili。

读者点评@xdylxdyl：

We want to count all the books in the library. You count up shelf #1, I count up shelf #2. That's map. The more people we get, the faster it goes. Now we get together and add our individual counts. That's reduce。
数据魔方里的缓存穿透,架构,空数据缓存这些和Hadoop一点关系都么有，如果是想讲一个Hadoop的具体应用的话,数据魔方这部分其实没讲清楚的。
感觉你是把两个东西混在一起了。不过这两个都是挺有价值的东西,或者说数据魔方的架构比Hadoop可能更重要一些,基本上大的互联网公司都会选择这么做。Null对象的缓存保留五分钟未必会有好的结果吧,如果Null对象不是特别大,数据的更新和插入不多也可以考虑实时维护。
Hadoop本身很笨重，不知道在数据魔方里是否是在扮演着实时数据处理的角色?还是只是在做线下的数据分析的？

结语：写文章是一种学习的过程。尊重他人劳动成果，转载请注明出处。谢谢。July、2011/8/20。完。

转自: http://blog.csdn.net/v_july_v/article/details/6704077

鑫龙 2012-12-23 19:55 发表评论