Hadoop-MapReduce-源码跟读-MapTask阶段篇

一、源码下载

下面是hadoop官方源码下载地址，我下载的是hadoop-3.2.4，那就一起来看下吧

Index of /dist/hadoop/core

二、Mapper类

我们先看下我们写的map所继承的Mapper类

public class Mapper {

  /**
   * 传递给 Mapper 实现的 Context
   */
  public abstract class Context
    implements MapContext {
  }
  
  /**
   * 在任务开始时调用一次
   */
  protected void setup(Context context
                       ) throws IOException, InterruptedException {
    // NOTHING
  }

  /**
   * 为输入分片的每个键/值对调用一次。我们的WordCount就是覆盖了这一点，
   */
  @SuppressWarnings("unchecked")
  protected void map(KEYIN key, VALUEIN value, 
                     Context context) throws IOException, InterruptedException {
    context.write((KEYOUT) key, (VALUEOUT) value);
  }

  /**
   * 在任务结束时调用一次
   */
  protected void cleanup(Context context
                         ) throws IOException, InterruptedException {
    // NOTHING
  }
  
  /**
   * 专家用户可以覆盖此方法，以便对Mapper的执行进行更完整的控制
   * @param context
   * @throws IOException
   */
  public void run(Context context) throws IOException, InterruptedException {
    setup(context);
    try {
      while (context.nextKeyValue()) {
        map(context.getCurrentKey(), context.getCurrentValue(), context);
      }
    } finally {
      cleanup(context);
    }
  }
}

经过该类的注释我们可以得到以下信息：

1、输入的每个 经过Map后会处理成一组 ，即

2、输入的每个 经过Map后会可以输出 0个、1个、多个

3、Hadoop Map Reduce框架为Job中InputFormat生成的每个InputSplit分配一个MapTask

4、框架首先为InputSplit中的每个 调用setup()，然后调用map()，最后调用cleanup()

5、Map输出的key对应的所有value由框架进行分组，并传递给Reduce

6、用户可以通过RawComparator来控制排序和分组

7、Map输出会根据Reduce进行分区，用户可以通过自定义Partitioner来控制哪些key去哪个Reduce

8、用户可以选择设置CombinaterClass指定组合器来聚合Map输出结果，这样会减少Map到Reduce的传送数据量

9、用户可以通过Configuration指定是否压缩、如何压缩中间输出。

10、如果Job只有Map阶段，那么Map会直接写入OutputFormat，且不会按照key排序

11、用户可以覆盖run()来对Map处理进行更大的干预，例如多线程实现

三、MapTask是如何调起的

在上一篇博客中已经将了YarnChild的启动，而MapTask就是在它里面被调起的，下面我们来看下YarnChild中的代码

public static void main(String[] args) throws Throwable {
    Thread.setDefaultUncaughtExceptionHandler(new YarnUncaughtExceptionHandler());
    LOG.debug("Child starting");

    //根据job的配置文件构建JobConf
    //JobConf是用户描述MapReduce作业到Hadoop框架执行的主要接口。框架试图忠实地执行作业，
    //例如我们在WordCount中的main方法中用Job.set**了很多属性，比如Mapper、Reducer的实现类、输出格式、输入输出目录等等
    final JobConf job = new JobConf(MRJobConfig.JOB_CONF_FILE);
    //使用JobConf初始化可以避免两次加载conf
    Limits.init(job);
    UserGroupInformation.setConfiguration(job);
    //MAPREDUCE-6565: 需要设置SecurityUtil的配置
    SecurityUtil.setConfiguration(job);

    String host = args[0];
    int port = Integer.parseInt(args[1]);
    //创建一个Socket地址
    final InetSocketAddress address =
        NetUtils.createSocketAddrForHost(host, port);
    final TaskAttemptID firstTaskid = TaskAttemptID.forName(args[2]);
    long jvmIdLong = Long.parseLong(args[3]);
    JVMId jvmId = new JVMId(firstTaskid.getJobID(),
        firstTaskid.getTaskType() == TaskType.MAP, jvmIdLong);
    
    CallerContext.setCurrent(
        new CallerContext.Builder("mr_" + firstTaskid.toString()).build());

    //初始化度量系统
    DefaultMetricsSystem.initialize(
        StringUtils.camelize(firstTaskid.getTaskType().name()) +"Task");

    //安全框架已将令牌加载到当前ugi中
    Credentials credentials =
        UserGroupInformation.getCurrentUser().getCredentials();
    LOG.info("Executing with tokens: {}", credentials.getAllTokens());

    //创建TaskUmplicalProtocol作为实际任务所有者
    UserGroupInformation taskOwner =
      UserGroupInformation.createRemoteUser(firstTaskid.getJobID().toString());
    Token jt = TokenCache.getJobToken(credentials);
    SecurityUtil.setTokenService(jt, address);
    taskOwner.addToken(jt);
    final TaskUmbilicalProtocol umbilical =
      taskOwner.doAs(new PrivilegedExceptionAction() {
      @Override
      public TaskUmbilicalProtocol run() throws Exception {
        return (TaskUmbilicalProtocol)RPC.getProxy(TaskUmbilicalProtocol.class,
            TaskUmbilicalProtocol.versionID, address, job);
      }
    });

    //向ApplicationMaster报告non-pid
    JvmContext context = new JvmContext(jvmId, "-1000");
    LOG.debug("PID: " + System.getenv().get("JVM_PID"));
    Task task = null;
    UserGroupInformation childUGI = null;
    ScheduledExecutorService logSyncer = null;

    try {
      int idleLoopCount = 0;
      JvmTask myTask = null;
      //轮询新任务
      for (int idle = 0; null == myTask; ++idle) {
        long sleepTimeMilliSecs = Math.min(idle * 500, 1500);
        LOG.info("Sleeping for " + sleepTimeMilliSecs
            + "ms before retrying again. Got null now.");
        MILLISECONDS.sleep(sleepTimeMilliSecs);
        myTask = umbilical.getTask(context);
      }
      if (myTask.shouldDie()) {
        return;
      }

      task = myTask.getTask();
      YarnChild.taskid = task.getTaskID();

      //创建作业conf并设置凭据
      configureTask(job, task, credentials, jt);

      //记录系统属性
      String systemPropsToLog = MRApps.getSystemPropertiesToLog(job);
      if (systemPropsToLog != null) {
        LOG.info(systemPropsToLog);
      }

      //启动Java VM指标
      JvmMetrics.initSingleton(jvmId.toString(), job.getSessionId());
      childUGI = UserGroupInformation.createRemoteUser(System
          .getenv(ApplicationConstants.Environment.USER.toString()));
      //向新用户添加令牌，使其能够正确执行任务
      childUGI.addCredentials(credentials);

      //如果在调用任务之前进行了配置，请设置作业类加载器
      MRApps.setJobClassLoader(job);

      logSyncer = TaskLog.createLogSyncer();

      //为doAs块创建对任务的最终引用
      final Task taskFinal = task;
      childUGI.doAs(new PrivilegedExceptionAction