reduce

今日我在eclipse上运行Map/Reduce框架进行数据分析的时候遇到了一个很奇怪的错误： 一开始我发现运行程序之后也没在控制台报错，也生成了目标目录，但一直出不来统计好的数据文件。 我先通过位置标记输出来判断各个类的加载是否正常， 发现Map是可以正常加载执行的，但是Reduce一直无法加载执行。 然后我通过设置，让其在运行时显示日志信息，再运行。 文末会分享设置显示日志信息的方法。 这一次便发现了如下的报错： 日志中的报错信息： java.lang.Exception: org.apache.hadoop.mapreduce.task.reduce.Shuffle$ShuffleError: error in shuffle in localfetcher#1at org.apache.hadoop.mapred.LocalJobRunner$Job.runTasks(LocalJobRunner.java:462)at org.apache.hadoop.mapred.LocalJobRunner$Job.run(LocalJobRunner.java:529)Caused by: org.apache.hadoop.mapreduce.task.reduce.Shuffle$ShuffleError: error in shuffle in localfetcher#1at org.apache.hadoop.mapreduce.task.reduce.Shuffle.run(Shuffle.java:134)at org.apache.hadoop.mapred.ReduceTask.run(ReduceTask.java:376)at org.apache.hadoop.mapred.LocalJobRunner$Job$ReduceTaskRunnable.run(LocalJobRunner.java:319)at java.util.concurrent.Executors$RunnableAdapter.call(Unknown Source)at java.util.concurrent.FutureTask.run(Unknown Source)at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)at java.lang.Thread.run(Unknown Source)Caused by:（1）]java.io.FileNotFoundException: E:/tmp/hadoop-Alan%20Yang/mapred/local/localRunner/Alan%20Yang/jobcache/job_local214639494_0001/attempt_local214639494_0001_m_000003_0/output/file.out.indexat org.apache.hadoop.fs.RawLocalFileSystem.open(RawLocalFileSystem.java:200)at org.apache.hadoop.fs.FileSystem.open(FileSystem.java:767)at （2）]org.apache.hadoop.io.SecureIOUtils.openFSDataInputStream(SecureIOUtils.java:156)at org.apache.hadoop.mapred.SpillRecord.<init>(SpillRecord.java:70)at org.apache.hadoop.mapred.SpillRecord.<init>(SpillRecord.java:62)at org.apache.hadoop.mapred.SpillRecord.<init>(SpillRecord.java:57)at org.apache.hadoop.mapreduce.task.reduce.LocalFetcher.copyMapOutput(LocalFetcher.java:124)at org.apache.hadoop.mapreduce.task.reduce.LocalFetcher.doCopy(LocalFetcher.java:102)at org.apache.hadoop.mapreduce.task.reduce.LocalFetcher.run(LocalFetcher.java:85)2017-07-12 16:19:02,616 INFO [org.apache.hadoop.mapreduce.Job] - Job job_local214639494_0001 failed with state FAILED due to: NA2017-07-12 16:19:02,663 INFO [org.apache.hadoop.mapreduce.Job] - Counters: 22File System CountersFILE: Number of bytes read=62223FILE: Number of bytes written=176635984FILE: Number of read operations=0FILE: Number of large read operations=0FILE: Number of write operations=0HDFS: Number of bytes read=898750946HDFS: Number of bytes written=0HDFS: Number of read operations=140HDFS: Number of large read operations=0HDFS: Number of write operations=10Map-Reduce FrameworkMap input records=2629660Map output records=2626091Map output bytes=26260910Map output materialized bytes=31513152Input split bytes=1210Combine input records=0Spilled Records=2626091Failed Shuffles=0Merged Map outputs=0GC time elapsed (ms)=496Total committed heap usage (bytes)=7754743808File Input Format Counters Bytes Read=163038920 按照通常的排错思路，后面的错误往往是前面的错误导致产生的，所以我先入为主的直接去搜索 error in shuffle in localfetcher的解决办法，发现几乎都在说是内存的问题。百般尝试始终是毫无成效。 后来当我往下看的时候发现其实日志给出了大概的错误原因，是路径的问题。这一下子就找到了正确的方向。通过查找资料，发现有的朋友通过修改默认的路径即可解决，我尝试了一下，结果只是换个路径报错而已。这就耐人寻味了，我再自己看了看这条报错信息，里面用到了我的Windows的用户名，但是中间的空格变成了%20，在路径中出现%这意味着什么？配过环境变量的人都知道。我一下子恍然大悟。很有可能是Windows用户名的问题。所以我去修改了Windows本机的用户名，把空格去掉。一下子就解决了！！！ eclipse控制台不显示MapReduce程序日志的解决方法： 使用Hadoop2.6.0，在eclipse下面调试mapreduce程序的时候，控制台不打印程序运行时的日志，而是显示如下信息： log4j:WARN No appenders could be found for logger (org.apache.[Hadoop] log4j:WARN Please initialize the log4j system properly. log4j:WARN [hadoop] See noconfig for more info. 说明没有配置log4j.properties文件。这虽然不影响程序的正常运行，但是看不到日志难免不爽。解决方法：把Hadoop2.6.0的安装目录下面的/etc/hadoop／目录下面的log4j.properties文件拷贝放到MapReduce工程的src目录下面。

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

客户端（client） 提交MapReduce作业 JobTracker 1.作业调度：将一个作业（Job）分成若干个子任务分发到taskTraker中去执行 2.任务监控：TaskTracker发送心跳给JobTracker报告自己的运行状态，以让JobTracker能够监控到他 3.资源管理：每个任务向JobTracker申请资源 4.监控过程中发现失败或者运行过慢的任务，对他进行重新启动 TaskTracker 主动发送心跳给jobTracker并与JobTracker通信，从而接受到JobTracker发送过来需要执行的任务 资源表示模型 用于描述资源表示形式，Hadoop1.0使用“槽位（slot）”组织各个节点的资源，为了简化资源的管理，Hadoop将各个节点上资源（CPU、内存、网络IO、磁盘IO等等）等量切分成若干份，每一份用“slot”表示，同时规定一个task可根据实际情况需要占用多个”slot”。 简单的说：hadoop1.0将多维度的资源进行了抽象，使用“slot”来表示，从而简化对资源的管理。 资源分配模型 而资源分配模型则决定如何将资源分配给各个作业/任务，在Hadoop中，这一部分由一个插拔式的调度器完成。 更进一步说，slot相当于运行的“许可证”，一个任务只有获得“许可证”后，才能够获得运行的机会，这也意味着，每一个节点上的slot的数量决定了当前节点能够并发执行多少个任务。Hadoop1.0为了区分MapTask跟ReduceTask所使用资源的差异，进一步将slot分为MapSlot跟ReduceSlot，他们分别只能被MapTask跟ReduceTask使用。 Hadoop集群管理员可根据各个节点硬件配置和应用特点为它们分配不同的map slot数（由参数mapred.tasktracker.map.tasks.maximum指定）和reduce slot数（由参数mapred.tasktrackerreduce.tasks.maximum指定） 静态资源配置 。 采用了静态资源设置策略，即每个节点事先配置好可用的slot总数，这些slot数目一旦启动后无法再动态修改。 资源无法共享 。 Hadoop 1.0将slot分为Map slot和Reduce slot两种，且不允许共享。对于一个作业，刚开始运行时，Map slot资源紧缺而Reduce slot空闲，当Map Task全部运行完成后，Reduce slot紧缺而Map slot空闲。很明显，这种区分slot类别的资源管理方案在一定程度上降低了slot的利用率。 资源划分粒度过大 。资源划分粒度过大，往往会造成节点资源利用率过高或者过低 ，比如，管理员事先规划好一个slot代表2GB内存和1个CPU，如果一个应用程序的任务只需要1GB内存，则会产生“资源碎片”，从而降低集群资源的利用率，同样，如果一个应用程序的任务需要3GB内存，则会隐式地抢占其他任务的资源，从而产生资源抢占现象，可能导致集群利用率过高。 没引入有效的资源隔离机制 。Hadoop 1.0仅采用了基于jvm的资源隔离机制，这种方式仍过于粗糙，很多资源，比如CPU，无法进行隔离，这会造成同一个节点上的任务之间干扰严重。 主要是InputFormat。InputFormat类有2个重要的作用： 1）将输入的数据切分为多个逻辑上的InputSplit，其中每一个InputSplit作为一个map的输入。 2）提供一个RecordReader，用于将InputSplit的内容转换为可以作为map输入的k,v键值对。 系统默认的RecordReader是 LineRecordReader ，它是 TextInputFormat (FileInputFormat的子类)对应的RecordReader; Map读入的Key值是偏移量，Value是行内容。 两个Mapper各自输入一块数据，由键值对构成，对它进行加工（加上了个字符n），然后按加工后的数据的键进行分组，相同的键到相同的机器。这样的话，第一台机器分到了键nk1和nk3，第二台机器分到了键nk2。 接下来再在这些Reducers上执行聚合操作（这里执行的是是count），输出就是nk1出现了2次，nk3出现了1次，nk2出现了3次。从全局上来看，MapReduce就是一个分布式的GroupBy的过程。 从上图可以看到，Global Shuffle左边，两台机器执行的是Map。Global Shuffle右边，两台机器执行的是Reduce。 Hadoop会将输入数据划分成等长的数据块，成为数据分片。Hadoop会为每个分片构建一个map任务。并行的处理分片时间肯定会少于处理整个大数据块的时间，但由于各个节点性能及作业运行情况的不同，每个分片的处理时间可能不一样，因此， 把数据分片切分的更细可以得到更好的负载均衡 。 但另一方面，分片太小的话，管理分片和构建map任务的时间将会增多。因此，需要在hadoop分片大小和处理分片时间之间做一个权衡。对大多数作业来说，一个分片大小为64MB比较合适，其实，Hadoop的默认块大小也是64MB。 我们上面看到了hadoop的数据块大小与最佳分片大小相同，这样的话，数据分片就不容易跨数据块存储，因此，一个map任务的输入分片便可以直接读取本地数据块，这就 避免了再从其它节点读取分片数据 ，从而节省了网络开销。 map的任务输出是 写入到本地磁盘而非HDFS的 。那么为什么呢？因为map任务输出的是中间结果，一旦map任务完成即会被删除，如果把它存入HDFS中并实现备份容错，未免有点大题小做。如果一个map任务失败，hadoop会再另一个节点重启map一个map任务。 而reduce任务并不具备数据本地化优势——单个reduce任务的输入通常来自所有mapper输出。一般排序过的map输出需要通过 网络传输 发送到运行reduce任务的节点，并在reduce端进行合并。reduce的输出通常需要存储到HDFS中以实现可靠存储。每个reduce输出HDFS块第一个复本会存储在本地节点，而其它复本则存储到其它节点，因此reduce输出也需要占用网络带宽。 1.调整reduce个数方法（1） （1）每个Reduce处理的数据量默认是256MB （2）每个任务最大的reduce数，默认为1009 （3）计算reducer数的公式 2.调整reduce个数方法（2） 在hadoop的mapred-default.xml文件中修改，设置每个job的Reduce个数 3.reduce个数并不是越多越好 （1）过多的启动和初始化reduce也会消耗时间和资源； （2）另外，有多少个reduce，就会有多少个输出文件，如果产生了很多个小文件，那么如果这些小文件作为下一个任务的输入，则也会出现小文件过多的问题； 在设置reduce个数的时候也需要考虑这两个原则：处理大数据利用适合的reduce数；使单个reduce任务处理数据大小要合适； 在进行map计算之前，mapreduce会根据输入文件计算输入分片（input split），每个输入分片（input split）针对一个map任务，输入分片（input split）存储的并非数据本身，而是一个分片长度和一个记录数据的位置的数组，输入分片（input split）往往和hdfs的block（块）关系很密切，我们没有设置分片的范围的时候，分片大小是由block块大小决定的，和它的大小一样。 比如把一个258MB的文件上传到HDFS上，假设block块大小是128MB，那么它就会被分成三个block块，与之对应产生三个split，所以最终会产生三个map task。我又发现了另一个问题，第三个block块里存的文件大小只有2MB，而它的block块大小是128MB，那它实际占用Linux file system的多大空间？答案是实际的文件大小，而非一个块的大小。最后一个问题是： 如果hdfs占用Linux file system的磁盘空间按实际文件大小算，那么这个”块大小“有必要存在吗？其实块大小还是必要的，一个显而易见的作用就是当文件通过append操作不断增长的过程中，可以通过来block size决定何时split文件。 1．每个输入分片会让一个map任务来处理，map输出的结果会暂且放在一个环形内存缓冲区中（该缓冲区的大小默认为100M，由io.sort.mb属性控制），当该缓冲区快要溢出时（默认为缓冲区大小的80%，由io.sort.spill.percent属性控制），会在本地文件系统中创建一个溢出文件，将该缓冲区中的数据写入这个文件。 2．在写入磁盘之前，线程首先根据reduce任务的数目将数据划分为相同数目的分区，也就是一个reduce任务对应一个分区的数据。这样做是为了避免有些reduce任务分配到大量数据，而有些reduce任务却分到很少数据，甚至没有分到数据的尴尬局面。其实分区就是对数据进行hash的过程。然后对每个分区中的数据进行 排序 ，如果此时设置了Combiner，将排序后的结果进行Combiner操作，主要是在map计算出中间文件前做一个简单的合并重复key值的操作，这样做的目的是让尽可能少的数据写入到磁盘。 3．当map任务输出最后一个记录时，可能会有很多的溢出文件，这时需要将这些文件合并。合并的过程中会不断地进行排序和Combiner操作，目的有两个：1.尽量减少每次写入磁盘的数据量；2.尽量减少下一复制阶段网络传输的数据量。最后合并成了一个 已分区且已排序 的文件。为了减少网络传输的数据量，这里可以将数据压缩，只要将mapred.compress.map.out设置为true就可以了。 4．将分区中的数据 拷贝 （网络传输）给相对应的reduce任务。有人可能会问：分区中的数据怎么知道它对应的reduce是哪个呢？其实map任务一直和其父TaskTracker保持联系，而TaskTracker又一直和JobTracker保持心跳。所以JobTracker中保存了整个集群中的宏观信息。只要reduce任务向JobTracker获取对应的map输出位置就ok了哦。 Reduce端： 1．Reduce会接收到不同map任务传来的数据，并且每个map传来的数据都是有序的。如果reduce端接受的数据量相当小，则直接存储在内存中（缓冲区大小由mapred.job.shuffle.input.buffer.percent属性控制，表示用作此用途的堆空间的百分比），如果数据量超过了该缓冲区大小的一定比例（由mapred.job.shuffle.merge.percent决定），则对 数据合并 后 溢写 到磁盘中。 2．随着溢写文件的增多，后台线程会将它们合并成一个更大的有序的文件，这样做是为了给后面的合并节省时间。其实不管在map端还是reduce端，MapReduce都是反复地执行排序，合并操作，现在终于明白了有些人为什么会说：排序是hadoop的灵魂。 3．合并的过程中会产生许多的中间文件（写入磁盘了），但MapReduce会让写入磁盘的数据尽可能地少，并且 最后一次合并的结果 并没有写入磁盘，而是直接输入到reduce函数。 Read阶段 ：MapTask通过用户编写的RecordReader，从输入InputSplit中解析出一个个key/value Map阶段 ：该节点主要是将解析出的key/value交给用户编写map()函数处理，并产生一系列新的key/value。 Collect收集阶段 ：在用户编写map()函数中，当数据处理完成后，一般会调用OutputCollection.collect()输出结果。在该函数内部，它会将生成的 key/value分区 （调用Partitioner），并写入一个环形内存缓冲区中。 Spill阶段 ：即“溢写”，当环形缓冲区满后，MapReduce会将数据写入本地磁盘上，生成一个临时文件。需要注意的是，将数据写入本地磁盘之前，先要对数据进行一次本地 排序 ，并在必要时对数据进行 combiner 、 压缩 等操作。 溢写阶段详情： 合并阶段 ：当所有数据处理完成后，MapTask对所有临时文件进行一次合并，以确保最终只会生成一个数据文件。在进行文件合并过程中，MapTask以分区为单位进行合并。对于某个分区，它将采用多轮递归合并的方式。每轮合并io.sort.factor（默认100）个文件，并将产生的文件重新加入待合并列表中，对文件排序后，重复以上过程，直到最终得到一个大文件。让一个MapTask最终只生成一个数据文件，可避免同时打开大量文件和同时读取大量小文件产生的随机读取带来的开销。

reduce pollution减污

减少到

reduce you to tears让你掉眼泪词条：reduce词义：（PHRASE短语） 使…落泪英英释义：If someone or something reduces you to tears, they make you feel so unhappy that you cry.【例句】The attentions of the media reduced her to tears.媒体的关注把她弄哭了。

