Hadoop源码篇---解读Mapprer源码outPut输出

MATLAB App打包实战:从代码到独立桌面程序的完整指南 在软件开发和工程实践中,将原型代码转化为可独立分发的应用程序是产品化、专业化的关键环节。其核心原理是通过编译器将源代码及其依赖项打包,生成不依赖完整开发环境的可执行文件,从而解决软件部署和分发的难题。这一技术对于提升工具易用性、扩大用户群体具有重要价值,广泛应用于数据分析、科学计算、工业仿真等场景。本文聚焦于MATLAB App Designer应用的打包流程,深入解析如何利用Application Compiler工具箱,将图形界面应用及其依赖(包括自定义函数、数据文件和工具箱)高效地编译为可安装的桌面程 阅读详情

一。前述

上次讲完MapReduce的输入后,这次开始讲MapReduce的输出。注意MapReduce的原语很重要:

“相同”的key为一组,调用一次reduce方法,方法内迭代这一组数据进行计算!!!!!

二。代码

继续看MapTask任务。

private <INKEY,INVALUE,OUTKEY,OUTVALUE>
  void runNewMapper(final JobConf job,
                    final TaskSplitIndex splitIndex,
                    final TaskUmbilicalProtocol umbilical,
                    TaskReporter reporter
                    ) throws IOException, ClassNotFoundException,
                             InterruptedException {
    // make a task context so we can get the classes
    org.apache.hadoop.mapreduce.TaskAttemptContext taskContext =
      new org.apache.hadoop.mapreduce.task.TaskAttemptContextImpl(job, 
                                                                  getTaskID(),
                                                                  reporter);
    // make a mapper
    org.apache.hadoop.mapreduce.Mapper<INKEY,INVALUE,OUTKEY,OUTVALUE> mapper =
      (org.apache.hadoop.mapreduce.Mapper<INKEY,INVALUE,OUTKEY,OUTVALUE>)
        ReflectionUtils.newInstance(taskContext.getMapperClass(), job);
    // make the input format
    org.apache.hadoop.mapreduce.InputFormat<INKEY,INVALUE> inputFormat =
      (org.apache.hadoop.mapreduce.InputFormat<INKEY,INVALUE>)
        ReflectionUtils.newInstance(taskContext.getInputFormatClass(), job);
    // rebuild the input split
    org.apache.hadoop.mapreduce.InputSplit split = null;
    split = getSplitDetails(new Path(splitIndex.getSplitLocation()),
        splitIndex.getStartOffset());
    LOG.info("Processing split: " + split);

    org.apache.hadoop.mapreduce.RecordReader<INKEY,INVALUE> input =
      new NewTrackingRecordReader<INKEY,INVALUE>
        (split, inputFormat, reporter, taskContext);
    
    job.setBoolean(JobContext.SKIP_RECORDS, isSkipping());
    org.apache.hadoop.mapreduce.RecordWriter output = null;
    
    // get an output object
    if (job.getNumReduceTasks() == 0) {
      output = 
        new NewDirectOutputCollector(taskContext, job, umbilical, reporter);
    } else {
      output = new NewOutputCollector(taskContext, job, umbilical, reporter);源码解析一
    }

    org.apache.hadoop.mapreduce.MapContext<INKEY, INVALUE, OUTKEY, OUTVALUE> 
    mapContext = 
      new MapContextImpl<INKEY, INVALUE, OUTKEY, OUTVALUE>(job, getTaskID(), 
          input, output, 
          committer, 
          reporter, split);

    org.apache.hadoop.mapreduce.Mapper<INKEY,INVALUE,OUTKEY,OUTVALUE>.Context 
        mapperContext = 
          new WrappedMapper<INKEY, INVALUE, OUTKEY, OUTVALUE>().getMapContext(
              mapContext);

    try {
      input.initialize(split, mapperContext);
      mapper.run(mapperContext);
      mapPhase.complete();
      setPhase(TaskStatus.Phase.SORT);
      statusUpdate(umbilical);
      input.close();
      input = null;
      output.close(mapperContext);
      output = null;
    } finally {
      closeQuietly(input);
      closeQuietly(output, mapperContext);
    }
  }