【答案】：A本题考查动词词义的辨析。填入的动词，表达Increased use of IC cards（对IC卡使用的增加）对 the space needed for ticket vending (售票需要的空间)的影响。根据上文可知道，IC卡的使用替代了传统的车票和定期券，因此空格所在句子的含义是：IC卡使用的增加减少了售票所占的空间。关键看四个选项哪个与space搭配，符合文意。［A］项reduce“减少，缩小”，用法较为广泛，除表示数量、大小、价格等的减少外，还可以接表抽象含义的词，如reduce the risk of detection（减少被发现的危险），原文意为：对IC卡使用的增加将会减少售票占用的空间。［B］项narrow“使变狭窄，使缩小”与space搭配，指“使空间变得狭小”，有“拥挤”的含义；［C］项dwarf指“（通过与大的事物比较）使显得小”，而实际大小没有改变，如Most professional basketball players dwarf other men（大多数职业篮球运动员使别人显得矮小）；［D］项shrink意为“使事物本身缩小或萎缩”，如shrink the markets for the exports（使出口市场萎缩），均不符合文意。

shrink是收缩、缩小，reduce是减少

更亮 更暗 几份复印件 减少/增大 扫描到

relief 减轻（压力）望采纳

reduce by 减至 reduce to 减少

为了健康，不要使用黄油，猪油和牛油，仅使用少量的植物油或涂抹减脂奶油。吃肉的时候，挑选瘦肉或已经去掉可见脂肪的肉。 （仅供参考，翻译字字对应反而不通顺）

part-r-0000这个文件时存放在hdfs上的，并非本地文件系统，所以你当然找不到了，你只能通过hdfs的命令查看，或者使用插件。hdfs的文件虽然底层也是存放在本地文件系统的，但是你是没法显式查看的，跟数据库一样的。

分析在MongoDB中正成为越来越重要的话题，因为它在越来越多的大型项目中使用。人们厌倦了使用不同的软件来做分析（包括Hadoop），分析在MongoDB中正成为越来越重要的话题，因为它在越来越多的大型项目中使用。人们厌倦了使用不同的软件来做分析（包括Hadoop），它们显然需要传输大量开销的数据。MongoDB提供了两种内置分析数据的方法：Map Reduce和Aggregation框架。MR非常灵活，很容易部署。它通过分区工作良好，，并允许大量输出。MR在MongoDB v2.4中，通过使用JavaScript引擎把Spider Monkey替换成V8,性能提升很多。老板抱怨它太慢了，尤其是和Agg框架（使用C++）相比。让我们看看能否从中榨出点果汁。练习让我们插入1千万条文档，每个文档包含一个从0到1000000的整数。这意味着平均有10个文档会具有相同的值。> for (var i = 0; i < 10000000; ++i){ db.uniques.insert({ dim0: Math.floor(Math.random()*1000000) });}> db.uniques.findOne(){ "_id" : ObjectId("51d3c386acd412e22c188dec"), "dim0" : 570859 }> db.uniques.ensureIndex({dim0: 1})> db.uniques.stats(){ "ns" : "test.uniques", "count" : 10000000, "size" : 360000052, "avgObjSize" : 36.0000052, "storageSize" : 582864896, "numExtents" : 18, "nindexes" : 2, "lastExtentSize" : 153874432, "paddingFactor" : 1, "systemFlags" : 1, "userFlags" : 0, "totalIndexSize" : 576040080, "indexSizes" : { "_id_" : 324456384, "dim0_1" : 251583696 }, "ok" : 1}从这其中，我们想要计算出现的不同值的个数。可以用下列MR任务轻松完成这个工作: > db.runCommand({ mapreduce: "uniques", map: function () { emit(this.dim0, 1); }, reduce: function (key, values) { return Array.sum(values); }, out: "mrout" }){ "result" : "mrout", "timeMillis" : 1161960, "counts" : { "input" : 10000000, "emit" : 10000000, "reduce" : 1059138, "output" : 999961 }, "ok" : 1}正如你在输出内容中看到的，这耗费了大概1200秒(在EC2 M3实例上进行的测试)。有1千万个map，1百万个reduce，输出了999961个文档。结果就像下面这样: > db.mrout.find(){ "_id" : 1, "value" : 10 }{ "_id" : 2, "value" : 5 }{ "_id" : 3, "value" : 6 }{ "_id" : 4, "value" : 10 }{ "_id" : 5, "value" : 9 }{ "_id" : 6, "value" : 12 }{ "_id" : 7, "value" : 5 }{ "_id" : 8, "value" : 16 }{ "_id" : 9, "value" : 10 }{ "_id" : 10, "value" : 13 }...更多详情见请继续阅读下一页的精彩内容： MongoDB 的详细介绍：请点这里MongoDB 的下载地址：请点这里推荐阅读：Java实现MongoDB中自增长字段 CentOS编译安装MongoDB CentOS 编译安装 MongoDB与mongoDB的php扩展 CentOS 6 使用 yum 安装MongoDB及服务器端配置 Ubuntu 13.04下安装MongoDB2.4.3 如何在MongoDB中建立新数据库和集合 MongoDB入门必读(概念与实战并重) 《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF]

是一个开源的框架，可编写和运行分布式应用处理大规模数据，是专为离线和大规模数据分析而设计的，并不适合那种对几个记录随机读写的在线事务处理模式。

　　大数据的时代， 到处张嘴闭嘴都是Hadoop, MapReduce, 不跟上时代怎么行？ 可是对一个hadoop的新手， 写一个属于自己的MapReduce程序还是小有点难度的， 需要建立一个maven项目， 还要搞清楚各种库的依赖， 再加上编译运行， 基本上头大两圈了吧。 这也使得很多只是想简单了解一下MapReduce的人望而却步。　　本文会教你如何用最快最简单的方法编写和运行一个属于自己的MapReduce程序， let"s go!　　首先有两个前提：　　1. 有一个已经可以运行的hadoop 集群（也可以是伪分布系统)， 上面的hdfs和mapreduce工作正常 （这个真的是最基本的了， 不再累述， 不会的请参考 )　　2. 集群上安装了JDK (编译运行时会用到）　　正式开始　　1. 首先登入hadoop 集群里面的一个节点， 创建一个java源文件， 偷懒起见， 基本盗用官方的word count (因为本文的目的是教会你如何快编写和运行一个MapReduce程序， 而不是如何写好一个功能齐全的MapReduce程序）　　内容如下：　　import java.io.IOException;import java.util.StringTokenizer;import org.apache.hadoop.conf.Configuration;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 myword { public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable>{ private final static IntWritable one = new IntWritable(1); private Text word = new Text(); public void map(Object key, Text value, Context context ) throws IOException, InterruptedException { StringTokenizer itr = new StringTokenizer(value.toString()); while (itr.hasMoreTokens()) { word.set(itr.nextToken()); context.write(word, one); } } } public static class IntSumReducer extends Reducer<Text,IntWritable,Text,IntWritable> { 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) { sum += val.get(); } result.set(sum); context.write(key, result); } } public static void main(String[] args) throws Exception { Configuration conf = 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 = new Job(conf, "word count"); job.setJarByClass(myword.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） 为了简单起见，去掉了开头的 package org.apache.hadoop.examples;　　2） 将类名从 WordCount 改为 myword, 以体现是我们自己的工作成果 :)　　2. 拿到hadoop 运行的class path, 主要为编译所用　　运行命令　　hadoop classpath　　保存打出的结果，本文用的hadoop 版本是Pivotal 公司的Pivotal hadoop, 例子：　　/etc/gphd/hadoop/conf:/usr/lib/gphd/hadoop/lib/*:/usr/lib/gphd/hadoop/.//*:/usr/lib/gphd/hadoop-hdfs/./:/usr/lib/gphd/hadoop-hdfs/lib/*:/usr/lib/gphd/hadoop-hdfs/.//*:/usr/lib/gphd/hadoop-yarn/lib/*:/usr/lib/gphd/hadoop-yarn/.//*:/usr/lib/gphd/hadoop-mapreduce/lib/*:/usr/lib/gphd/hadoop-mapreduce/.//*::/etc/gphd/pxf/conf::/usr/lib/gphd/pxf/pxf-core.jar:/usr/lib/gphd/pxf/pxf-api.jar:/usr/lib/gphd/publicstage:/usr/lib/gphd/gfxd/lib/gemfirexd.jar::/usr/lib/gphd/zookeeper/zookeeper.jar:/usr/lib/gphd/hbase/lib/hbase-common.jar:/usr/lib/gphd/hbase/lib/hbase-protocol.jar:/usr/lib/gphd/hbase/lib/hbase-client.jar:/usr/lib/gphd/hbase/lib/hbase-thrift.jar:/usr/lib/gphd/hbase/lib/htrace-core-2.01.jar:/etc/gphd/hbase/conf::/usr/lib/gphd/hive/lib/hive-service.jar:/usr/lib/gphd/hive/lib/libthrift-0.9.0.jar:/usr/lib/gphd/hive/lib/hive-metastore.jar:/usr/lib/gphd/hive/lib/libfb303-0.9.0.jar:/usr/lib/gphd/hive/lib/hive-common.jar:/usr/lib/gphd/hive/lib/hive-exec.jar:/usr/lib/gphd/hive/lib/postgresql-jdbc.jar:/etc/gphd/hive/conf::/usr/lib/gphd/sm-plugins/*:　　3. 编译　　运行命令　　javac -classpath xxx ./myword.java　　xxx部分就是上一步里面取到的class path　　运行完此命令后， 当前目录下会生成一些.class 文件， 例如：　　myword.class myword$IntSumReducer.class myword$TokenizerMapper.class　　4. 将class文件打包成.jar文件　　运行命令　　jar -cvf myword.jar ./*.class　　至此, 目标jar 文件成功生成　　5. 准备一些文本文件， 上传到hdfs, 以做word count的input　　例子：　　随意创建一些文本文件， 保存到mapred_test 文件夹　　运行命令　　hadoop fs -put ./mapred_test/　　确保此文件夹成功上传到hdfs 当前用户根目录下　　6. 运行我们的程序　　运行命令　　hadoop jar ./myword.jar myword mapred_test output　　顺利的话， 此命令会正常进行， 一个MapReduce job 会开始工作， 输出的结果会保存在 hdfs 当前用户根目录下的output 文件夹里面。　　至此大功告成！　　如果还需要更多的功能， 我们可以修改前面的源文件以达到一个真正有用的MapReduce job。　　但是原理大同小异， 练手的话， 基本够了。　　一个抛砖引玉的简单例子， 欢迎板砖。　　转载

你得配置下 在map-reduce 右键eidt 配置下你的HDFS系统信息嘛，

　　一、 首先要知道此前提 转载　　若在windows的Eclipse工程中直接启动mapreduc程序，需要先把hadoop集群的配置目录下的xml都拷贝到src目录下，让程序自动读取集群的地址后去进行分布式运行(您也可以自己写java代码去设置job的configuration属性)。　　若不拷贝，工程中bin目录没有完整的xml配置文件，则windows执行的mapreduce程序全部通过本机的jvm执行，作业名也是带有“local"字眼的作业，如 job_local2062122004_0001。 这不是真正的分布式运行mapreduce程序。　　估计得研究org.apache.hadoop.conf.Configuration的源码，反正xml配置文件会影响执行mapreduce使用的文件系统是本机的windows文件系统还是远程的hdfs系统; 还有影响执行mapreduce的mapper和reducer的是本机的jvm还是集群里面机器的jvm　　二、 本文的结论　　第一点就是： windows上执行mapreduce，必须打jar包到所有slave节点才能正确分布式运行mapreduce程序。（我有个需求是要windows上触发一个mapreduce分布式运行）　　第二点就是： Linux上，只需拷贝jar文件到集群master上,执行命令hadoop jarPackage.jar MainClassName即可分布式运行mapreduce程序。　　第三点就是： 推荐使用附一，实现了自动打jar包并上传，分布式执行的mapreduce程序。　　附一、 推荐使用此方法：实现了自动打jar包并上传，分布式执行的mapreduce程序：　　请先参考博文五篇：　　Hadoop作业提交分析（一）~~（五）　　引用博文的附件中EJob.java到你的工程中，然后main中添加如下方法和代码。　　public static File createPack() throws IOException {　　File jarFile = EJob.createTempJar("bin");　　ClassLoader classLoader = EJob.getClassLoader();　　Thread.currentThread().setContextClassLoader(classLoader);　　return jarFile;　　}　　在作业启动代码中使用打包：　　Job job = Job.getInstance(conf, "testAnaAction");　　添加：　　String jarPath = createPack().getPath();　　job.setJar(jarPath);　　即可实现直接run as java application 在windows跑分布式的mapreduce程序，不用手工上传jar文件。　　附二、得出结论的测试过程　　（未有空看书，只能通过愚笨的测试方法得出结论了）　　一. 直接通过windows上Eclipse右击main程序的java文件，然后"run as application"或选择hadoop插件"run on hadoop"来触发执行MapReduce程序的测试。　　1，如果不打jar包到进集群任意linux机器上，它报错如下：　　[work] 2012-06-25 15:42:47,360 - org.apache.hadoop.mapreduce.Job -10244 [main] INFO org.apache.hadoop.mapreduce.Job - map 0% reduce 0%　　[work] 2012-06-25 15:42:52,223 - org.apache.hadoop.mapreduce.Job -15107 [main] INFO org.apache.hadoop.mapreduce.Job - Task Id : attempt_1403517983686_0056_m_000000_0, Status : FAILED　　Error: java.lang.RuntimeException: java.lang.ClassNotFoundException: Class bookCount.BookCount$BookCountMapper not found　　at org.apache.hadoop.conf.Configuration.getClass(Configuration.java:1720)　　at org.apache.hadoop.mapreduce.task.JobContextImpl.getMapperClass(JobContextImpl.java:186)　　at org.apache.hadoop.mapred.MapTask.runNewMapper(MapTask.java:721)　　at org.apache.hadoop.mapred.MapTask.run(MapTask.java:339)　　at org.apache.hadoop.mapred.YarnChild$2.run(YarnChild.java:162)　　at java.security.AccessController.doPrivileged(Native Method)　　at javax.security.auth.Subject.doAs(Subject.java:415)　　at org.apache.hadoop.security.UserGroupInformation.doAs(UserGroupInformation.java:1491)　　at org.apache.hadoop.mapred.YarnChild.main(YarnChild.java:157)　　Caused by: java.lang.ClassNotFoundException: Class bookCount.BookCount$BookCountMapper not found　　at org.apache.hadoop.conf.Configuration.getClassByName(Configuration.java:1626)　　at org.apache.hadoop.conf.Configuration.getClass(Configuration.java:1718)　　... 8 more　　# Error:后重复三次　　2012-06-25 15:44:53,234 - org.apache.hadoop.mapreduce.Job -37813 [main] INFO org.apache.hadoop.mapreduce.Job - map 100% reduce 100%　　现象就是：报错，无进度，无运行结果。　　　　2，拷贝jar包到“只是”集群master的$HADOOP_HOME/share/hadoop/mapreduce/目录上，直接通过windows的eclipse "run as application"和通过hadoop插件"run on hadoop"来触发执行，它报错同上。　　现象就是：报错，无进度，无运行结果。　　3，拷贝jar包到集群某些slave的$HADOOP_HOME/share/hadoop/mapreduce/目录上，直接通过windows的eclipse "run as application"和通过hadoop插件"run on hadoop"来触发执行　　和报错：　　Error: java.lang.RuntimeException: java.lang.ClassNotFoundException: Class bookCount.BookCount$BookCountMapper not found　　at org.apache.hadoop.conf.Configuration.getClass(Configuration.java:1720)　　at org.apache.hadoop.mapreduce.task.JobContextImpl.getMapperClass(JobContextImpl.java:186)　　和报错：　　Error: java.lang.RuntimeException: java.lang.ClassNotFoundException: Class bookCount.BookCount$BookCountReducer not found　　　　现象就是：有报错，但仍然有进度，有运行结果。　　4，拷贝jar包到集群所有slave的$HADOOP_HOME/share/hadoop/mapreduce/目录上，直接通过windows的eclipse "run as application"和通过hadoop插件"run on hadoop"来触发执行：　　现象就是：无报错，有进度，有运行结果。　　第一点结论就是： windows上执行mapreduce，必须打jar包到所有slave节点才能正确分布式运行mapreduce程序。　　二 在Linux上的通过以下命令触发MapReduce程序的测试。　　hadoop jar $HADOOP_HOME/share/hadoop/mapreduce/bookCount.jar bookCount.BookCount　　　　1，只拷贝到master，在master上执行。　　现象就是：无报错，有进度，有运行结果。　　2，拷贝随便一个slave节点,在slave上执行。　　现象就是：无报错，有进度，有运行结果。　　但某些节点上运行会报错如下，且运行结果。：　　14/06/25 16:44:02 INFO mapreduce.JobSubmitter: Cleaning up the staging area /tmp/hadoop-yarn/staging/hduser/.staging/job_1403517983686_0071　　Exception in thread "main" java.lang.NoSuchFieldError: DEFAULT_MAPREDUCE_APPLICATION_CLASSPATH　　at org.apache.hadoop.mapreduce.v2.util.MRApps.setMRFrameworkClasspath(MRApps.java:157)　　at org.apache.hadoop.mapreduce.v2.util.MRApps.setClasspath(MRApps.java:198)　　at org.apache.hadoop.mapred.YARNRunner.createApplicationSubmissionContext(YARNRunner.java:443)　　at org.apache.hadoop.mapred.YARNRunner.submitJob(YARNRunner.java:283)　　at org.apache.hadoop.mapreduce.JobSubmitter.submitJobInternal(JobSubmitter.java:415)　　at org.apache.hadoop.mapreduce.Job$10.run(Job.java:1268)　　at org.apache.hadoop.mapreduce.Job$10.run(Job.java:1265)　　at java.security.AccessController.doPrivileged(Native Method)　　at javax.security.auth.Subject.doAs(Subject.java:415)　　at org.apache.hadoop.security.UserGroupInformation.doAs(UserGroupInformation.java:1491)　　at org.apache.hadoop.mapreduce.Job.submit(Job.java:1265)　　at org.apache.hadoop.mapreduce.Job.waitForCompletion(Job.java:1286)　　at com.etrans.anaSpeed.AnaActionMr.run(AnaActionMr.java:207)　　at org.apache.hadoop.util.ToolRunner.run(ToolRunner.java:70)　　at com.etrans.anaSpeed.AnaActionMr.main(AnaActionMr.java:44)　　at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)　　at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)　　at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)　　at java.lang.reflect.Method.invoke(Method.java:606)　　at org.apache.hadoop.util.RunJar.main(RunJar.java:212)　　第二点结论就是： Linux上，只需拷贝jar文件到集群master上,执行命令hadoop jarPackage.jar MainClassName即可分布式运行mapreduce程序。

MapReduce极大地方便了编程人员在不会分布式并行编程的情况下，将自己的程序运行在分布式系统上。MapReduce保证结果文件中key的唯一性的方法为：1、打开Hadoop集群，打开主机master的终端，输入【ifconfig】命令查看主机IP地址。2、使用SecureCRT软件连接到Hadoop集群的主机。3、首先进入到hadoop目录下的bin目录下，因为要将代码文件上传到这个目录下，所以先要打开这个目录，然后输入【rz】命令准备上传代码文件。4、选中已经写好的两个代码文件，然后点击【添加】，然后点击【确定】开始文件的上传。5、在软件中观察上传进度，上传成功之后就是下图中的显示。6、运行结果如下图。注意事项：MapReduce借助于函数式程序设计语言Lisp的设计思想，提供了一种简便的并行程序设计方法，用Map和Reduce两个函数编程实现基本的并行计算任务，提供了抽象的操作和并行编程接口，以简单方便地完成大规模数据的编程和计算处理。

大数据的时代， 到处张嘴闭嘴都是Hadoop, MapReduce, 不跟上时代怎么行？ 可是对一个hadoop的新手， 写一个属于自己的MapReduce程序还是小有点难度的， 需要建立一个maven项目， 还要搞清楚各种库的依赖， 再加上编译运行， 基本上头大两圈了吧。 这也使得很多只是想简单了解一下MapReduce的人望而却步。　　本文会教你如何用最快最简单的方法编写和运行一个属于自己的MapReduce程序， let"s go!　　首先有两个前提：　　1. 有一个已经可以运行的hadoop 集群（也可以是伪分布系统)， 上面的hdfs和mapreduce工作正常 （这个真的是最基本的了， 不再累述， 不会的请参考 http://hadoop.apache.org/docs/current/)　　2. 集群上安装了JDK (编译运行时会用到）　　正式开始　　1. 首先登入hadoop 集群里面的一个节点， 创建一个java源文件， 偷懒起见， 基本盗用官方的word count (因为本文的目的是教会你如何快编写和运行一个MapReduce程序， 而不是如何写好一个功能齐全的MapReduce程序）　　内容如下：　　import java.io.IOException;import java.util.StringTokenizer;import org.apache.hadoop.conf.Configuration;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 myword { public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable>{ private final static IntWritable one = new IntWritable(1); private Text word = new Text(); public void map(Object key, Text value, Context context ) throws IOException, InterruptedException { StringTokenizer itr = new StringTokenizer(value.toString()); while (itr.hasMoreTokens()) { word.set(itr.nextToken()); context.write(word, one); } } } public static class IntSumReducer extends Reducer<Text,IntWritable,Text,IntWritable> { 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) { sum += val.get(); } result.set(sum); context.write(key, result); } } public static void main(String[] args) throws Exception { Configuration conf = 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 = new Job(conf, "word count"); job.setJarByClass(myword.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） 为了简单起见，去掉了开头的 package org.apache.hadoop.examples;　　2） 将类名从 WordCount 改为 myword, 以体现是我们自己的工作成果 :)　　2. 拿到hadoop 运行的class path, 主要为编译所用　　运行命令　　hadoop classpath　　保存打出的结果，本文用的hadoop 版本是Pivotal 公司的Pivotal hadoop, 例子：　　/etc/gphd/hadoop/conf:/usr/lib/gphd/hadoop/lib/*:/usr/lib/gphd/hadoop/.//*:/usr/lib/gphd/hadoop-hdfs/./:/usr/lib/gphd/hadoop-hdfs/lib/*:/usr/lib/gphd/hadoop-hdfs/.//*:/usr/lib/gphd/hadoop-yarn/lib/*:/usr/lib/gphd/hadoop-yarn/.//*:/usr/lib/gphd/hadoop-mapreduce/lib/*:/usr/lib/gphd/hadoop-mapreduce/.//*::/etc/gphd/pxf/conf::/usr/lib/gphd/pxf/pxf-core.jar:/usr/lib/gphd/pxf/pxf-api.jar:/usr/lib/gphd/publicstage:/usr/lib/gphd/gfxd/lib/gemfirexd.jar::/usr/lib/gphd/zookeeper/zookeeper.jar:/usr/lib/gphd/hbase/lib/hbase-common.jar:/usr/lib/gphd/hbase/lib/hbase-protocol.jar:/usr/lib/gphd/hbase/lib/hbase-client.jar:/usr/lib/gphd/hbase/lib/hbase-thrift.jar:/usr/lib/gphd/hbase/lib/htrace-core-2.01.jar:/etc/gphd/hbase/conf::/usr/lib/gphd/hive/lib/hive-service.jar:/usr/lib/gphd/hive/lib/libthrift-0.9.0.jar:/usr/lib/gphd/hive/lib/hive-metastore.jar:/usr/lib/gphd/hive/lib/libfb303-0.9.0.jar:/usr/lib/gphd/hive/lib/hive-common.jar:/usr/lib/gphd/hive/lib/hive-exec.jar:/usr/lib/gphd/hive/lib/postgresql-jdbc.jar:/etc/gphd/hive/conf::/usr/lib/gphd/sm-plugins/*:　　3. 编译　　运行命令　　javac -classpath xxx ./myword.java　　xxx部分就是上一步里面取到的class path　　运行完此命令后， 当前目录下会生成一些.class 文件， 例如：　　myword.class myword$IntSumReducer.class myword$TokenizerMapper.class　　4. 将class文件打包成.jar文件　　运行命令　　jar -cvf myword.jar ./*.class　　至此, 目标jar 文件成功生成　　5. 准备一些文本文件， 上传到hdfs, 以做word count的input　　例子：　　随意创建一些文本文件， 保存到mapred_test 文件夹　　运行命令　　hadoop fs -put ./mapred_test/　　确保此文件夹成功上传到hdfs 当前用户根目录下　　6. 运行我们的程序　　运行命令　　hadoop jar ./myword.jar myword mapred_test output　　顺利的话， 此命令会正常进行， 一个MapReduce job 会开始工作， 输出的结果会保存在 hdfs 当前用户根目录下的output 文件夹里面。　　至此大功告成！　　如果还需要更多的功能， 我们可以修改前面的源文件以达到一个真正有用的MapReduce job。　　但是原理大同小异， 练手的话， 基本够了。　　一个抛砖引玉的简单例子， 欢迎板砖。

　　大数据的时代， 到处张嘴闭嘴都是Hadoop, MapReduce, 不跟上时代怎么行？ 可是对一个hadoop的新手， 写一个属于自己的MapReduce程序还是小有点难度的， 需要建立一个maven项目， 还要搞清楚各种库的依赖， 再加上编译运行， 基本上头大两圈了吧。 这也使得很多只是想简单了解一下MapReduce的人望而却步。　　本文会教你如何用最快最简单的方法编写和运行一个属于自己的MapReduce程序， let"s go!　　首先有两个前提：　　1. 有一个已经可以运行的hadoop 集群（也可以是伪分布系统)， 上面的hdfs和mapreduce工作正常 （这个真的是最基本的了， 不再累述， 不会的请参考 http://hadoop.apache.org/docs/current/)　　2. 集群上安装了JDK (编译运行时会用到）　　正式开始　　1. 首先登入hadoop 集群里面的一个节点， 创建一个java源文件， 偷懒起见， 基本盗用官方的word count (因为本文的目的是教会你如何快编写和运行一个MapReduce程序， 而不是如何写好一个功能齐全的MapReduce程序）　　内容如下：　　view sourceprint?　　01.import java.io.IOException;　　02.import java.util.StringTokenizer;　　03.　　04.import org.apache.hadoop.conf.Configuration;　　05.import org.apache.hadoop.fs.Path;　　06.import org.apache.hadoop.io.IntWritable;　　07.import org.apache.hadoop.io.Text;　　08.import org.apache.hadoop.mapreduce.Job;　　09.import org.apache.hadoop.mapreduce.Mapper;　　10.import org.apache.hadoop.mapreduce.Reducer;　　11.import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;　　12.import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;　　13.import org.apache.hadoop.util.GenericOptionsParser;　　14.　　15.public class my<a href="http://www.it165.net/edu/ebg/" target="_blank" class="keylink">word</a> {　　16.　　17.public static class TokenizerMapper　　18.extends Mapper<Object, Text, Text, IntWritable>{　　19.　　20.private final static IntWritable one = new IntWritable(1);　　21.private Text word = new Text();　　22.　　23.public void map(Object key, Text value, Context context　　24.) throws IOException, InterruptedException {　　25.StringTokenizer itr = new StringTokenizer(value.toString());　　26.while (itr.hasMoreTokens()) {　　27.word.set(itr.nextToken());　　28.context.write(word, one);　　29.}　　30.}　　31.}　　32.　　33.public static class IntSumReducer　　34.extends Reducer<Text,IntWritable,Text,IntWritable> {　　35.private IntWritable result = new IntWritable();　　36.　　37.public void reduce(Text key, Iterable<IntWritable> values,　　38.Context context　　39.) throws IOException, InterruptedException {　　40.int sum = 0;　　41.for (IntWritable val : values) {　　42.sum += val.get();　　43.}　　44.result.set(sum);　　45.context.write(key, result);　　46.}　　47.}　　48.　　49.public static void main(String[] args) throws Exception {　　50.Configuration conf = new Configuration();　　51.String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();　　52.if (otherArgs.length != 2) {　　53.System.err.println("Usage: wordcount <in> <out>");　　54.System.exit(2);　　55.}　　56.Job job = new Job(conf, "word count");　　57.job.setJarByClass(myword.class);　　58.job.setMapperClass(TokenizerMapper.class);　　59.job.setCombinerClass(IntSumReducer.class);　　60.job.setReducerClass(IntSumReducer.class);　　61.job.setOutputKeyClass(Text.class);　　62.job.setOutputValueClass(IntWritable.class);　　63.FileInputFormat.addInputPath(job, new Path(otherArgs[0]));　　64.FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));　　65.System.exit(job.waitForCompletion(true) ? 0 : 1);　　66.}　　67.}　　与官方版本相比， 主要做了两处修改　　1） 为了简单起见，去掉了开头的 package org.apache.hadoop.examples;　　2） 将类名从 WordCount 改为 myword, 以体现是我们自己的工作成果 :)　　2. 拿到hadoop 运行的class path, 主要为编译所用　　运行命令　　view sourceprint?　　1.hadoop classpath　　保存打出的结果，本文用的hadoop 版本是Pivotal 公司的Pivotal hadoop, 例子：　　view sourceprint?　　1./etc/gphd/hadoop/conf:/usr/lib/gphd/hadoop/lib/*:/usr/lib/gphd/hadoop/.//*:/usr/lib/gphd/hadoop-hdfs/./:/usr/lib/gphd/hadoop-hdfs/lib/*:/usr/lib/gphd/hadoop-hdfs/.//*:/usr/lib/gphd/hadoop-yarn/lib/*:/usr/lib/gphd/hadoop-yarn/.//*:/usr/lib/gphd/hadoop-mapreduce/lib/*:/usr/lib/gphd/hadoop-mapreduce/.//*::/etc/gphd/pxf/conf::/usr/lib/gphd/pxf/pxf-core.jar:/usr/lib/gphd/pxf/pxf-api.jar:/usr/lib/gphd/publicstage:/usr/lib/gphd/gfxd/lib/gemfirexd.jar::/usr/lib/gphd/zookeeper/zookeeper.jar:/usr/lib/gphd/hbase/lib/hbase-common.jar:/usr/lib/gphd/hbase/lib/hbase-protocol.jar:/usr/lib/gphd/hbase/lib/hbase-client.jar:/usr/lib/gphd/hbase/lib/hbase-thrift.jar:/usr/lib/gphd/hbase/lib/htrace-core-2.01.jar:/etc/gphd/hbase/conf::/usr/lib/gphd/hive/lib/hive-service.jar:/usr/lib/gphd/hive/lib/libthrift-0.9.0.jar:/usr/lib/gphd/hive/lib/hive-metastore.jar:/usr/lib/gphd/hive/lib/libfb303-0.9.0.jar:/usr/lib/gphd/hive/lib/hive-common.jar:/usr/lib/gphd/hive/lib/hive-exec.jar:/usr/lib/gphd/hive/lib/postgresql-jdbc.jar:/etc/gphd/hive/conf::/usr/lib/gphd/sm-plugins/*:　　3. 编译　　运行命令　　view sourceprint?　　1.javac -classpath xxx ./myword.java　　xxx部分就是上一步里面取到的class path　　运行完此命令后， 当前目录下会生成一些.class 文件， 例如：　　myword.class myword$IntSumReducer.class myword$TokenizerMapper.class　　4. 将class文件打包成.jar文件　　运行命令　　view sourceprint?　　1.jar -cvf myword.jar ./*.class　　至此, 目标jar 文件成功生成　　5. 准备一些文本文件， 上传到hdfs, 以做word count的input　　例子：　　随意创建一些文本文件， 保存到mapred_test 文件夹　　运行命令　　view sourceprint?　　1.hadoop fs -put ./mapred_test/　　确保此文件夹成功上传到hdfs 当前用户根目录下　　6. 运行我们的程序　　运行命令　　view sourceprint?　　1.hadoop jar ./myword.jar myword mapred_test output　　顺利的话， 此命令会正常进行， 一个MapReduce job 会开始工作， 输出的结果会保存在 hdfs 当前用户根目录下的output 文件夹里面。　　至此大功告成！　　如果还需要更多的功能， 我们可以修改前面的源文件以达到一个真正有用的MapReduce job。　　但是原理大同小异， 练手的话， 基本够了。　　一个抛砖引玉的简单例子， 欢迎板砖。