解析一。构造OutPut对象:

 NewOutputCollector(org.apache.hadoop.mapreduce.JobContext jobContext,
                       JobConf job,
                       TaskUmbilicalProtocol umbilical,
                       TaskReporter reporter
                       ) throws IOException, ClassNotFoundException {
      collector = createSortingCollector(job, reporter);//对应解析源码1.2
      partitions = jobContext.getNumReduceTasks();//分区数等于Reduce数,分区数大于分组的概念。
      if (partitions > 1) {
        partitioner = (org.apache.hadoop.mapreduce.Partitioner<K,V>)
          ReflectionUtils.newInstance(jobContext.getPartitionerClass(), job);//对应源码1.1
      } else {
        partitioner = new org.apache.hadoop.mapreduce.Partitioner<K,V>() {
          @Override
          public int getPartition(K key, V value, int numPartitions) {
            return partitions - 1;//用户不设置时默认框架一个reduce,并且分区号为0
          }
        };
      }
    }
  @Override
    public void write(K key, V value) throws IOException, InterruptedException {
      collector.collect(key, value,
                        partitioner.getPartition(key, value, partitions));//上下文对象构造写出的值,放在collect缓存区中。
    }


解析1.1

public Class<? extends Partitioner<?,?>> getPartitionerClass()
throws ClassNotFoundException {
return (Class<? extends Partitioner<?,?>>)
conf.getClass(PARTITIONER_CLASS_ATTR, HashPartitioner.class);//当用户设置取用户的,没设置默认HashPartitioner 对应解析源码1.1.1

解析源码1.2createSortingCollector类的具体实现

 private <KEY, VALUE> MapOutputCollector<KEY, VALUE>
          createSortingCollector(JobConf job, TaskReporter reporter)
    throws IOException, ClassNotFoundException {
    MapOutputCollector.Context context =
      new MapOutputCollector.Context(this, job, reporter);

    Class<?>[] collectorClasses = job.getClasses(
      JobContext.MAP_OUTPUT_COLLECTOR_CLASS_ATTR, MapOutputBuffer.class);
    int remainingCollectors = collectorClasses.length;
    for (Class clazz : collectorClasses) {
      try {
        if (!MapOutputCollector.class.isAssignableFrom(clazz)) {
          throw new IOException("Invalid output collector class: " + clazz.getName() +
            " (does not implement MapOutputCollector)");
        }
        Class<? extends MapOutputCollector> subclazz =
          clazz.asSubclass(MapOutputCollector.class);
        LOG.debug("Trying map output collector class: " + subclazz.getName());
        MapOutputCollector<KEY, VALUE> collector =
          ReflectionUtils.newInstance(subclazz, job);
        collector.init(context);//解析源码对应1.2.1
        LOG.info("Map output collector class = " + collector.getClass().getName());
        return collector;
      } catch (Exception e) {
        String msg = "Unable to initialize MapOutputCollector " + clazz.getName();
        if (--remainingCollectors > 0) {
          msg += " (" + remainingCollectors + " more collector(s) to try)";
        }
        LOG.warn(msg, e);
      }
    }
    throw new IOException("Unable to initialize any output collector");
  }

 解析源码1.2.1 缓冲区collect的初始化

 public void init(MapOutputCollector.Context context
                    ) throws IOException, ClassNotFoundException {
      job = context.getJobConf();
      reporter = context.getReporter();
      mapTask = context.getMapTask();
      mapOutputFile = mapTask.getMapOutputFile();
      sortPhase = mapTask.getSortPhase();
      spilledRecordsCounter = reporter.getCounter(TaskCounter.SPILLED_RECORDS);
      partitions = job.getNumReduceTasks();
      rfs = ((LocalFileSystem)FileSystem.getLocal(job)).getRaw();

      //sanity checks
      final float spillper =
        job.getFloat(JobContext.MAP_SORT_SPILL_PERCENT, (float)0.8);//缓冲区溢写阈值,
      final int sortmb = job.getInt(JobContext.IO_SORT_MB, 100);//缓冲区默认单位是100M
      indexCacheMemoryLimit = job.getInt(JobContext.INDEX_CACHE_MEMORY_LIMIT,
                                         INDEX_CACHE_MEMORY_LIMIT_DEFAULT);
      if (spillper > (float)1.0 || spillper <= (float)0.0) {
        throw new IOException("Invalid \"" + JobContext.MAP_SORT_SPILL_PERCENT +
            "\": " + spillper);
      }
      if ((sortmb & 0x7FF) != sortmb) {
        throw new IOException(
            "Invalid \"" + JobContext.IO_SORT_MB + "\": " + sortmb);
      }
      sorter = ReflectionUtils.newInstance(job.getClass("map.sort.class",
            QuickSort.class, IndexedSorter.class), job);//Map从缓冲区往磁盘写文件的时候需要排序,用的快排。
      // buffers and accounting
      int maxMemUsage = sortmb << 20;
      maxMemUsage -= maxMemUsage % METASIZE;
      kvbuffer = new byte[maxMemUsage];
      bufvoid = kvbuffer.length;
      kvmeta = ByteBuffer.wrap(kvbuffer)
         .order(ByteOrder.nativeOrder())
         .asIntBuffer();
      setEquator(0);
      bufstart = bufend = bufindex = equator;
      kvstart = kvend = kvindex;

      maxRec = kvmeta.capacity() / NMETA;
      softLimit = (int)(kvbuffer.length * spillper);
      bufferRemaining = softLimit;
      LOG.info(JobContext.IO_SORT_MB + ": " + sortmb);
      LOG.info("soft limit at " + softLimit);
      LOG.info("bufstart = " + bufstart + "; bufvoid = " + bufvoid);
      LOG.info("kvstart = " + kvstart + "; length = " + maxRec);
      comparator = job.getOutputKeyComparator();//排序所使用的比较器 见源码解析1,2.1.1
      keyClass = (Class<K>)job.getMapOutputKeyClass();
      valClass = (Class<V>)job.getMapOutputValueClass();
      serializationFactory = new SerializationFactory(job);
      keySerializer = serializationFactory.getSerializer(keyClass);
      keySerializer.open(bb);
      valSerializer = serializationFactory.getSerializer(valClass);
      valSerializer.open(bb);
// combiner
      final Counters.Counter combineInputCounter =
        reporter.getCounter(TaskCounter.COMBINE_INPUT_RECORDS);
      combinerRunner = CombinerRunner.create(job, getTaskID(), //map端的组合 
                                             combineInputCounter,
                                             reporter, null);
      if (combinerRunner != null) {
        final Counters.Counter combineOutputCounter =
          reporter.getCounter(TaskCounter.COMBINE_OUTPUT_RECORDS);
        combineCollector= new CombineOutputCollector<K,V>(combineOutputCounter, reporter, job);
      } else {
        combineCollector = null;
      }

      spillInProgress = false;
      minSpillsForCombine = job.getInt(JobContext.MAP_COMBINE_MIN_SPILLS, 3);//小文件最少是3时,会合并小文件。
      spillThread.setDaemon(true);//线程是另外一个线程负责写的 见解析源码1.2.1.2
      spillThread.setName("SpillThread");
      spillLock.lock();

总结:Mappper输出到缓冲区默认是100M,写到0.8时,会溢写!!!!这块可以调优。通过来回折半来调比如第一次调整50% 然后再80%中减小 70% 然后60%来回折半。

          Combine一定要注意,比如求平均值

 解析1,2.1.1排序比较器的实现

 

 public RawComparator getOutputKeyComparator() {
    Class<? extends RawComparator> theClass = getClass(
      JobContext.KEY_COMPARATOR, null, RawComparator.class);字典排序 默认
    if (theClass != null)
      return ReflectionUtils.newInstance(theClass, this);
    return WritableComparator.get(getMapOutputKeyClass().asSubclass(WritableComparable.class), this);//如果用户没有设置排序比较器,就是Key类型自己的比较器,所以Key必须实现序列化,反序列化,比较器。
  }

 

总结:框架默认使用Key的比较器,字典排序 默认,用户也可以覆盖Key的比较器,自定义。!!!

 

解析源码1.2.1.2 溢写线程做的事
protected class SpillThread extends Thread {

      @Override
      public void run() {
        spillLock.lock();
        spillThreadRunning = true;
        try {
          while (true) {
            spillDone.signal();
            while (!spillInProgress) {
              spillReady.await();
            }
            try {
              spillLock.unlock();
              sortAndSpill();//排序溢写
            } catch (Throwable t) {
              sortSpillException = t;
            } finally {
              spillLock.lock();
              if (bufend < bufstart) {
                bufvoid = kvbuffer.length;
              }
              kvstart = kvend;
              bufstart = bufend;
              spillInProgress = false;
            }
          }
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
        } finally {
          spillLock.unlock();
          spillThreadRunning = false;
        }
      }
    }

总结:Map往缓冲区写入东西,线程把缓冲区中的内容做溢写,开始排序,溢写使用快排!!!Combine也在内存中,buffer也在内存,这些计算逻辑都在内存中,排序算法也在内存中,因为Map方法在内存中,这是第一次Combine,从Buffer产生一堆小文件的时候,然后一堆小文件在合并的时候还会执行一次Combine,这次有条件限制(小文件数量大于3)。

 

 

 

解析源码1.1.1

public class HashPartitioner<K, V> extends Partitioner<K, V> {

  /** Use {@link Object#hashCode()} to partition. */
  public int getPartition(K key, V value,
                          int numReduceTasks) {
    return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;!!!
  }
return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;!!!重要取分区的写法!!

总结1.以上源码来源于 output = new NewOutputCollector(taskContext, job, umbilical, reporter);所以可得出在输出构造的时候需要构造一个分区器。要么是0的,要么是用户设置的,要么是默认的。
总结2.在输出构造中,有缓冲区的设置。
总结3,以上方法都是OutPut的初始化。
总结4.Map输出的K,V变成K,V,P然后写入到环形缓冲区,内存缓存区80%,然后溢写排序,(先按分区排序,然后再按Key的组排序),然后生成小文件,然后合并,用的归并算法,此时小文件已经是内部有序的,所以使用归并算法,一次io即可。

 

持续更新中。。。。,欢迎大家关注我的公众号LHWorld.

 

 

 

mappr:一个Python程序,该程序解析城市数据和Google位置记录文件(以JSON格式),在航班和火车之间插值数据点,将数据点投影到Mercator地图上,然后将数据逐帧渲染为MPEG-4视频 Mappr 使用的Python脚本,用于渲染在地图上移动的标记视频,以显示您去过的。 入门 安装Python 3 确保下载 。 安装后,请在命令行中验证“ python”和“ pip”是否都可用。 您可以通过输入“哪个点”来执行此操作,以查看终端机是否返回有效的系统路径。 克隆存储库 在您选择的终端中的终端中输入此命令,以在其中复制Mappr项目文件。 git clone https://github.com/actuallyaswin/mappr.git 安装先决条件 进入Mappr目录后,在终端中运行以下命令。 pip install -r requirements.txt 除底图外,所有Python依赖项都应安装。 安装底图 从“下载最新的源代码zip。 解压缩归档文件,然后将终端导航到“ basemap-xxx”文件夹内的“ geos-xxx”文件夹。 您需要通过在C语 立即下载

相关推荐

RK3576+IMX415 MIPI摄像头零拷贝显示系统

MIPI CSI-2是嵌入式视觉系统中主流的高速图像传感器接口标准,其核心价值在于低延迟、高带宽与硬件级DMA直通能力。基于V4L2子系统与DRM/KMS驱动栈,可构建从传感器RAW数据到帧缓冲区的零拷贝通路,显著降低CPU负载并提升实时性。该技术广泛应用于工业检测、边缘AI推理前数据接入及多路同步采集等场景。本文以Rockchip RK3576 SoC和索尼IMX415传感器为典型组合,详解MIPI物理层适配、内核驱动集成、GStreamer零拷贝管道搭建及systemd服务化部署,覆盖从硬件信号完整性到

weixin_36047538的博客 217

Hadoop整个MR的过程源码解析(二)-map端任务的执行-map输出的过程源码解析

接着上文所说的map的输入以及通过调用读取器的nextKeyValue判断是否还有下一条数据,读取数据,重新赋值偏移量,以及给key赋值偏移量pos(当前行相对于整个文件的一个位置),value(当前行的数据),完成了map阶段的输入以及重新定义,接下来该聊的就是map的输出阶段,该阶段是比较复杂的,分为两个分支;第一分支是没有reduce的阶段,在日常的MR的过程中最简单的优化手段就是在尽量的避...

Galaxy_songypd的博客 713

deepfake detection数据集

最全Deepfake数据集总结,包含各个数据集下载链接: https://github.com/deepfakeinthewild/deepfake_in_the_wild Dataset name Download Generate method Deepfake videos Actors Deepfake-TIMIT low download De...

where_is_horse的博客 1万+

MapReduce的详细过程

前面的话 MapReduce作为Hadoop的编程框架,是工程师最常接触的部分,也是除去了网络环境和集群配 置之外对整个Job执行效率影响很大的部分,所以很有必要深入了解整个过程。本文写作的目的在于使得读者对整个MapReduce过程有比较细致的了解,当自己需要定制MapReduce行为时,知道该重写 哪些类和方法。在写作时,我贴了部分认为重要的源码和接口,并跟着自己的理解,对于某些内容,结

Full in love with code 861

基于任务的后勤智能体:三段构建与演进设计探究

这是系统智能化的核心难点。例如,对于一个“加强连级滩头阵地防御”子任务,系统会根据防御时长、预期敌军攻击强度、地形等因素,计算出所需的弹药(不同弹种的具体数量)、构筑工事的器材、人员的给养和饮水量、以及医疗救护的药品和血包数量。首先进行分词、词性标注等基础处理,然后利用在军事语料库上训练的命名实体识别(NER)模型,提取出关键实体,如任务类型(“夺控作战”)、作战对象(“Y岛”)、时间约束(“D日H时”、“24小时内”)、成功标准(“建立稳固滩头阵地”)、保障重点(“弹药充足”、“及时救治”)等。

weixin_49042442的博客 1088

运放电路实战:5分钟搞定加法器与减法器的电路设计与调试(附避坑指南)

本文从实战角度出发,详细讲解了运算放大器加法器与减法器的电路设计与调试方法。针对加法器,重点分析了利用“虚地”特性简化设计和选型要点;对于减法器,则深入剖析了决定精度的核心——电阻匹配问题,并提供了使用电阻网络等提升共模抑制比的实用策略。文章还分享了从仿真到实物焊接的完整流程与常见避坑技巧,帮助电子爱好者快速掌握这两种基础运放电路。

weixin_28323057的博客 470

hadoop中的Partitioner分区

hadoop的map/reduce中支持对key进行分区,从而让map出来的数据均匀分布在reduce上,当然,有时候由于机器间配置问题,可能不需要数据均匀,这时候也能派上用场。 框架自带了一个默认的分区类,HashPartitioner,先看看这个类,就知道怎么自定义key分区了。 public class HashPartitioner extends Partitioner { ...

Aronlulu的专栏 488

52、切换线性动态系统:原理、挑战与高斯和滤波解决方案

本文介绍了切换线性动态系统(SLDS)的基本原理及其在复杂时间序列建模中的应用。SLDS结合了隐马尔可夫模型的离散状态切换与线性动态系统的连续状态演化,适用于系统动态发生跳跃的场景,如化工过程监测和金融市场分析。由于精确推理在计算上不可行,文章重点阐述了高斯和滤波这一近似方法,通过有限高斯混合来逼近后验分布,并详细描述了其递归更新、权重计算与组件合并流程。同时讨论了性能评估、优化策略及常见问题的解决方案,并展望了SLDS与深度学习、在线学习和多模态融合的未来发展方向。

algae的博客 161

hadoop培训笔记

# hadoop前言# Hadoop试验集群的部署结构# 系统和组建的依赖关系 # 生产环境的部署结构# Day1 搭建伪分布实验环境# 准备软件# vmare 9.0.2# 操作系统 CentOS 6.4# jdk-6u45-linux-i586.bin# hadoop-1.1.2.tar.gz# 开始搭建环境一 (基础环境)# 在虚拟机上装好 CentOS 6.4# VM的网络连接方式选择...

zhengun的专栏 1392

【华为OD机试真题】3、 路灯照明问题 | 机试真题+思路参考+代码解析(C++、Java、Py、C语言、JS)

题目描述 >在一条笔直的公路上安装了N个路灯,从位置0开始安装,路灯之间间距固定为100米。 每个路灯都有自己的照明半径,请计算第一个路灯和最后一个路灯之间,无法照明的区间的长度和。

KJ.JK 1万+

Agent驱动电商运营:从选品到售后的全链路革新

在当今竞争激烈的电商市场中,传统的电商运营模式面临着诸多挑战。从选品到售后,每个环节都需要大量的人力投入和专业知识。选品需要深入了解市场趋势和消费者需求,营销需要精准定位目标用户,客服需要24小时响应用户咨询。这些工作不仅耗时耗力,而且容易受到人为因素的影响,导致效率低下和成本高企。AI Agent是一种能够感知环境、做出决策并采取行动的智能系统。感知能力:能够获取和处理环境信息。决策能力:能够根据感知到的信息做出决策。行动能力:能够执行决策,对环境产生影响。学习能力。

AI 领航者的博客 356

Hadoop源代码分析(完整图文版) part 1

Hadoop源代码分析(一) 关键字: 分布式 云计算  Google的核心竞争技术是它的计算平台。Google的大牛们用了下面5篇文章,介绍了它们的计算设施。  GoogleCluster: http://research.google.com/archive/googlecluster.html  Chubby:http://labs.google.com/papers/chubb

集成显卡的开源主页 https://github.com/0604hx 1万+

Langchain cannot connect with Azure SQL Database

Langchain 无法连接到 Azure SQL 数据库

suiusoar 634

Hadoop常见错误及解决办法汇总

Hadoop常见错误及解决办法汇总   1,错误一:java.io.IOException: Incompatible clusterIDs 时常出现在namenode重新格式化之后9 `7 k# I: L2 |9 U* @6 d 2014-04-29 14:32:53,877 FATAL org.apache.hadoop.hdfs.server.datanode.DataNode:

大讲台内测员的博客 1948

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

局部高阶图聚类

KDD 2017 Research Paper                  KDD’17, August 13–17, 2017,Halifax, NS, Canada Local Higher-Order Graph Clustering 局部高阶图聚类 Hao Yin  Stanford University  yinh@stanford.edu AustinR. Benson 

baidu_32142047的博客 3176

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

Hadoop中MapReduce整体源码解析

MapReduce整体源码解析: 前言:本文章分析的源码基于Hadoop 3.1.3,主要是针对MR流程过一遍源码,源码的详细解释只涉及一些重要部分,鉴于水平有限,免不了有些说明不够正确,欢迎各位大佬指正。 废话不多说,开搞! job提交流程: 1. waitForCompletion()提交,进入submit方法,通过connnet方法获取当前job需要执行到本地还是Yarn //1.waitForCompletion后,进入到job.java中,源码1587行 if (state == JobState

sql_python的博客 739

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

MapReduce执行流程源码深度剖析(三)

1. MapTask的工作原理 1.1 runNewMapper private <INKEY,INVALUE,OUTKEY,OUTVALUE> void runNewMapper(final JobConf job, final TaskSplitIndex splitIndex, final TaskUmbilicalProtocol umbilical, TaskReporter

百看不如一RUN 548

从头开始系列(四)--Hadoop篇之Shuffle过程源码剖析

1、Map端Shuffle 2、Reduce端shuffle 本篇文章通过Hadoop2.7.5源码获得。 1、Map端Shuffle 必备条件:idea、一个WordCount的MR程序。 在开始之前,我们注意到,Shuffle是Map端输出——&gt;Reduce端接收过程。在这个过程中我们很容易想到一个问题,那就是,我们该怎么知道Map端输出是在源码哪个部分,我们这样...

weixin_42028303的博客 1847

hadoop中mapreduce源码个人记录

以下主要分析记录map阶段:org.apache.hadoop.mapred.MapTask$MapOutputBuffer public static class MapOutputBuffer<K extends Object, V extends Object> implements MapOutputCollector<K, V>, IndexedSortable { //省略... public void init(MapOutputCollector.Co

cuichunchi的博客 224

hadoop hdfs记录踩到的坑

研究了几天终于将hdfs的java api调用搞通了,其中的艰辛一度让我想要放弃,但最终让我坚持了下来。这几天的经验,不能不说是宝贵的,故记录下来,以防以后遗忘。我用的是版本2.10.0,你要问我为啥选择这个版本,我的回答是我也不知道,只知道官网上的下载列表第一个就是它。 1、下载 wget https://mirror.bit.edu.cn/apache/hadoop/common/hadoop-2.10.0/hadoop-2.10.0.tar.gz 2、安装 我是采用Linux系统来安装的(windo

m0_46455711的博客 5664

Hadoop源代码分析(mapreduce.lib.partition/reduce/output)

Map的结果,会通过partition分发到Reducer上,Reducer做完Reduce操作后,通过OutputFormat,进行输出,下面我们就来分析参与这个过程的类。 Mapper的结果,可能送到可能的Combiner做合并,Combiner在系统中并没有自己的基类,而是用Reducer作为Combiner的基类,他们对外的功能是一样的,只是使用的位置和使用时的上下文不太一样而已。 M

1469

性能调优

目 录 12 性能调优 12.1 配置原则 12.2 Manager 12.2.1 提升Manager配置服务参数的效率 12.2.2 根据集群节点数优化Manager配置 12.3 HBase 12.3.1 提升BulkLoad效率 12.3.2 提升连续put场景性能 12.3.3 Put和Scan性能综合调优 12.3.4 提升实时

liuwei063608的专栏 3837
上一篇: Linux知识--初始linux
下一篇: Hadoop源码篇--Reduce篇
L先生AI课堂
L先生AI课堂 领域专家: 大数据技术领域 领域专家: 大数据技术领域
博客等级 码龄9年 678粉丝 216原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

L先生AI课堂

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值