什么是Map/Reduce，看下面的各种解释：　　(1)MapReduce是hadoop的核心组件之一，hadoop要分布式包括两部分，一是分布式文件系统hdfs,一部是分布式计算框，就是mapreduce,缺一不可，也就是说，可以通过mapreduce很容易在hadoop平台上进行分布式的计算编程。　　(2)Mapreduce是一种编程模型，是一种编程方法，抽象理论。　　(3)下面是一个关于一个程序员是如何个妻子讲解什么是MapReduce？文章很长请耐心的看。　　我问妻子：“你真的想要弄懂什么是MapReduce？” 她很坚定的回答说“是的”。 因此我问道：　　我： 你是如何准备洋葱辣椒酱的？（以下并非准确食谱，请勿在家尝试）　　妻子： 我会取一个洋葱，把它切碎，然后拌入盐和水，最后放进混合研磨机里研磨。这样就能得到洋葱辣椒酱了。　　妻子： 但这和MapReduce有什么关系？　　我： 你等一下。让我来编一个完整的情节，这样你肯定可以在15分钟内弄懂MapReduce.　　妻子： 好吧。　　我：现在，假设你想用薄荷、洋葱、番茄、辣椒、大蒜弄一瓶混合辣椒酱。你会怎么做呢？　　妻子： 我会取薄荷叶一撮，洋葱一个，番茄一个，辣椒一根，大蒜一根，切碎后加入适量的盐和水，再放入混合研磨机里研磨，这样你就可以得到一瓶混合辣椒酱了。　　我： 没错，让我们把MapReduce的概念应用到食谱上。Map和Reduce其实是两种操作，我来给你详细讲解下。　　Map（映射）: 把洋葱、番茄、辣椒和大蒜切碎，是各自作用在这些物体上的一个Map操作。所以你给Map一个洋葱，Map就会把洋葱切碎。 同样的，你把辣椒，大蒜和番茄一一地拿给Map，你也会得到各种碎块。 所以，当你在切像洋葱这样的蔬菜时，你执行就是一个Map操作。 Map操作适用于每一种蔬菜，它会相应地生产出一种或多种碎块，在我们的例子中生产的是蔬菜块。在Map操作中可能会出现有个洋葱坏掉了的情况，你只要把坏洋葱丢了就行了。所以，如果出现坏洋葱了，Map操作就会过滤掉坏洋葱而不会生产出任何的坏洋葱块。　　Reduce（化简）:在这一阶段，你将各种蔬菜碎都放入研磨机里进行研磨，你就可以得到一瓶辣椒酱了。这意味要制成一瓶辣椒酱，你得研磨所有的原料。因此，研磨机通常将map操作的蔬菜碎聚集在了一起。　　妻子： 所以，这就是MapReduce?　　我： 你可以说是，也可以说不是。 其实这只是MapReduce的一部分，MapReduce的强大在于分布式计算。　　妻子： 分布式计算？ 那是什么？请给我解释下吧。　　我： 没问题。　　我： 假设你参加了一个辣椒酱比赛并且你的食谱赢得了最佳辣椒酱奖。得奖之后，辣椒酱食谱大受欢迎，于是你想要开始出售自制品牌的辣椒酱。假设你每天需要生产10000瓶辣椒酱，你会怎么办呢？　　妻子： 我会找一个能为我大量提供原料的供应商。　　我：是的..就是那样的。那你能否独自完成制作呢？也就是说，独自将原料都切碎？ 仅仅一部研磨机又是否能满足需要？而且现在，我们还需要供应不同种类的辣椒酱，像洋葱辣椒酱、青椒辣椒酱、番茄辣椒酱等等。　　妻子： 当然不能了，我会雇佣更多的工人来切蔬菜。我还需要更多的研磨机，这样我就可以更快地生产辣椒酱了。　　我：没错，所以现在你就不得不分配工作了，你将需要几个人一起切蔬菜。每个人都要处理满满一袋的蔬菜，而每一个人都相当于在执行一个简单的Map操作。每一个人都将不断的从袋子里拿出蔬菜来，并且每次只对一种蔬菜进行处理，也就是将它们切碎，直到袋子空了为止。　　这样，当所有的工人都切完以后，工作台（每个人工作的地方）上就有了洋葱块、番茄块、和蒜蓉等等。　　妻子：但是我怎么会制造出不同种类的番茄酱呢？　　我：现在你会看到MapReduce遗漏的阶段—搅拌阶段。MapReduce将所有输出的蔬菜碎都搅拌在了一起，这些蔬菜碎都是在以key为基础的 map操作下产生的。搅拌将自动完成，你可以假设key是一种原料的名字，就像洋葱一样。 所以全部的洋葱keys都会搅拌在一起，并转移到研磨洋葱的研磨器里。这样，你就能得到洋葱辣椒酱了。同样地，所有的番茄也会被转移到标记着番茄的研磨器里，并制造出番茄辣椒酱。　　（4）上面都是从理论上来说明什么是MapReduce，那么咱们在MapReduce产生的过程和代码的角度来理解这个问题。　　如果想统计下过去10年计算机论文出现最多的几个单词，看看大家都在研究些什么，那收集好论文后，该怎么办呢？　　方法一：　　我可以写一个小程序，把所有论文按顺序遍历一遍，统计每一个遇到的单词的出现次数，最后就可以知道哪几个单词最热门了。 这种方法在数据集比较小时，是非常有效的，而且实现最简单，用来解决这个问题很合适。　　方法二：　　写一个多线程程序，并发遍历论文。　　这个问题理论上是可以高度并发的，因为统计一个文件时不会影响统计另一个文件。当我们的机器是多核或者多处理器，方法二肯定比方法一高效。但是写一个多线程程序要比方法一困难多了，我们必须自己同步共享数据，比如要防止两个线程重复统计文件。　　方法三：　　把作业交给多个计算机去完成。　　我们可以使用方法一的程序，部署到N台机器上去，然后把论文集分成N份，一台机器跑一个作业。这个方法跑得足够快，但是部署起来很麻烦，我们要人工把程序copy到别的机器，要人工把论文集分开，最痛苦的是还要把N个运行结果进行整合（当然我们也可以再写一个程序）。　　方法四：　　让MapReduce来帮帮我们吧！　　MapReduce本质上就是方法三，但是如何拆分文件集，如何copy程序，如何整合结果这些都是框架定义好的。我们只要定义好这个任务（用户程序），其它都交给MapReduce。　　map函数和reduce函数　　map函数和reduce函数是交给用户实现的，这两个函数定义了任务本身。　　map函数：接受一个键值对（key-value pair），产生一组中间键值对。MapReduce框架会将map函数产生的中间键值对里键相同的值传递给一个reduce函数。　　reduce函数：接受一个键，以及相关的一组值，将这组值进行合并产生一组规模更小的值（通常只有一个或零个值）。　　统计词频的MapReduce函数的核心代码非常简短，主要就是实现这两个函数。　　map(String key, String value):　　// key: document name　　// value: document contents　　for each word w in value:　　EmitIntermediate(w, "1");　　reduce(String key, Iterator values):　　// key: a word　　// values: a list of counts　　int result = 0;　　for each v in values:　　result += ParseInt(v);　　Emit(AsString(result));　　在统计词频的例子里，map函数接受的键是文件名，值是文件的内容，map逐个遍历单词，每遇到一个单词w，就产生一个中间键值对<w, "1">，这表示单词w咱又找到了一个；MapReduce将键相同（都是单词w）的键值对传给reduce函数，这样reduce函数接受的键就是单词w，值是一串"1"（最基本的实现是这样，但可以优化），个数等于键为w的键值对的个数，然后将这些“1”累加就得到单词w的出现次数。最后这些单词的出现次数会被写到用户定义的位置，存储在底层的分布式存储系统（GFS或HDFS）。转载

什么是Map/Reduce，看下面的各种解释：　　(1)MapReduce是hadoop的核心组件之一，hadoop要分布式包括两部分，一是分布式文件系统hdfs,一部是分布式计算框，就是mapreduce,缺一不可，也就是说，可以通过mapreduce很容易在hadoop平台上进行分布式的计算编程。　　(2)Mapreduce是一种编程模型，是一种编程方法，抽象理论。　　(3)下面是一个关于一个程序员是如何个妻子讲解什么是MapReduce？文章很长请耐心的看。　　我问妻子：“你真的想要弄懂什么是MapReduce？” 她很坚定的回答说“是的”。 因此我问道：　　我： 你是如何准备洋葱辣椒酱的？（以下并非准确食谱，请勿在家尝试）　　妻子： 我会取一个洋葱，把它切碎，然后拌入盐和水，最后放进混合研磨机里研磨。这样就能得到洋葱辣椒酱了。　　妻子： 但这和MapReduce有什么关系？　　我： 你等一下。让我来编一个完整的情节，这样你肯定可以在15分钟内弄懂MapReduce.　　妻子： 好吧。　　我：现在，假设你想用薄荷、洋葱、番茄、辣椒、大蒜弄一瓶混合辣椒酱。你会怎么做呢？　　妻子： 我会取薄荷叶一撮，洋葱一个，番茄一个，辣椒一根，大蒜一根，切碎后加入适量的盐和水，再放入混合研磨机里研磨，这样你就可以得到一瓶混合辣椒酱了。　　我： 没错，让我们把MapReduce的概念应用到食谱上。Map和Reduce其实是两种操作，我来给你详细讲解下。　　Map（映射）: 把洋葱、番茄、辣椒和大蒜切碎，是各自作用在这些物体上的一个Map操作。所以你给Map一个洋葱，Map就会把洋葱切碎。 同样的，你把辣椒，大蒜和番茄一一地拿给Map，你也会得到各种碎块。 所以，当你在切像洋葱这样的蔬菜时，你执行就是一个Map操作。 Map操作适用于每一种蔬菜，它会相应地生产出一种或多种碎块，在我们的例子中生产的是蔬菜块。在Map操作中可能会出现有个洋葱坏掉了的情况，你只要把坏洋葱丢了就行了。所以，如果出现坏洋葱了，Map操作就会过滤掉坏洋葱而不会生产出任何的坏洋葱块。　　Reduce（化简）:在这一阶段，你将各种蔬菜碎都放入研磨机里进行研磨，你就可以得到一瓶辣椒酱了。这意味要制成一瓶辣椒酱，你得研磨所有的原料。因此，研磨机通常将map操作的蔬菜碎聚集在了一起。　　妻子： 所以，这就是MapReduce?　　我： 你可以说是，也可以说不是。 其实这只是MapReduce的一部分，MapReduce的强大在于分布式计算。　　妻子： 分布式计算？ 那是什么？请给我解释下吧。　　我： 没问题。　　我： 假设你参加了一个辣椒酱比赛并且你的食谱赢得了最佳辣椒酱奖。得奖之后，辣椒酱食谱大受欢迎，于是你想要开始出售自制品牌的辣椒酱。假设你每天需要生产10000瓶辣椒酱，你会怎么办呢？　　妻子： 我会找一个能为我大量提供原料的供应商。　　我：是的..就是那样的。那你能否独自完成制作呢？也就是说，独自将原料都切碎？ 仅仅一部研磨机又是否能满足需要？而且现在，我们还需要供应不同种类的辣椒酱，像洋葱辣椒酱、青椒辣椒酱、番茄辣椒酱等等。　　妻子： 当然不能了，我会雇佣更多的工人来切蔬菜。我还需要更多的研磨机，这样我就可以更快地生产辣椒酱了。　　我：没错，所以现在你就不得不分配工作了，你将需要几个人一起切蔬菜。每个人都要处理满满一袋的蔬菜，而每一个人都相当于在执行一个简单的Map操作。每一个人都将不断的从袋子里拿出蔬菜来，并且每次只对一种蔬菜进行处理，也就是将它们切碎，直到袋子空了为止。　　这样，当所有的工人都切完以后，工作台（每个人工作的地方）上就有了洋葱块、番茄块、和蒜蓉等等。　　妻子：但是我怎么会制造出不同种类的番茄酱呢？　　我：现在你会看到MapReduce遗漏的阶段—搅拌阶段。MapReduce将所有输出的蔬菜碎都搅拌在了一起，这些蔬菜碎都是在以key为基础的 map操作下产生的。搅拌将自动完成，你可以假设key是一种原料的名字，就像洋葱一样。 所以全部的洋葱keys都会搅拌在一起，并转移到研磨洋葱的研磨器里。这样，你就能得到洋葱辣椒酱了。同样地，所有的番茄也会被转移到标记着番茄的研磨器里，并制造出番茄辣椒酱。　　（4）上面都是从理论上来说明什么是MapReduce，那么咱们在MapReduce产生的过程和代码的角度来理解这个问题。　　如果想统计下过去10年计算机论文出现最多的几个单词，看看大家都在研究些什么，那收集好论文后，该怎么办呢？　　方法一：　　我可以写一个小程序，把所有论文按顺序遍历一遍，统计每一个遇到的单词的出现次数，最后就可以知道哪几个单词最热门了。 这种方法在数据集比较小时，是非常有效的，而且实现最简单，用来解决这个问题很合适。　　方法二：　　写一个多线程程序，并发遍历论文。　　这个问题理论上是可以高度并发的，因为统计一个文件时不会影响统计另一个文件。当我们的机器是多核或者多处理器，方法二肯定比方法一高效。但是写一个多线程程序要比方法一困难多了，我们必须自己同步共享数据，比如要防止两个线程重复统计文件。　　方法三：　　把作业交给多个计算机去完成。　　我们可以使用方法一的程序，部署到N台机器上去，然后把论文集分成N份，一台机器跑一个作业。这个方法跑得足够快，但是部署起来很麻烦，我们要人工把程序copy到别的机器，要人工把论文集分开，最痛苦的是还要把N个运行结果进行整合（当然我们也可以再写一个程序）。

分类: 教育/科学 >> 外语学习 问题描述: 尤其是两逗号中间的半句是什么意思 解析: 这句话可以改写成： The ship, which was reduced to a shapeless wreck, was hardly recognizable. 中间的reduced to a shapeless wreck是动词的－ed形式作后置定语，对前面的the ship进行补充说明。be reduced to something: 被毁坏、破坏成了..... 全句：轮船被毁成了一堆乱七八糟的残骸而几乎难以辨认了。 或 船儿被毁得面目全非而无法辨认了。

简单点来说，就是Hadoop是继承了Google的MapReduce、GFS思想，开发出来的一套框架，后来又交给了Apache作为开源项目。MapReduce诞生于谷歌实验室，MapReduce与GFS、BigTable并称为谷歌的三驾马车，、而Hadoop则是谷歌三驾马车的开源实现。2003年，Google发表了一篇技术学术论文谷歌文件系统（GFS）。GFS是google公司为了存储海量搜索数据而设计的专用文件系统。2004年，Nutch创始人Doug Cutting基于Google的GFS论文实现了分布式文件存储系统名为NDFS。2004年，Google又发表了一篇技术学术论文MapReduce。MapReduce是一种编程模型，用于大规模数据集（大于1TB）的并行分析运算。2005年，Doug Cutting又基于MapReduce，在Nutch搜索引擎实现了该功能。2006年，Yahoo雇用了Doug Cutting，Doug Cutting将NDFS和MapReduce升级命名为Hadoop，Yahoo开建了一个独立的团队给Goug Cutting专门研究发展Hadoop。

　　1. 概述　　1970年，IBM的研究员E.F.Codd博士在刊物《Communication of the ACM》上发表了一篇名为“A Relational Model of Data for Large Shared Data Banks”的论文，提出了关系模型的概念，标志着关系数据库的诞生，随后几十年，关系数据库及其结构化查询语言SQL成为程序员必须掌握的基本技能之一。　　2005年4月，Jeffrey Dean和Sanjay Ghemawat在国际会议OSDI上发表“MapReduce: Simplified Data Processing on Large Cluster”，标志着google的大规模数据处理系统MapReduce公开。受这篇论文的启发，当年秋天，Hadoop 由 Apache Software Foundation 公司作为 Lucene 的子项目 Nutch 的一部分正式被引入，2006 年 3 月份，MapReduce 和 Nutch Distributed File System (NDFS) 分别被纳入称为 Hadoop 的项目中。如今，Hadoop已经被超过50%的互联网公司使用，其他很多公司正准备使用Hadoop来处理海量数据，随着Hadoop越来越受欢迎，也许在将来的某段时间，Hadoop会成为程序员必须掌握的技能之一，如果真是这样的话，学会如何在Hadoop上编写MapReduce程序便是学习Hadoop的开始。　　本文介绍了在Hadoop上编写MapReduce程序的基本方法，包括MapReduce程序的构成，不同语言开发MapReduce的方法等。　　2. Hadoop 作业构成　　2.1 Hadoop作业执行流程　　用户配置并将一个Hadoop作业提到Hadoop框架中，Hadoop框架会把这个作业分解成一系列map tasks 和reduce tasks。Hadoop框架负责task分发和执行，结果收集和作业进度监控。　　下图给出了一个作业从开始执行到结束所经历的阶段和每个阶段被谁控制（用户 or Hadoop框架）。　　下图详细给出了用户编写MapRedue作业时需要进行那些工作以及Hadoop框架自动完成的工作：　　在编写MapReduce程序时，用户分别通过InputFormat和OutputFormat指定输入和输出格式，并定义Mapper和Reducer指定map阶段和reduce阶段的要做的工作。在Mapper或者Reducer中，用户只需指定一对key/value的处理逻辑，Hadoop框架会自动顺序迭代解析所有key/value，并将每对key/value交给Mapper或者Reducer处理。表面上看来，Hadoop限定数据格式必须为key/value形式，过于简单，很难解决复杂问题，实际上，可以通过组合的方法使key或者value（比如在key或者value中保存多个字段，每个字段用分隔符分开，或者value是个序列化后的对象，在Mapper中使用时，将其反序列化等）保存多重信息，以解决输入格式较复杂的应用。　　2.2 用户的工作　　用户编写MapReduce需要实现的类或者方法有：　　（1） InputFormat接口　　用户需要实现该接口以指定输入文件的内容格式。该接口有两个方法　　1　　2　　3　　4　　5　　6　　7　　8　　9　　10　　11　　　　public interface InputFormat<K, V> {　　　　InputSplit[] getSplits(JobConf job, int numSplits) throws IOException;　　　　RecordReader<K, V> getRecordReader(InputSplit split,　　　　JobConf job,　　　　Reporter reporter) throws IOException;　　　　}　　　　其中getSplits函数将所有输入数据分成numSplits个split，每个split交给一个map task处理。getRecordReader函数提供一个用户解析split的迭代器对象，它将split中的每个record解析成key/value对。　　Hadoop本身提供了一些InputFormat：　　（2）Mapper接口　　用户需继承Mapper接口实现自己的Mapper，Mapper中必须实现的函数是　　1　　2　　3　　4　　5　　6　　7　　8　　9　　　　void map(K1 key,　　　　V1 value,　　　　OutputCollector<K2,V2> output,　　　　Reporter reporter　　　　) throws IOException　　　　其中，<K1 V1>是通过Inputformat中的RecordReader对象解析处理 的，OutputCollector获取map()的输出结果，Reporter保存了当前task处理进度。　　Hadoop本身提供了一些Mapper供用户使用：　　（3）Partitioner接口　　用户需继承该接口实现自己的Partitioner以指定map task产生的key/value对交给哪个reduce task处理，好的Partitioner能让每个reduce task处理的数据相近，从而达到负载均衡。Partitioner中需实现的函数是　　getPartition( K2 key, V2 value, int numPartitions)　　该函数返回<K2 V2>对应的reduce task ID。　　用户如果不提供Partitioner，Hadoop会使用默认的（实际上是个hash函数）。　　（4）Combiner　　Combiner使得map task与reduce task之间的数据传输量大大减小，可明显提高性能。大多数情况下，Combiner与Reducer相同。　　（5）Reducer接口　　用户需继承Reducer接口实现自己的Reducer，Reducer中必须实现的函数是　　1　　2　　3　　4　　5　　6　　7　　8　　9　　　　void reduce(K2 key,　　　　Iterator<V2> values,　　　　OutputCollector<K3,V3> output,　　　　Reporter reporter　　　　) throws IOException　　　　Hadoop本身提供了一些Reducer供用户使用：　　（6）OutputFormat　　用户通过OutputFormat指定输出文件的内容格式，不过它没有split。每个reduce task将其数据写入自己的文件，文件名为part-nnnnn，其中nnnnn为reduce task的ID。　　Hadoop本身提供了几个OutputFormat:　　3. 分布式缓存　　Haoop中自带了一个分布式缓存，即DistributedCache对象，方便map task之间或者reduce task之间共享一些信息，比如某些实际应用中，所有map task要读取同一个配置文件或者字典，则可将该配置文件或者字典放到分布式缓存中。　　4. 多语言编写MapReduce作业　　Hadoop采用java编写，因而Hadoop天生支持java语言编写作业，但在实际应用中，有时候，因要用到非java的第三方库或者其他原因，要采用C/C++或者其他语言编写MapReduce作业，这时候可能要用到Hadoop提供的一些工具。　　如果你要用C/C++编写MpaReduce作业，可使用的工具有Hadoop Streaming或者Hadoop Pipes。　　如果你要用Python编写MapReduce作业，可以使用Hadoop Streaming或者Pydoop。　　如果你要使用其他语言，如shell，php，ruby等，可使用Hadoop Streaming。　　关于Hadoop Streaming编程，可参见我的这篇博文：《Hadoop Streaming编程》（http://dongxicheng.org/mapreduce/hadoop-streaming-programming/ ）　　关于Pydoop编程，可参见其官方网站：http://sourceforge.net/projects/pydoop/　　关于Hadoop pipes编程，可参见《Hadoop Tutorial 2.2 — Running C++ Programs on Hadoop》。　　5. 编程方式比较　　（1）java。 Hadoop支持的最好最全面的语言，而且提供了很多工具方便程序员开发。　　（2）Hadoop Streaming。 它最大的优点是支持多种语言，但效率较低，reduce task需等到map 阶段完成后才能启动；它不支持用户自定义InputFormat，如果用户想指定输入文件格式，可使用java语言编写或者在命令行中指定分隔符；它采用标准输入输出让C/C++与java通信，因而只支持text数据格式。　　（3）Hadoop Pipes。 专门为C/C++语言设计，由于其采用了socket方式让C/C++与java通信，因而其效率较低（其优势在于，但作业需要大量，速度很快）。它支持用户（用C/C++）编写RecordReader。　　（4）Pydoop。它是专门方便python程序员编写MapReduce作业设计的，其底层使用了Hadoop Streaming接口和libhdfs库。　　6. 总结　　Hadoop使得分布式程序的编写变得异常简单，很多情况下，用户只需写map()和reduce()两个函数即可（InputFormat，Outputformat可用系统缺省的）。正是由于Hadoop编程的简单性，越来越多的公司或者研究单位开始使用Hadoop。

在安装Hadoop集群的时候，我们在yarn-site.xml文件中配置了MapReduce的运行方式为yarn.nodemanager.aux-services=mapreduce_shuffle。本节就来详细介绍一下MapReduce的shuffle过程。 shuffle，即混洗、洗牌的意思，是指MapReduce程序在执行过程中，数据在各个Mapper（Combiner、Sorter、Partitioner）、Reducer等进程之间互相交换的过程。 关于上图Shuffle过程的几点说明： 说明：map节点执行map task任务生成map的输出结果。 shuffle的工作内容： 从运算效率的出发点，map输出结果优先存储在map节点的内存中。每个map task都有一个内存缓冲区，存储着map的输出结果，当达到内存缓冲区的阀值（80%）时，需要将缓冲区中的数据以一个临时文件的方式存到磁盘，当整个map task结束后再对磁盘中这个map task所产生的所有临时文件做合并，生成最终的输出文件。最后，等待reduce task来拉取数据。当然，如果map task的结果不大，能够完全存储到内存缓冲区，且未达到内存缓冲区的阀值，那么就不会有写临时文件到磁盘的操作，也不会有后面的合并。 详细过程如下： （1）map task任务执行，输入数据的来源是：HDFS的block。当然在mapreduce概念中，map task读取的是split分片。split与block的对应关系：一对一（默认）。 此处有必要说明一下block与split： block（物理划分）：文件上传到HDFS，就要划分数据成块，这里的划分属于物理的划分，块的大小可配置（默认：第一代为64M，第二代为128M）可通过 dfs.block.size配置。为保证数据的安　全，block采用冗余机制：默认为3份，可通过dfs.replication配置。注意：当更改块大小的配置后，新上传的文件的块大小为新配置的值，以前上传的文件的块大小为以前的配置值。 split（逻辑划分）：Hadoop中split划分属于逻辑上的划分，目的只是为了让map task更好地获取数据。split是通过hadoop中的InputFormat接口中的getSplit()方法得到的。那么，split的大小具体怎么得到呢？ 首先介绍几个数据量： totalSize：整个mapreduce job所有输入的总大小。注意：基本单位是block个数，而不是Bytes个数。 numSplits：来自job.getNumMapTasks()，即在job启动时用户利用 org.apache.hadoop.mapred.JobConf.setNumMapTasks(int n)设置的值，从方法的名称上看，是用于设置map的个数。但是，最终map的个数也就是split的个数并不一定取用户设置的这个值，用户设置的map个数值只是给最终的map个数一个提示，只是一个影响因素，而不是决定因素。 goalSize：totalSize/numSplits，即期望的split的大小，也就是每个mapper处理多少的数据。但是仅仅是期望 minSize：split的最小值，该值可由两个途径设置： 最终取goalSize和minSize中的最大值！ 最终：split大小的计算原则：finalSplitSize=max(minSize,min(goalSize,blockSize)) 那么，map的个数=totalSize/finalSplitSize 注意： 新版的API中InputSplit划分算法不再考虑用户设定的Map Task个数，而是用mapred.max.split.size(记为maxSize)代替 即：InputSplit大小的计算公式为：splitSize=max{minSize,min{maxSize,blockSize}} 接下来就简答说说怎么根据业务需求，调整map的个数。 当我们用hadoop处理大批量的大数据时，一种最常见的情况就是job启动的mapper数量太多而超出系统限制，导致hadoop抛出异常终止执行。 解决方案：减少mapper的数量！具体如下： a.输入文件数量巨大，但不是小文件 这种情况可通过增大每个mapper的inputsize，即增大minSize或者增大blockSize来减少所需的mapper的数量。增大blocksize通常不可行，因为HDFS被hadoop namenode -format之后，blocksize就已经确定了(由格式化时dfs.block.size决定)，如果要更改blocksize，需要重新格式化HDFS，这样当然会丢失已有的数据。所以通常情况下只能增大minSize，即增大mapred.min.split.size的值。 b.输入文件数量巨大，且都是小文件 所谓小文件，就是单个文件的size小于blockSize。这种情况通过增大mapred.min.split.size不可行，需要使用FileInputFormat衍生的CombineFileInputFormat将多个input path合并成一个InputSplit送给mapper处理，从而减少mapper的数量。增加mapper的数量，可以通过减少每个mapper的输入做到，即减小blockSize或者减少mapred.min.split.size的值。 （2）map执行后，得到key/value键值对。接下来的问题就是，这些键值对应该交给哪个reduce做？注意：reduce的个数是允许用户在提交job时，通过设置方法设置的！ MapReduce提供partitioner接口解决上述问题。默认操作是：对key hash后再以reduce task数量取模，返回值决定着该键值对应该由哪个reduce处理。这种默认的取模方式只是为了平均reduce的处理能力，防止数据倾斜，保证负载均衡。如果用户自己对Partition有需求，可以自行定制并设置到job上。 接下来，需要将key/value以及Partition结果都写入到缓冲区，缓冲区的作用：批量收集map结果，减少磁盘IO的影响。当然，写入之前，这些数据都会被序列化成字节数组。而整个内存缓冲区就是一个字节数组。这个内存缓冲区是有大小限制的，默认100MB。当map task的输出结果很多时，就可能撑爆内存。需将缓冲区的数据临时写入磁盘，然后重新利用这块缓冲区。 从内存往磁盘写数据被称为Spill(溢写)，由单独线程完成，不影响往缓冲区写map结果的线程。溢写比例：spill.percent(默认0.8)。 当缓冲区的数据达到阀值，溢写线程启动，锁定这80MB的内存，执行溢写过程。剩下的20MB继续写入map task的输出结果。互不干涉！ 当溢写线程启动后，需要对这80MB空间内的key做排序(Sort)。排序是mapreduce模型的默认行为，也是对序列化的字节做的排序。排序规则：字典排序！ map task的输出结果写入内存后，当溢写线程未启动时，对输出结果并没有做任何的合并。从官方图可以看出，合并是体现在溢写的临时磁盘文件上的，且这种合并是对不同的reduce端的数值做的合并。所以溢写过程一个很重要的细节在于，如果有很多个key/value对需要发送到某个reduce端，那么需要将这些键值对拼接到一块，减少与partition相关的索引记录。如果client设置Combiner，其会将有相同key的key/value对的value加起来，减少溢写到磁盘的数据量。注意：这里的合并并不能保证map结果中所有的相同的key值的键值对的value都合并了，它合并的范围只是这80MB，它能保证的是在每个单独的溢写文件中所有键值对的key值均不相同！ 溢写生成的临时文件的个数随着map输出结果的数据量变大而增多，当整个map task完成，内存中的数据也全部溢写到磁盘的一个溢写文件。也就是说，不论任何情况下，溢写过程生成的溢写文件至少有一个！但是最终的文件只能有一个，需要将这些溢写文件归并到一起，称为merge。merge是将所有的溢写文件归并到一个文件，结合上面所描述的combiner的作用范围，归并得到的文件内键值对有可能拥有相同的key，这个过程如果client设置过Combiner，也会合并相同的key值的键值对，如果没有，merge得到的就是键值集合，如{“aaa”, [5, 8, 2, …]}。注意：combiner的合理设置可以提高效率，但是如果使用不当会影响效率！ 至此，map端的所有工作都已经结束！ 当mapreduce任务提交后，reduce task就不断通过RPC从JobTracker那里获取map task是否完成的信息，如果获知某台TaskTracker上的map task执行完成，Shuffle的后半段过程就开始启动。其实呢，reduce task在执行之前的工作就是：不断地拉取当前job里每个map task的最终结果，并对不同地方拉取过来的数据不断地做merge，也最终形成一个文件作为reduce task的输入文件。 1.Copy过程，简单地拉取数据。Reduce进程启动一些数据copy线程（Fether），通过HTTP方式请求map task所在的TaskTracker获取map task的输出文件。因为map task早已结束，这些文件就归TaskTracker管理在本地磁盘。 2.Merge过程。这里的merge如map端的merge动作，只是数组中存放的是不同map端copy过来的数值。Copy过来的数据会先放入内存缓冲区中，这里缓冲区的大小要比map端的更为灵活，它是基于JVM的heap size设置，因为shuffler阶段reducer不运行，所以应该把绝大部分的内存都给shuffle用。 merge的三种形式：内存到内存、内存到磁盘、磁盘到磁盘。默认情况下，第一种形式不启用。当内存中的数据量达到一定的阀值，就启动内存到磁盘的merge。与map端类似，这也是溢写过程，当然如果这里设置了Combiner，也是会启动的，然后在磁盘中生成了众多的溢写文件。第二种merge方式一直在运行，直到没有map端的数据时才结束，然后启动第三种磁盘到磁盘的merge方式生成最终的那个文件。 3.reducer的输入文件。不断地merge后，最后会生成一个“最终文件”。这个最终文件可能在磁盘中也可能在内存中。当然我们希望它在内存中，直接作为reducer的输入，但默认情况下，这个文件是存放于磁盘中的。当reducer的输入文件已定，整个shuffle才最终结束。然后就是reducer执行，把结果存放到HDFS上。

不妨用Drop,愚见。

通过一个综合数据分析案例：”金庸的江湖——金庸武侠小说中的人物关系挖掘“，来学习和掌握MapReduce程序设计。通过本项目的学习，可以体会如何使用MapReduce完成一个综合性的数据挖掘任务，包括全流程的数据预处理、数据分析、数据后处理等。 1 任务1 数据预处理 1.1 任务描述 从原始的金庸小说文本中，抽取出与人物互动相关的数据，而屏蔽掉与人物关系无关的文本内容，为后面的基于人物共现的分析做准备。 1.2 关键问题 1.2.1 中文分词和人名提取 使用开源的Ansj_seg进行分词。Ansj_seg不仅支持中文分词，还允许用户自定义词典，在分词前，将人名列表到添加用户自定义的词典，可以精确识别金庸武侠小说中的人名。 但实际测试的时候发现，Ansj_seg分词会出现严重的歧义问题，比如“汉子”属于人名列表中的人名(nr)，但Ansj_seg可能会错误地将它分类为名词(n)。因此，如果根据词性提取人名，会导致最后提取的人名太少。解决方法是在提取人名的时候，需要在将人名加入用户自定义词典的同时，构造一个包含所有人名的字典，对分词的结果逐个进行测试，如果在字典里，就是人名。 1.2.2 文件传输 使用HDFS传递数据。考虑到人名列表文件已经存放在了HDFS里，所以使用HDFS的方式不需要移动人名列表文件，只需要在Configuration中设置文件在HDFS文件系统中的路径，然后在Mapper的setup()函数里调用HDFS的函数获取文件内容即可。 1.2.3 单词同现算法 两个单词近邻关系的定义：实验要求中已经说明，同现关系为一个段落。 段落划分：非常庆幸的是，小说原文中一个段落就是一行，因此，不需要自己定义FileInputFormat和RecordReader。 1.3 MapReduce设计 1.3.1 Mapper 1.3.2 Reducer 1.3.3 Driver 2 任务2 特征抽取：人物同现统计 2.1 任务描述 完成基于单词同现算法的人物同现统计。在人物同现分析中，如果两个人在原文的同一段落中出现，则认为两个人发生了一次同现关系。我们需要对人物之间的同现关系次数进行统计，同现关系次数越多，则说明两人的关系越密切。 2.2 关键问题 2.2.1 人名冗余 在同一段中，人名可能多次出现，任务一只负责提取出所有的人名，没有剔除多余的人名，任务必须在输出同现次数之前处理冗余人名。我的做法是在Mapper中创建一个集合，把所有人名放入集合中，集合会自动剔除冗余的人名。 2.2.2 同现次数统计 两个人物之间应该输出两个键值对，如“狄云”和“戚芳”，应该输出“<狄云，戚芳> 1”和“<戚芳，狄云> 1”。多个段落中允许输出相同的键值对，因此，Reducer中需要整合具有相同键的输出，输出总的同现次数。 2.3 MapReduce设计 2.3.1 Mapper 2.3.2 Reducer 3 任务3 特征处理：人物关系图构建与特征归一化 3.1 任务描述 根据任务2人物之间的共现关系，生成人物之间的关系图。人物关系使用邻接表的形式表示，人物是顶点，人物之间关系是边，两个人的关系的密切程度由共现次数体现，共现次数越高，边权重越高。另外需要对共现次数进行归一化处理，确保某个顶点的出边权重和为1。 3.2 关键问题 3.2.1 确保人物的所有邻居输出到相同结点处理 在Mapper结点将输入的键值对“<狄云，戚芳> 1”拆分，输出新的键值对“<狄云> 戚芳:1”，“狄云”的所有邻居会被分配给同一个Reducer结点处理。 3.2.2 归一化 在Reducer结点首先统计该人物与所有邻居同现的次数和sum，每个邻居的的同现次数除以sum就得到共现概率。为了提高效率，在第一次遍历邻居的时候，可以把名字和共现次数保存在链表里，避免重复处理字符串。 3.3 MapReduce设计 3.3.1 Mapper 3.3.2 Reducer 4.1 任务描述 经过数据预处理并获得任务的关系图之后，就可以对人物关系图作数据分析，其中一个典型的分析任务是：PageRank 值计算。通过计算 PageRank，我们就可以定量地获知金庸武侠江湖中的“主角”们是哪些。 4.2 PageRank原理 PageRank算法由Google的两位创始人佩奇和布林在研究网页排序问题时提出，其核心思想是：如果一个网页被很多其它网页链接到，说明这个网页很重要，它的PageRank值也会相应较高；如果一个PageRank值很高的网页链接到另外某个网页，那么那个网页的PageRank值也会相应地提高。 相应地，PageRank算法应用到人物关系图上可以这么理解：如果一个人物与多个人物存在关系连接，说明这个人物是重要的，其PageRank值响应也会较高；如果一个PageRank值很高的人物与另外一个人物之间有关系连接，那么那个人物的PageRank值也会相应地提高。一个人物的PageRank值越高，他就越可能是小说中的主角。 PageRank有两个比较常用的模型：简单模型和随机浏览模型。由于本次设计考虑的是人物关系而不是网页跳转，因此简单模型比较合适。简单模型的计算公式如下，其中Bi为所有连接到人物i的集合，Lj为认为人物j对外连接边的总数： 在本次设计的任务3中，已经对每个人物的边权值进行归一化处理，边的权值可以看做是对应连接的人物占总边数的比例。设表示人物i在人物j所有边中所占的权重，则PageRank计算公式可以改写为： 4.3.2 PageRanklter类 GraphBuilder将数据处理成可供迭代的格式，PageRank的迭代过程由PageRanklter类实现，包含一个Map和Reduce过程。Map过程产生两种类型的<key,value>：<人物名，PageRrank值>，<人物名，关系链表>。第一个人物名是关系链表中的各个链出人物名，其PR值由计算得到；第二个人物名是本身人物名，目的是为了保存该人物的链出关系，以保证完成迭代过程。以上面的输出为例，则Map过程产生的键值对为<完颜萍, 1.0 0.005037>，<小龙女, 1.0 0.017632>，……，<一灯大师, #完颜萍:0.005037783;……>。 Reduce过程将同一人物名的<key,value>汇聚在一起，如果value是PR值，则累加到sum变量；如果value是关系链表则保存为List。遍历完迭代器里所有的元素后输出键值对<人物名，sum#List>，这样就完成了一次迭代过程。 PR值排名不变的比例随迭代次数变化的关系图如下，由于我们考虑的是找出小说中的主角，所以只要关心PR值前100名的人物的排名的变化情况，可以看到迭代次数在10以后，PR值排名不变的比例已经趋于稳定了，所以基于效率考虑，选取10作为PR的迭代次数。 4.3.3 PageRankViewer类 当所有迭代都完成后，我们就可以对所有人物的PageRank值进行排序，该过程由PageRankViewer类完成，包含一个Map和Reduce过程。Map过程只提取迭代过程输出结果中的人物名以及对应的PageRank值，并以PageRank值作为key，人物名作为value输出。为了实现PageRank值从大到小排序，需要实现DescFloatComparator类来重写compare方法以达成逆序排序。由于可能存在PageRank值相同的情况，所以还需要一个reduce过程来把因PageRank值相同而汇聚到一起的人物名拆开并输出。 PageRankMapper PageRankReducer Driver类 5.1 任务描述 标签传播（Label Propagation）是一种半监督的图分析算法，他能为图上的顶点打标签，进行图顶点的聚类分析，从而在一张类似社交网络图中完成社区发现。在人物关系图中，通过标签传播算法可以将关联度比较大的人物分到同一标签，可以直观地分析人物间的关系。 5.2 标签传播算法原理 标签传播算法（Label Propagation Algorithm，后面简称LPA）是由Zhu等人于2002年提出，它是一种基于图的半监督学习方法，其基本思路是用已标记节点的标签信息去预测未标记节点的标签信息。LPA基本过程为：（1）每个结点初始化一个特定的标签值；（2）逐轮更新所有节点的标签，直到所有节点的标签不再发生变化为止。对于每一轮刷新，节点标签的刷新规则如下：对于某一个节点，考察其所有邻居节点的标签，并进行统计，将出现个数最多的那个标签赋值给当前节点。当个数最多的标签不唯一时，随机选择一个标签赋值给当前节点。 LPA与PageRank算法相似，同样需要通过迭代过程来完成。在标签传播算法中，节点的标签更新通常有同步更新和异步更新两种方法。同步更新是指，节点x在t时刻的更新是基于邻接节点在t-1时刻的标签。异步更新是指，节点x在t时刻更新时，其部分邻接节点是t时刻更新的标签，还有部分的邻接节点是t-1时刻更新的标签。若LPA算法在标签传播过程中采用的是同步更新，则在二分结构网络中，容易出现标签震荡的现象。在本次设计中，我们考虑到了两种更新方法，并进行了比较。 5.3 标签传播算法在mapreduce上的实现细节 5.3.1 LPAInit类 为实现LPA的迭代过程，需要先给每个人物赋予一个独特标签，标签初始化由LPAInit类完成，仅包含一个Map过程。标签由数字表示，Map过程由1开始，为每一个人物名赋予一个独特的标签。为了便于后面的可视化分析，我们需要把PageRank值和标签整合在一起，所以LPAInit的输入文件直接采用PageRank过程的输出文件，格式如下： 5.3.2 LPAIteration类 LPAIteration类完成标签的更新过程，其格式与LPAInit的输出格式一致，包含一个Map和Reduce过程。Map过程对输入的每一行进行切割，输出四种格式的<key,value>：<人物名，关系链表>，<人物名，PageRank值>，<人物名，标签>，<链出人物名，标签#起点人物名>。第四种格式个键值对是为了将该节点的标签传给其所有邻居。 Reduce过程对value值进行识别，识别可以通过Map过程把预先定义好的特殊字符如‘#"、‘@"来实现前缀到value上来实现。由于人物关系图中的各个边都是有权重的，并且代表两个人物的相关程度，所以标签更新过程不是用边数最多的标签而是权重最大标签来更新，我们可以预先把权重最大的若干个保存到一个链表中，如果存在多个权重相同的标签，则随机选取一个作为该人名新的标签。异步方法更新标签需要使用一个哈希表来存储已经更新标签的人物名和它们的新标签，并且在更新标签时使用该哈希表里面的标签。同步方法更新标签则不需要存储已更新的标签。 本次设计中比较了同步和异步更新两种方法，下图为标签不变的比例随迭代次数的变化。可以发现，异步收敛速度更快，只要6次迭代即可完全收敛，且标签不变的比例可达100%。而同步更新方法则不能达到100%，说明人物关系图中存在子图是二部子图。 5.3.3 LPAReorganize类 LPA算法迭代收敛后，所有人物名的标签不再变化，但是此时的标签排列是散乱的，需要把同一标签的人物名整合在一起。该过程由LPAReorganize类完成，包含一个Map和Reduce过程。Map过程对输入的每一行进行切割，以<标签，人物名#PageRank值#关系链表>格式输出。Reduce过程中，同一标签的人物名汇聚在一起，然后根据每个标签人物集合的大小从大到小排序，重新赋予标签（从1开始）。这样输出文件中同一标签的人物名就会聚集在一起。最后的输出格式如下： 5.3.2 LPAMapper类 LPAIteration类完成标签的更新过程，其格式与LPAInit的输出格式一致，包含一个Map和Reduce过程。Map过程对输入的每一行进行切割，输出四种格式的<key,value>：<人物名，关系链表>，<人物名，PageRank值>，<人物名，标签>，<链出人物名，标签#起点人物名>。第四种格式个键值对是为了将该节点的标签传给其所有邻居。 5.3.2 LPAReducer类 Reduce过程对value值进行识别，识别可以通过Map过程把预先定义好的特殊字符如‘#"、‘@"来实现前缀到value上来实现。由于人物关系图中的各个边都是有权重的，并且代表两个人物的相关程度，所以标签更新过程不是用边数最多的标签而是权重最大标签来更新，我们可以预先把权重最大的若干个保存到一个链表中，如果存在多个权重相同的标签，则随机选取一个作为该人名新的标签。异步方法更新标签需要使用一个哈希表来存储已经更新标签的人物名和它们的新标签，并且在更新标签时使用该哈希表里面的标签。同步方法更新标签则不需要存储已更新的标签。 Driver类 6.1 可视化工具Gephi Gephi是一款开源的跨平台的基于JVM的复杂网络分析软件。把PageRank和LPA的结果，转化为gexf格式，在Gephi中绘制图像并分析大数据实验结果，更加直观、易于理解。 gexf实际上是一种特殊的XML文件，python的gexf库提供了接口方便我们编辑和生成gexf文件，因此我们选择使用python处理PageRank和LPA的结果。顶点有两种属性，LPA生成的标签和PageRank计算的PR值，每条边的权重是PageRank计算出的值。在可视化的时候，标签决定顶点显示的颜色，PR值决定标签的 6.2 可视化预处理 编写一个python程序transform2xml.py，将数据分析部分得到的PR值，标签以及点连接关系处理成一个可供Gephi读取的gexf文件。 6.3 可视化结果 7 输出结果截图 7.2 同现次数统计 7.4 PageRank

Hadoop　　它是一个分布式系统基础架构，由Apache基金会所开发。　　用户可以在不了解分布式底层细节的情况下，开发分布式程序。充分利用集群的威力进行高速运算和存储。　　Hadoop的框架最核心的设计就是：HDFS和MapReduce.HDFS为海量的数据提供了存储，则MapReduce为海量的数据提供了计算。　　Yarn　　它是Hadoop2.0的升级版。　　Yarn 的优点：　　这个设计大大减小了 JobTracker（也就是现在的 ResourceManager）的资源消耗，并且让监测每一个 Job 子任务 (tasks) 状态的程序分布式化了，更安全、更优美。　　在新的 Yarn 中，ApplicationMaster 是一个可变更的部分，用户可以对不同的编程模型写自己的 AppMst，让更多类型的编程模型能够跑在 Hadoop 集群中，可以参考 hadoop Yarn 官方配置模板中的 mapred-site.xml 配置。　　对于资源的表示以内存为单位 ( 在目前版本的 Yarn 中，没有考虑 cpu 的占用 )，比之前以剩余 slot 数目更合理。　　老的框架中，JobTracker 一个很大的负担就是监控 job 下的 tasks 的运行状况，现在，这个部分就扔给 ApplicationMaster 做了，而 ResourceManager 中有一个模块叫做 ApplicationsMasters( 注意不是 ApplicationMaster)，它是监测 ApplicationMaster 的运行状况，如果出问题，会将其在其他机器上重启。　　Container 是 Yarn 为了将来作资源隔离而提出的一个框架。这一点应该借鉴了 Mesos 的工作，目前是一个框架，仅仅提供 java 虚拟机内存的隔离 ,hadoop 团队的设计思路应该后续能支持更多的资源调度和控制 , 既然资源表示成内存量，那就没有了之前的 map slot/reduce slot 分开造成集群资源闲置的尴尬情况。

　　（1） Hadoop 1.0　　第一代Hadoop，由分布式存储系统HDFS和分布式计算框架MapReduce组成，其中，HDFS由一个NameNode和多个DataNode组成，MapReduce由一个JobTracker和多个TaskTracker组成，对应Hadoop版本为Hadoop 1.x和0.21.X，0.22.x。　　（2） Hadoop 2.0　　第二代Hadoop，为克服Hadoop 1.0中HDFS和MapReduce存在的各种问题而提出的。针对Hadoop 1.0中的单NameNode制约HDFS的扩展性问题，提出了HDFS Federation，它让多个NameNode分管不同的目录进而实现访问隔离和横向扩展；针对Hadoop 1.0中的MapReduce在扩展性和多框架支持方面的不足，提出了全新的资源管理框架YARN(Yet Another Resource Negotiator)，它将JobTracker中的资源管理和作业控制功能分开，分别由组件ResourceManager和ApplicationMaster实现，其中，ResourceManager负责所有应用程序的资源分配，而ApplicationMaster仅负责管理一个应用程序。对应Hadoop版本为Hadoop 0.23.x和2.x。　　（3） MapReduce 1.0或者MRv1（MapReduceversion 1）　　第一代MapReduce计算框架，它由两部分组成：编程模型（programming model）和运行时环境（runtime environment）。它的基本编程模型是将问题抽象成Map和Reduce两个阶段，其中Map阶段将输入数据解析成key/value，迭代调用map()函数处理后，再以key/value的形式输出到本地目录，而Reduce阶段则将key相同的value进行规约处理，并将最终结果写到HDFS上。它的运行时环境由两类服务组成：JobTracker和TaskTracker，其中，JobTracker负责资源管理和所有作业的控制，而TaskTracker负责接收来自JobTracker的命令并执行它。　　（4）MapReduce 2.0或者MRv2（MapReduce version 2）或者NextGen MapReduc　　MapReduce 2.0或者MRv2具有与MRv1相同的编程模型，唯一不同的是运行时环境。MRv2是在MRv1基础上经加工之后，运行于资源管理框架YARN之上的MRv1，它不再由JobTracker和TaskTracker组成，而是变为一个作业控制进程ApplicationMaster，且ApplicationMaster仅负责一个作业的管理，至于资源的管理，则由YARN完成。　　简而言之，MRv1是一个独立的离线计算框架，而MRv2则是运行于YARN之上的MRv1。　　（5）Hadoop-MapReduce（一个离线计算框架）　　Hadoop是google分布式计算框架MapReduce与分布式存储系统GFS的开源实现，由分布式计算框架MapReduce和分布式存储系统HDFS（Hadoop Distributed File System）组成，具有高容错性，高扩展性和编程接口简单等特点，现已被大部分互联网公司采用。　　（6）Hadoop-YARN(Hadoop 2.0的一个分支，实际上是一个资源管理系统)　　YARN是Hadoop的一个子项目（与MapReduce并列），它实际上是一个资源统一管理系统，可以在上面运行各种计算框架（包括MapReduce、Spark、Storm、MPI等）。　　　　当前Hadoop版本比较混乱，让很多用户不知所措。实际上，当前Hadoop只有两个版本：Hadoop 1.0和Hadoop 2.0，其中，Hadoop 1.0由一个分布式文件系统HDFS和一个离线计算框架MapReduce组成，而Hadoop 2.0则包含一个支持NameNode横向扩展的HDFS，一个资源管理系统YARN和一个运行在YARN上的离线计算框架MapReduce。相比于Hadoop 1.0，Hadoop 2.0功能更加强大，且具有更好的扩展性、性能，并支持多种计算框架。　　　　Borg/YARN/Mesos/Torca/Corona一类系统可以为公司构建一个内部的生态系统，所有应用程序和服务可以“和平而友好”地运行在该生态系统上。有了这类系统之后，你不必忧愁使用Hadoop的哪个版本，是Hadoop 0.20.2还是 Hadoop 1.0，你也不必为选择何种计算模型而苦恼，因此各种软件版本，各种计算模型可以一起运行在一台“超级计算机”上了。　　从开源角度看，YARN的提出，从一定程度上弱化了多计算框架的优劣之争。YARN是在Hadoop MapReduce基础上演化而来的，在MapReduce时代，很多人批评MapReduce不适合迭代计算和流失计算，于是出现了Spark和Storm等计算框架，而这些系统的开发者则在自己的网站上或者论文里与MapReduce对比，鼓吹自己的系统多么先进高效，而出现了YARN之后，则形势变得明朗：MapReduce只是运行在YARN之上的一类应用程序抽象，Spark和Storm本质上也是，他们只是针对不同类型的应用开发的，没有优劣之别，各有所长，合并共处，而且，今后所有计算框架的开发，不出意外的话，也应是在YARN之上。这样，一个以YARN为底层资源管理平台，多种计算框架运行于其上的生态系统诞生了。　　　　目前spark是一个非常流行的内存计算（或者迭代式计算，DAG计算）框架，在MapReduce因效率低下而被广为诟病的今天，spark的出现不禁让大家眼前一亮。　　从架构和应用角度上看，spark是一个仅包含计算逻辑的开发库（尽管它提供个独立运行的master/slave服务，但考虑到稳定后以及与其他类型作业的继承性，通常不会被采用），而不包含任何资源管理和调度相关的实现，这使得spark可以灵活运行在目前比较主流的资源管理系统上，典型的代表是mesos和yarn，我们称之为“spark on mesos”和“spark on yarn”。将spark运行在资源管理系统上将带来非常多的收益，包括：与其他计算框架共享集群资源；资源按需分配，进而提高集群资源利用率等。　　FrameWork On YARN　　运行在YARN上的框架，包括MapReduce-On-YARN, Spark-On-YARN, Storm-On-YARN和Tez-On-YARN。　　（1）MapReduce-On-YARN：YARN上的离线计算；　　（2）Spark-On-YARN：YARN上的内存计算；　　（3）Storm-On-YARN：YARN上的实时/流式计算；　　（4）Tez-On-YARN：YARN上的DAG计算

YARN允许用户配置每个节点上可用的物理内存资源，注意，这里是“可用的”，因为一个节点上的内存会被若干个服务共享，比如一部分给YARN，一部分给HDFS，一部分给HBase等，YARN配置的只是自己可以使用的，配置参数如下: (1)yarn.nodemanager.resource.memory-mb 表示该节点上YARN可使用的物理内存总量，默认是8192（MB），注意，如果你的节点内存资源不够8GB，则需要调减小这个值，而YARN不会智能的探测节点的物理内存总量。 (2)yarn.scheduler.minimum-allocation-mb 单个容器可申请的最少物理内存量，默认是1024（MB），如果一个容器申请的物理内存量少于该值，则该对应的值改为这个数。 (3) yarn.scheduler.maximum-allocation-mb 单个容器可申请的最多物理内存量，默认是8192（MB） 目前的CPU被划分成虚拟CPU（CPU virtual Core），这里的虚拟CPU是YARN自己引入的概念，初衷是，考虑到不同节点的CPU性能可能不同，每个CPU具有的计算能力也是不一样的，比如某个物理CPU的计算能力可能是另外一个物理CPU的2倍，这时候，你可以通过为第一个物理CPU多配置几个虚拟CPU弥补这种差异。用户提交作业时，可以指定每个任务需要的虚拟CPU个数。在YARN中，CPU相关配置参数如下： (1)yarn.nodemanager.resource.cpu-vcores 表示该节点上YARN可使用的虚拟CPU个数，默认是8，注意，目前推荐将该值设值为与物理CPU核数数目相同。如果你的节点CPU核数不够8个，则需要调减小这个值，而YARN不会智能的探测节点的物 理CPU总数。 (2)yarn.scheduler.minimum-allocation-vcores 单个容器可申请的最小虚拟CPU个数，默认是1，如果一个容器申请的CPU个数少于该数，则该对应的值改为这个数 (3)yarn.scheduler.maximum-allocation-vcores 单个容器可申请的最多虚拟CPU个数，默认是4 3.mapreduce---Memory调优 (1)yarn.app.mapreduce.am.resource.mb MR AppMaster需要的内存，默认是1536M (2)yarn.app.mapreduce.am.command-opts MR AppMaster的Java opts ，默认是 -Xmx1024m (3)mapreduce.map.memory.mb 每个map task所需要的内存，默认是1024M。应该是大于或者等于Container的最小内存 (4)mapreduce.reduce.memory.mb 每个reduce task所需要的内存，默认是1024M (5)mapreduce.map.java.opts map task进程的java.opts，默认是 -Xmx200m (6)mapreduce.reduce.java.opts reduce task进程的java.opts，默认是 -Xmx200m 特别注意: mapreduce.map.memory.mb >mapreduce.map.java.opts mapreduce.reduce.memory.mb >mapreduce.reduce.java.opts mapreduce.map.java.opts / mapreduce.map.memory.mb =0.70~0.80 mapreduce.reduce.java.opts / mapreduce.reduce.memory.mb =0.70~0.80 在yarn container这种模式下，JVM进程跑在container中，mapreduce.{map|reduce}.java.opts 能够通过Xmx设置JVM最大的heap的使用， 一般设置为0.75倍的memory.mb， 则预留些空间会存储java,scala code等 4.mapreduce---CPU调优 (1)mapreduce.map.cpu.vcores map task的虚拟核数，默认为1 (2)mapreduce.reduce.cpu.vcores reduce task的虚拟核数，默认为1 (3)yarn.app.mapreduce.am.resource.cpu-vcores am的虚拟核数，默认为1 假设机器的物理配置 64G 16cores 装完系统还剩 62G 预留15~20% 14G:DN 4G + NM 1G=5G 9G DN进程: 生产4G 1000m hadoop-env.sh HADOOP_NAMENODE_OPTS=-Xmx1024m HADOOP_DATANODE_OPTS=-Xmx4096m NM进程: 生产1G yarn-env.sh export YARN_RESOURCEMANAGER_HEAPSIZE=1024 export YARN_NODEMANAGER_HEAPSIZE=1024 部署同一台： 数据本地化 NN RM 经常性部署同一台 说白了 集群节点少 yarn.nodemanager.resource.memory-mb : 48G 计算总内存 固定经验计算值 yarn.nodemanager.resource.cpu-vcores : 24 yarn.scheduler.minimum-allocation-mb : 4G yarn.scheduler.minimum-allocation-vcores： 2 yarn.scheduler.maximum-allocation-mb : 8G yarn.scheduler.maximum-allocation-vcores : 4 固定经验值(不要超过5个) http://blog.itpub.net/30089851/viewspace-2127851/ http://blog.itpub.net/30089851/viewspace-2127850/

Environmentally aware consumers are producing less waste by practicing the “3 Rs:” Reduce Reuse Recycle. They are buying products that are less toxic or contain less packaging using reusable containers and other reusable items maintaining and repairing products participating in recycling programs and buying products made from recycled materials. Reduce Waste prevention or "source reduction " me consuming and throwing away less. It includes: * purchasing durable long-lasting goods; * seeking products and packaging that are as free of toxics as possible; * redesigning products to use less raw material in production have a longer life or be used again after its original use. Source reduction actually prevents the generation of waste in the first place so it is the most preferred method of waste management and goes a long way toward protecting the environment. Reuse Reusing items -- by repairing them donating them to charity and munity groups or selling them -- also reduces waste. Reusing products when possible is even better than recycling because the item does not need to be reprocessed before it can be used again. Recycle Benefits of Recycling * Conserves resources for our children"s future. * Prevents emissions of many greenhouse gases and water pollutants. * Saves energy. * Supplies valuable raw materials to industry. * Creates jobs. * Stimulates the development of greener technologies. * Reduces the need for new landfills and incinerators. Recycling turns materials that would otherwise bee waste into valuable resources. In addition it generates a host of environmental financial and social benefits. Materials like glass metal plastics and paper are collected separated and sent to facilities that can process them into new materials or products. Recycling is one of the best environmental success stories of the late 20th century. Recycling including posting diverted 79 million tons of material away from landfills and incinerators in 2005 up from 34 million tons in 1990. By 2002 almost 9 000 curbside collection programs served roughly half of the American population. Curbside programs along with drop-off and buy-back centers resulted in a diversion of about 32 percent of the nation"s solid waste in 2005. * More About Recycling * Recycle on the Go – EPA"s campaign to put recycling places in public spaces * Recycling Publications 1. 再用 重新使用 重复利用 use aagin 1. 减少;缩小;降低 -something recycle 1.使再循环;再利用 reuse aagin 参考: .dictionary.yahoo/

一般表示再怎么样，比如第一个就是重复使用，就是再次使用

单词

reduce [rɪ"djuːs] vi. 减少；缩小；归纳为vt. 减少；降低；使处于；把…分解reuse [riː"juːz] n. 重新使用，再用vt. 再使用recycle [riː"saɪk(ə)l] n. 再生；再循环；重复利用vt. 使再循环；使…重新利用vi. 重复利用

(1)废弃物的减少(Reduce)：对制品设计时要考虑小型、轻便、易于修理，达到省资源、长寿命；修理体制充实完善，使产品的寿命延长；通过升级使产品的寿命延长。(2)部件的再使用(Reuse)：在设计时使部件易于再使用；要再使用的部件应标准化；经修理或再生后再使用。(3)循环(Recycle)的强化：生产者有回收废产品循环利用的义务：为了使不同材料的废弃物再回收时易于区别，生产者有义务添加材料标号；抑制副产物的产生，强化副产物的循环利用。希望以上对您有所帮助！

reduce 减少reuse 来自 re- use 重新使用recycle re-cycle 回收利用

Reduced Chi-Sqr相当于 ANOVA 里面的 Mean Square of Residual，即 RSS/dof。Residual sum of squares残差平方和：概念：为了明确解释变量和随机误差各产生的效应是多少，统计学上把数据点与它在回归直线上相应位置的差异称残差，把每个残差的平方后加起来 称为残差平方和，它表示随机误差的效应。意义：每一点的y值的估计值和实际值的平方差之和称为残差平方和,而y的实际值和平均值的平方差之和称为总平方和。

副词修饰形容词，middle class视作一个形容词，中等收入的，和poor同性，故皆用副词修饰

pay attention to reducing

reduce，使得一些事物在价格、数量，或者大小变得少，或者小。the price was reduced by50 % 价格下降了50%。decline 指的是事物在数量、质量和重要性的增加。the decline of manufacturing。手工制作的衰弱。 fell是fall的过去式，指的是，突然落到地面，当人们站着,散步和跑步。children are always falling over.孩子们总是摔倒。slow指的是活动不是快速，不是快速的做些事情。

decrease （渐渐地）减少reduce （人为的）减少decline （多用于经济方面，如：经济形势、股息的）下降

　　什么是Map/Reduce，看下面的各种解释：　　(1)MapReduce是hadoop的核心组件之一，hadoop要分布式包括两部分，一是分布式文件系统hdfs,一部是分布式计算框，就是mapreduce,缺一不可，也就是说，可以通过mapreduce很容易在hadoop平台上进行分布式的计算编程。　　(2)Mapreduce是一种编程模型，是一种编程方法，抽象理论。　　(3)下面是一个关于一个程序员是如何个妻子讲解什么是MapReduce？文章很长请耐心的看。　　我问妻子：“你真的想要弄懂什么是MapReduce？” 她很坚定的回答说“是的”。 因此我问道：　　我： 你是如何准备洋葱辣椒酱的？（以下并非准确食谱，请勿在家尝试）　　妻子： 我会取一个洋葱，把它切碎，然后拌入盐和水，最后放进混合研磨机里研磨。这样就能得到洋葱辣椒酱了。　　妻子： 但这和MapReduce有什么关系？　　我： 你等一下。让我来编一个完整的情节，这样你肯定可以在15分钟内弄懂MapReduce.　　妻子： 好吧。　　我：现在，假设你想用薄荷、洋葱、番茄、辣椒、大蒜弄一瓶混合辣椒酱。你会怎么做呢？　　妻子： 我会取薄荷叶一撮，洋葱一个，番茄一个，辣椒一根，大蒜一根，切碎后加入适量的盐和水，再放入混合研磨机里研磨，这样你就可以得到一瓶混合辣椒酱了。　　我： 没错，让我们把MapReduce的概念应用到食谱上。Map和Reduce其实是两种操作，我来给你详细讲解下。　　Map（映射）: 把洋葱、番茄、辣椒和大蒜切碎，是各自作用在这些物体上的一个Map操作。所以你给Map一个洋葱，Map就会把洋葱切碎。 同样的，你把辣椒，大蒜和番茄一一地拿给Map，你也会得到各种碎块。 所以，当你在切像洋葱这样的蔬菜时，你执行就是一个Map操作。 Map操作适用于每一种蔬菜，它会相应地生产出一种或多种碎块，在我们的例子中生产的是蔬菜块。在Map操作中可能会出现有个洋葱坏掉了的情况，你只要把坏洋葱丢了就行了。所以，如果出现坏洋葱了，Map操作就会过滤掉坏洋葱而不会生产出任何的坏洋葱块。　　Reduce（化简）:在这一阶段，你将各种蔬菜碎都放入研磨机里进行研磨，你就可以得到一瓶辣椒酱了。这意味要制成一瓶辣椒酱，你得研磨所有的原料。因此，研磨机通常将map操作的蔬菜碎聚集在了一起。　　妻子： 所以，这就是MapReduce?　　我： 你可以说是，也可以说不是。 其实这只是MapReduce的一部分，MapReduce的强大在于分布式计算。　　妻子： 分布式计算？ 那是什么？请给我解释下吧。　　我： 没问题。　　我： 假设你参加了一个辣椒酱比赛并且你的食谱赢得了最佳辣椒酱奖。得奖之后，辣椒酱食谱大受欢迎，于是你想要开始出售自制品牌的辣椒酱。假设你每天需要生产10000瓶辣椒酱，你会怎么办呢？　　妻子： 我会找一个能为我大量提供原料的供应商。　　我：是的..就是那样的。那你能否独自完成制作呢？也就是说，独自将原料都切碎？ 仅仅一部研磨机又是否能满足需要？而且现在，我们还需要供应不同种类的辣椒酱，像洋葱辣椒酱、青椒辣椒酱、番茄辣椒酱等等。　　妻子： 当然不能了，我会雇佣更多的工人来切蔬菜。我还需要更多的研磨机，这样我就可以更快地生产辣椒酱了。　　我：没错，所以现在你就不得不分配工作了，你将需要几个人一起切蔬菜。每个人都要处理满满一袋的蔬菜，而每一个人都相当于在执行一个简单的Map操作。每一个人都将不断的从袋子里拿出蔬菜来，并且每次只对一种蔬菜进行处理，也就是将它们切碎，直到袋子空了为止。　　这样，当所有的工人都切完以后，工作台（每个人工作的地方）上就有了洋葱块、番茄块、和蒜蓉等等。　　妻子：但是我怎么会制造出不同种类的番茄酱呢？　　我：现在你会看到MapReduce遗漏的阶段—搅拌阶段。MapReduce将所有输出的蔬菜碎都搅拌在了一起，这些蔬菜碎都是在以key为基础的 map操作下产生的。搅拌将自动完成，你可以假设key是一种原料的名字，就像洋葱一样。 所以全部的洋葱keys都会搅拌在一起，并转移到研磨洋葱的研磨器里。这样，你就能得到洋葱辣椒酱了。同样地，所有的番茄也会被转移到标记着番茄的研磨器里，并制造出番茄辣椒酱。　　（4）上面都是从理论上来说明什么是MapReduce，那么咱们在MapReduce产生的过程和代码的角度来理解这个问题。　　如果想统计下过去10年计算机论文出现最多的几个单词，看看大家都在研究些什么，那收集好论文后，该怎么办呢？　　方法一：　　我可以写一个小程序，把所有论文按顺序遍历一遍，统计每一个遇到的单词的出现次数，最后就可以知道哪几个单词最热门了。 这种方法在数据集比较小时，是非常有效的，而且实现最简单，用来解决这个问题很合适。　　方法二：　　写一个多线程程序，并发遍历论文。　　这个问题理论上是可以高度并发的，因为统计一个文件时不会影响统计另一个文件。当我们的机器是多核或者多处理器，方法二肯定比方法一高效。但是写一个多线程程序要比方法一困难多了，我们必须自己同步共享数据，比如要防止两个线程重复统计文件。　　方法三：　　把作业交给多个计算机去完成。　　我们可以使用方法一的程序，部署到N台机器上去，然后把论文集分成N份，一台机器跑一个作业。这个方法跑得足够快，但是部署起来很麻烦，我们要人工把程序copy到别的机器，要人工把论文集分开，最痛苦的是还要把N个运行结果进行整合（当然我们也可以再写一个程序）。　　方法四：　　让MapReduce来帮帮我们吧！　　MapReduce本质上就是方法三，但是如何拆分文件集，如何copy程序，如何整合结果这些都是框架定义好的。我们只要定义好这个任务（用户程序），其它都交给MapReduce。　　map函数和reduce函数　　map函数和reduce函数是交给用户实现的，这两个函数定义了任务本身。　　map函数：接受一个键值对（key-value pair），产生一组中间键值对。MapReduce框架会将map函数产生的中间键值对里键相同的值传递给一个reduce函数。　　reduce函数：接受一个键，以及相关的一组值，将这组值进行合并产生一组规模更小的值（通常只有一个或零个值）。　　统计词频的MapReduce函数的核心代码非常简短，主要就是实现这两个函数。　　map(String key, String value):　　// key: document name　　// value: document contents　　for each word w in value:　　EmitIntermediate(w, "1");　　reduce(String key, Iterator values):　　// key: a word　　// values: a list of counts　　int result = 0;　　for each v in values:　　result += ParseInt(v);　　Emit(AsString(result));　　在统计词频的例子里，map函数接受的键是文件名，值是文件的内容，map逐个遍历单词，每遇到一个单词w，就产生一个中间键值对<w, "1">，这表示单词w咱又找到了一个；MapReduce将键相同（都是单词w）的键值对传给reduce函数，这样reduce函数接受的键就是单词w，值是一串"1"（最基本的实现是这样，但可以优化），个数等于键为w的键值对的个数，然后将这些“1”累加就得到单词w的出现次数。最后这些单词的出现次数会被写到用户定义的位置，存储在底层的分布式存储系统（GFS或HDFS）。转载

首先，数据拟合是需要根据你的实验符合的数学模型进行拟合，你需要了解你的数据符合哪种函数，然后根据这个函数对你采集到的实验数据进行拟合。 至于具体的拟合步骤，需要在 Analysis — Non-linear Curve Fit — Advanced Fitting Tool 在弹出的对话框左侧是多项式的项数，有线性Line Mode，多项式Poly，常数 Constent，线性line，Parabalo抛物线，Cubic三次方，Poly4，Poly5 等，右侧的白框中会显示相应的函数表达式。 如果这里没有你需要的多项式，可以点击对话框右下侧的 More，选择更多的函数类型。在新对话框中，左上Categories中有各种常用的函数类型，右上方Functions 里有相应的具体函数形式，下方的方框中有其函数表达式Equation，曲线形式Sample Curve，和函数文件Function File（这个可以不用管，除非你想编程）选择符合你实验的函数，然后调整各个参数值进行拟合工作。 然后点击上方的工具栏中 Action — Fit，点击 100 Iter ，Done

这条被毁坏的支离破碎的船，已难辨其真。

减少的支出..

词义基本近义 但reduce 侧重减少 lessen 侧重减轻,可以用于减轻抽象的概念 比如压力 而reduce 有个词组 be reduced to doing 被迫干什么 lessen 没有

减少发动机功率

reduced level折合水准，归化高程减少的水平；双语例句1. Carrie was not to be reduced to the common level of observation. 嘉莉并不迁就那种平庸的看法.2. This may occur in response to a high level of reduced nitrogen in the medium. 这可能是由于对培养基中高水平的还原氮的反应而发生的.3. Its ravages must be reduced to a level where reasonable economic return can be achieved. 它的危害程度必须减少到能够得到合理的经济收入为度.*********************************************************************祝学习进步！如果不明白，请再问；如果对你有所帮助，请点击本页面中的“选为满意回答”按钮，谢谢！**********************************************************************

reduced cost：非基变量增加一个单位时（其他非基变量保持不变）目标函数减少的量(对max型问题) slack orSurplus：资源（原材料）剩余量 dual price ：最优解下“资源”增加1单位时“效益”的增量；或者是原料增1单位,利润增加的值

很高兴告诉你！reduced[英][r "dju:st][美][r "dju:st]adj减少的，简化的; v换算( reduce的过去式和过去分词 ); 约束; 使变为; 使变弱;为你解除疑惑是我的快乐！

reduce to ruin减少了词典结果：reduce[英][ru026au02c8dju:s][美][ru026au02c8du:s]vt.减少; 缩小; 使还原; 使变弱; vi.减少; 节食; 蒸发; （液体）浓缩变稠; 第三人称单数：reduces过去分词：reduced现在进行时：reducing过去式：reduced以上结果来自金山词霸例句:1.What is millercoors doing to reduce its water consumption? 米勒康胜公司采取了哪些措施来减少用水量？

reduced 减价了的 reduced to clear 为了清仓而减价的 reduced to clear items 为了清仓而减价的物品 Promotions 促销,优惠 优惠不包括为了清仓而减价的物品

意思是,减少,应用在数量,数目的减少注意减少体重要用lose没有特殊的用法,记住reduce to 减少到 reduce by 减少了 就可以了

不是主观上你想减它就少

根据用这款音响的朋友说，声擎HD3蓝牙书架音箱看说明书就知道Normal和REDUCED是普通模式和减少低频量感这两种，如果你没有外接低音炮，那么这个模式下低频将会被削弱，与一般音箱打开BASS开关是加重低频恰恰相反。

1空气滤清器脏：空气滤清器是为了保护发动机减少磨损设计的，一般在一万公里左右更换，如果更换不及时，会发生进气不足引起怠速低，而使发动机抖动，只要更换滤芯就可解决。2高压线断路：高压线断路是指高压线导线芯断路，可影响点火，引起发动机抖动，可用万用表测量电阻，把电阻明显偏大几倍的那一根换掉。3火花塞寿命：火花塞是有寿命的，超过3- 4万公里后点火效率明显降低，并可影响点火，这是最常见得故障将火花塞全部更换即可。

在开车时按M，点击屏幕下方的自带卡车，点击自己所在的城市，选择，设置为GPS目标，到那边后，在大门口那个绿色的玩意停下按ENTER，点击选择货物，倒到货物面前根据提示按T，如果觉得货物没意思可以按F6-取消任务。Reduced2破解版是一款随时驾驶着越野车开启有趣的登山之旅的模拟休闲游戏，逼真的3D环境让人代入感十足，在前进的过程中还伴随着真实变化的天气，在急转弯的时候要万分小心，展示你出色的驾驶技巧，不要从高山上掉下来，完成在每个关卡中的任务，你将会面临非常严峻的挑战，安全是最重要的哦。 1、真实平滑的控制方式，驾驶多种不同类型的越野车，无与伦比的细节魅力； 2、尝试不同的越野技术来完成闯关任务，解锁更多的地图和车辆； 3、精确的物理系统，随时随地同步操控，第一人陈视角让你变身越野高手。

be reduced to虽然在词典里有汉语翻译，但其实它是无法准确翻译成汉语里的某一个词的，你只能从主语和宾语之间的关系上去理解它的含义。

reducedcost：非基变量增加一个单位时（其他非基变量保持不变）目标函数减少的量(对max型问题)slackorSurplus：资源（原材料）剩余量dualprice：最优解下“资源”增加1单位时“效益”的增量；或者是原料增1单位,利润增加的值

reduced 英[ru026a"dju:st]美[ru026a"dju:st]adj. 减少的，简化的;v. 换算; ( reduce的过去式和过去分词 ) 约束; 使变为; 使变弱;[网络] 还原; 减低; 简化;[例句]This reduced the weight of the load.这减轻了负荷的重量。[其他] 形近词： adduced educed seduced

reduce to “降低到……，减少到……”，介词to后面接的是最终的结果，也就是最后的位置或程度。 例如：The temperature is 36 degrees,but it will be reduced to 20 degrees in the night. 现在气温40度，但是夜间将会降低到20度。 reduce by “降低了……，减少了“，介词by后面跟降低或减少的具体幅度。例如：He weighed 75 kilos last month, and now his weight has been reduced by 10 kilos.他上个月75公斤，现在减了10公斤。（现在是65公斤）

我觉得是这样的：reduce是一种主观的减少、降低，主语是使减少的外力，to make something smaller or less in size, amount, or price；decrese是一种客观的减少、下降，主语是减少的东西（size, amount, or price etc.）,to go down to a lower level, or to make something do this.

...the price is reduced.是被动语态结构 be+动词的过去分词

There are many ways to fight pollution in the present word.One way is to reduce the amount of cars being produced.This would lead to less smog and decrease pollution.Another way is to plant more trees.This would increase the oxygen in the air and lead to a heathier environment.Three other ways to fight pollution:Disposing of trash properly,decreasing the use of pesticides,and always recycling water bottles.There is air and water on the earth.There are people,animals and plants on the earth.People have lived on the earth for millions of years.Many years ago,the earthwas clean.But today,there is air pollution,water pollution and land pollution.People are cutting down the forests.Many plantswild animals,birds and insects live there.People are killing animals for food and their skins.People are polluting the land,the water and the air.People must stop doing this.We must save the earth

There are many ways to fight pollution in the present word.One way is to reduce the amount of cars being produced.This would lead to less smog and decrease pollution.Another way is to plant more trees.This would increase the oxygen in the air and lead to a heathier environment.Three other ways to fight pollution:Disposing of trash properly,decreasing the use of pesticides,and always recycling water bottles.There is air and water on the earth.There are people,animals and plants on the earth.People have lived on the earth for millions of years.Many years ago,the earthwas clean.But today,there is air pollution,water pollution and land pollution.People are cutting down the forests.Many plantswild animals,birds and insects live there.People are killing animals for food and their skins.People are polluting the land,the water and the air.People must stop doing this.We must save the earth.以上仅供参考，满意，请参考，谢谢

答案是BNot only do they want a pay increase, they want reduced hours as well.他们不仅想要涨薪水，他们也想减少工作时间。1、not only…but also…的用法用于连接两个表示并列关系的成分，着重强调后者，其意为“不仅……而且……”；其中的also有时可以省略。如：She not only plays well, but also writes music. 她不仅很会演奏，而且还会作曲。He not only writes his own plays, he also acts in them. 他不仅是自编剧本, 还饰演其中的角色。Not only men but also women were chosen. 不仅仅是男的，女的也有被选中的。He works not only on weekdays but on Sundays as well. 他不仅平时工作，星期日也工作。Not only the students but also their teacher is enjoying the film. 不仅学生们在欣赏这部影片，他们的老师也在欣赏这部影片。说明：若连接两个成分作主语，其谓语通常与靠近的主语保持一致。如：Not only you but also he has to leave. 不只是你，他也得离开。若连接两个句子，not only后面的句子要用倒装，如：Not only did he speak more correctly, but he spoke more easily. 他不仅说得更正确，而且讲得更不费劲了。

reduce是一种主观的减少、降低，主语是使减少的外力，to make something smaller or less in size, amount, or price； decrese是一种客观的减少、下降，主语是减少的东西（size, amount, or price etc.）,to go down to a lower level, or to make something do this.

LS回复的很经典。。。

MapReduce 转换到 SparkSpark 是类似于 MapReduce 的计算引擎，它提出的内存方式解决了 MapReduce 存在的读取磁盘速度较慢的困难，此外，它基于 Scala 的函数式编程风格和 API，进行并行计算时效率很高。由于 Spark 采用的是 RDD(弹性分布式结果集) 方式对数据进行计算，这种方式与 MapReduce 的 Map()、Reduce() 方式差距较大，所以很难直接使用 Mapper、Reducer 的 API，这也是阻碍 MapReduce 转为 Spark 的绊脚石。Scala 或者 Spark 里面的 map() 和 reduce() 方法与 Hadoop MapReduce 里面的 map()、reduce() 方法相比，Hadoop MapReduce 的 API 更加灵活和复杂，下面列出了 Hadoop MapReduce 的一些特性：Mappers 和 Reducers 通常使用 key-value 键值对作为输入和输出；一个 key 对应一个 Reducer 的 reduce；每一个 Mapper 或者 Reducer 可能发出类似于 0,1 这样的键值对作为每一次输出；Mappers 和 Reducers 可能发出任意的 key 或者 value，而不是标准数据集方式；Mapper 和 Reducer 对象对每一次 map() 和 reduce() 的调用都存在生命周期。它们支持一个 setup() 方法和 cleanup() 方法，这些方法可以被用来在处理批量数据之前的操作。试想这么一个场景，我们需要计算一个文本文件里每一行的字符数量。在 Hadoop MapReduce 里，我们需要为 Mapper 方法准备一个键值对，key 用作行的行数，value 的值是这一行的字符数量。清单 9. MapReduce 方式 Map 函数public class LineLengthCountMapper extends Mapper<LongWritable,Text,IntWritable,IntWritable> { @Override protected void map(LongWritable lineNumber, Text line, Context context) throws IOException, InterruptedException { context.write(new IntWritable(line.getLength()), new IntWritable(1)); }}清单 9 所示代码，由于 Mappers 和 Reducers 只处理键值对，所以对于类 LineLengthCountMapper 而言，输入是 TextInputFormat 对象，它的 key 由行数提供，value 就是该行所有字符。换成 Spark 之后的代码如清单 10 所示。清单 10. Spark 方式 Map 函数lines.map(line => (line.length, 1))在 Spark 里，输入是弹性分布式数据集 (Resilient Distributed Dataset)，Spark 不需要 key-value 键值对，代之的是 Scala 元祖 (tuple)，它是通过 (line.length, 1) 这样的 (a,b) 语法创建的。以上代码中 map() 操作是一个 RDD，(line.length, 1) 元祖。当一个 RDD 包含元祖时，它依赖于其他方法，例如 reduceByKey()，该方法对于重新生成 MapReduce 特性具有重要意义。清单 11 所示代码是 Hadoop MapReduce 统计每一行的字符数，然后以 Reduce 方式输出。清单 11. MapReduce 方式 Reduce 函数public class LineLengthReducer extends Reducer<IntWritable,IntWritable,IntWritable,IntWritable> { @Override protected void reduce(IntWritable length, Iterable<IntWritable> counts, Context context) throws IOException, InterruptedException { int sum = 0; for (IntWritable count : counts) { sum += count.get(); } context.write(length, new IntWritable(sum)); }}Spark 里面的对应代码如清单 12 所示。清单 12. Spark 方式 Reduce 函数val lengthCounts = lines.map(line => (line.length, 1)).reduceByKey(_ + _)Spark 的 RDD API 有一个 reduce() 方法，它会 reduce 所有的 key-value 键值对到一个独立的 value。我们现在需要统计大写字母开头的单词数量，对于文本的每一行而言，一个 Mapper 可能需要统计很多个键值对，代码如清单 13 所示。清单 13. MapReduce 方式计算字符数量public class CountUppercaseMapper extends Mapper<LongWritable,Text,Text,IntWritable> { @Override protected void map(LongWritable lineNumber, Text line, Context context) throws IOException, InterruptedException { for (String word : line.toString().split(" ")) { if (Character.isUpperCase(word.charAt(0))) { context.write(new Text(word), new IntWritable(1)); } } }}在 Spark 里面，对应的代码如清单 14 所示。清单 14. Spark 方式计算字符数量lines.flatMap(_.split(" ").filter(word => Character.isUpperCase(word(0))).map(word => (word,1)))MapReduce 依赖的 Map 方法这里并不适用，因为每一个输入必须对应一个输出，这样的话，每一行可能占用到很多的输出。相反的，Spark 里面的 Map 方法比较简单。Spark 里面的方法是，首先对每一行数据进行汇总后存入一个输出结果物数组，这个数组可能是空的，也可能包含了很多的值，最终这个数组会作为一个 RDD 作为输出物。这就是 flatMap() 方法的功能，它对每一行文本里的单词转换成函数内部的元组后进行了过滤。在 Spark 里面，reduceByKey() 方法可以被用来统计每篇文章里面出现的字母数量。如果我们想统计每一篇文章里面出现的大写字母数量，在 MapReduce 里程序可以如清单 15 所示。清单 15. MapReduce 方式public class CountUppercaseReducer extends Reducer<Text,IntWritable,Text,IntWritable> { @Override protected void reduce(Text word, Iterable<IntWritable> counts, Context context) throws IOException, InterruptedException { int sum = 0; for (IntWritable count : counts) { sum += count.get(); } context.write(new Text(word.toString().toUpperCase()), new IntWritable(sum)); }}在 Spark 里，代码如清单 16 所示。清单 16. Spark 方式groupByKey().map { case (word,ones) => (word.toUpperCase, ones.sum) }groupByKey() 方法负责收集一个 key 的所有值，不应用于一个 reduce 方法。本例中，key 被转换成大写字母，值被直接相加算出总和。但这里需要注意，如果一个 key 与很多个 value 相关联，可能会出现 Out Of Memory 错误。Spark 提供了一个简单的方法可以转换 key 对应的值，这个方法把 reduce 方法过程移交给了 Spark，可以避免出现 OOM 异常。reduceByKey(_ + _).map { case (word,total) => (word.toUpperCase,total) }setup() 方法在 MapReduce 里面主要的作用是在 map 方法开始前对输入进行处理，常用的场景是连接数据库，可以在 cleanup() 方法中释放在 setup() 方法里面占用的资源。清单 17. MapReduce 方式public class SetupCleanupMapper extends Mapper<LongWritable,Text,Text,IntWritable> { private Connection dbConnection; @Override protected void setup(Context context) { dbConnection = ...; } ... @Override protected void cleanup(Context context) { dbConnection.close(); }}

祝你身体健康~~~

reduce 的名词 reduction（减少） increase的名词 increment （增加）

因为level为可数名词，望采纳，谢谢

B

解释如下lower ,decline,reduce都有动词 减少的意思，其实在做减少时意思差不多。真正他们不同的在于当他们不是表示减少是意思很不同。例如decline可以表示拒绝。lower可以表示低。reduce可以表示节食;蒸发;至于表达“机会”的意思很多，为什么偏偏是opportunity，这个就是人家语言发展形成的习惯。好比我们说一双筷子，你为啥说一双筷子，而不是说一条筷子呢？就是个习惯。语言不像工科可以用公式表达的。

，reduce 最为通用，可指在体积、数量、金额、程度及范围等方面的减少 lower 多指价值、等级及水平的减少和降低，其强调程度和所指的精确程度不及reduce 5.。

应该说这两个词都有"减少"的意思,但感觉应该不完全相等

可以查看这个参数和监控里面都是可以看到的，而且那个成功的次数和命令都不一样

看报错应该是缺少zookeeper依赖jar包，看一下hadoop使用的zookeeper版本和hbase使用的是否版本一致。或者hbase使用的是不是内置的zookeeper