前两篇文章简单介绍了hadoop心跳机制的两个重要角色：JT和TT，虽然不是太详细，但是大纸业说清楚了一些事，在JT篇的最后对于JT返回TT的心跳响应中的一些命令一笔带过，这篇文章将重要介绍这些命令：ReinitTrackerAction，KillTaskAction，KillJobAction，CommitTaskAction，LaunchTaskAction。每个命令都对应着一系列行为，所有的行为都是由TT完成。下面分别看看这五个TaskTrackerAction，每个命令从三个部分进行解释：1）命令内容；2）JT下达命令；3）TT处理命令。
1.ReinitTrackerAction
1）命令内容：
该命令指示TT进行重新初始化操作。一般当JT与TT之间状态不一致时，JT就会像TT下达该命令，命令TT进行重新初始化。重新初始化会TT会清空其上的task，以及初始化一些状态信息和参数，最重要的是justInited变量会变成true，表示刚初始化的，这时再次发送心跳时JT接收到的参数initialContact就为true了，表示TT首次联系JT，保证JT和TT之间的状态一致。
该对象内部非常简单，简单到啥也没有。出了一个actionType==ActionType.REINIT_TRACKER（表示重新初始化，共有五种类型，对应五种命令）外啥也没有。
class ReinitTrackerAction extends TaskTrackerAction {
public ReinitTrackerAction() {
super(ActionType.REINIT_TRACKER);
}
public void write(DataOutput out) throws IOException {}
public void readFields(DataInput in) throws IOException {}
}2）JT下达命令：
如上所说JT对TT下达该命令一般是由于两者之间状态不一致导致，具体见下代码（去掉了注释）。
if (initialContact != true) {
if (prevHeartbeatResponse == null) {
if (hasRestarted()) {
addRestartInfo = true;
recoveryManager.unMarkTracker(trackerName);
} else {
LOG.warn("Serious problem, cannot find record of 'previous' " +
"heartbeat for '" + trackerName +
"'; reinitializing the tasktracker");
return new HeartbeatResponse(responseId,
new TaskTrackerAction[] {new ReinitTrackerAction()});
}
} else {
if (prevHeartbeatResponse.getResponseId() != responseId) {
LOG.info("Ignoring 'duplicate' heartbeat from '" +
trackerName + "'; resending the previous 'lost' response");
return prevHeartbeatResponse;
}
}
}当initialContact==false时，且prevHeartbeatResponse==null，prevHeartbeatResponse变量是JT从其保存的心跳记录中取出该TT的上次心跳记录，为null则表示JT没有收到过来自该TT的心跳记录，但是initialContact==false表示TT认为他不是首次联系JT，即JT有接收到过TT的心跳请求，这样JT与TT就产生了状态不一致情况。注释给出了一种可能的解释：This is the first heartbeat from the old tracker to the newly started JobTracker.意思是JT是重新实例化，即JT刚重启过，但是TT未重启，或者重新初始化，即old。出现这种情况时，JT会根据是否有任务需要恢复来判断是否让TT重新初始化。至于为什么要在对TT下达重新初始化命令之前判断是否有任务需要恢复，是因为如果JT检查出有任务需要恢复，那么有可能需要回复的任务在该TT上运行过，那么就需要该TT来恢复该任务，而TT重新初始化之后会丢失所有任务。总之如果JT不需要进行任务恢复则对TT下达重新初始化命令。还有另外一种情况JT也会对TT下达该命令。
if (!processHeartbeat(status, initialContact, now)) {
if (prevHeartbeatResponse != null) {
trackerToHeartbeatResponseMap.remove(trackerName);
}
return new HeartbeatResponse(newResponseId,
new TaskTrackerAction[] {new ReinitTrackerAction()});
}boolean seenBefore = updateTaskTrackerStatus(trackerName,
trackerStatus);
TaskTracker taskTracker = getTaskTracker(trackerName);
if (initialContact) {
// If it's first contact, then clear out
// any state hanging around
if (seenBefore) {
lostTaskTracker(taskTracker);
}
} else {
// If not first contact, there should be some record of the tracker
if (!seenBefore) {
LOG.warn("Status from unknown Tracker : " + trackerName);
updateTaskTrackerStatus(trackerName, null);
return false;
}
}以上就是JT对TT下达重新初始化命令产生的两种情况，归根到底都是由于JT与TT之间状态不一致导致，即TT认为他不是首次联系JT，但是JT却没有TT的以前记录。
3）TT处理命令：
TT发送心跳都是在TT的offerService()方法中调用的，该方法在TT运行过程中一直执行，当TT的心跳请求接收到响应时，会首先对收到的HeartbeatResponse中的TaskTrackerAction进行判断，判断是否有ReinitTrackerAction命令。
TaskTrackerAction[] actions = heartbeatResponse.getActions();
if(LOG.isDebugEnabled()) {
LOG.debug("Got heartbeatResponse from JobTracker with responseId: " +
heartbeatResponse.getResponseId() + " and " +
((actions != null) ? actions.length : 0) + " actions");
}
if (reinitTaskTracker(actions)) {
return State.STALE;
} private boolean reinitTaskTracker(TaskTrackerAction[] actions) {
if (actions != null) {
for (TaskTrackerAction action : actions) {
if (action.getActionId() ==
TaskTrackerAction.ActionType.REINIT_TRACKER) {
LOG.info("Recieved ReinitTrackerAction from JobTracker");
return true;
}
}
}
return false;
}while (running && !staleState && !shuttingDown && !denied) {
try {
State osState = offerService();
if (osState == State.STALE) {
staleState = true;
} else if (osState == State.DENIED) {
denied = true;
}
} catch (Exception ex) {
if (!shuttingDown) {
LOG.info("Lost connection to JobTracker [" +
jobTrackAddr + "]. Retrying...", ex);
try {
Thread.sleep(5000);
} catch (InterruptedException ie) {
}
}
}
}} finally {
// If denied we'll close via shutdown below. We should close
// here even if shuttingDown as shuttingDown can be set even
// if shutdown is not called.
if (!denied) {
close();
}
}
if (shuttingDown) { return; }
if (denied) { break; }
LOG.warn("Reinitializing local state");
initialize();2.KillTaskAction
1）命令内容：
从名字就可以看出该命令是指kill掉task的意思。对象内部同ReinitTrackerAction一样，只不过多存储一个taskId（TaskAttemptID）对象，所以在序列化时会将该变量序列化到流中，以便TT接收到命令时可以准确知道需要kill掉哪个TaskAttempt。
2）JT下达命令：
JT通过调用getTasksToKill()方法，获取该TT上所有需要kill的task，下面看看该方法如何获取需要kill掉的task。
private synchronized List<TaskTrackerAction> getTasksToKill(
String taskTracker) {
Set<TaskAttemptID> taskIds = trackerToTaskMap.get(taskTracker);
List<TaskTrackerAction> killList = new ArrayList<TaskTrackerAction>();
if (taskIds != null) {
for (TaskAttemptID killTaskId : taskIds) {
TaskInProgress tip = taskidToTIPMap.get(killTaskId);
if (tip == null) {
continue;
}
if (tip.shouldClose(killTaskId)) {
//
// This is how the JobTracker ends a task at the TaskTracker.
// It may be successfully completed, or may be killed in
// mid-execution.
//
if (!tip.getJob().isComplete()) {
killList.add(new KillTaskAction(killTaskId));
if (LOG.isDebugEnabled()) {
LOG.debug(taskTracker + " -> KillTaskAction: " + killTaskId);
}
}
}
}
}
// add the stray attempts for uninited jobs
synchronized (trackerToTasksToCleanup) {
Set<TaskAttemptID> set = trackerToTasksToCleanup.remove(taskTracker);
if (set != null) {
for (TaskAttemptID id : set) {
killList.add(new KillTaskAction(id));
}
}
}
return killList;
}public boolean shouldClose(TaskAttemptID taskid) {
boolean close = false;
TaskStatus ts = taskStatuses.get(taskid);
if ((ts != null) &&
(!tasksReportedClosed.contains(taskid)) &&
((this.failed) ||
((job.getStatus().getRunState() != JobStatus.RUNNING &&
(job.getStatus().getRunState() != JobStatus.PREP))))) {
tasksReportedClosed.add(taskid);
close = true;
} else if (isComplete() &&
!(isMapTask() && !jobSetup &&
!jobCleanup && isComplete(taskid)) &&
!tasksReportedClosed.contains(taskid)) {
tasksReportedClosed.add(taskid);
close = true;
} else if (isCommitPending(taskid) && !shouldCommit(taskid) &&
!tasksReportedClosed.contains(taskid)) {
tasksReportedClosed.add(taskid);
close = true;
} else {
close = tasksToKill.keySet().contains(taskid);
}
return close;
}a.满足Task的taskStatuses队列中包含此TaskAttempt，且tasksReportedClosed队列不包含该TaskAttempt对象（tasksReportedClosed中保存所有已被关闭的TaskAttempt，所以tasksReportedClosed中存在该TaskAttempt则表示该TaskAttempt已被关闭，则无需重复关闭），且满足该TaskInProgress对象的failed==true，即该Task已失败，或者Task所属的Job处于SUCCEEDED、FAILED、KILLED三个状态，则表示该TaskAttempt需要被关闭（Close），则返回true，同时将该TaskAttempt对象添加到tasksReportedClosed队列中，以避免下次重复关闭。
b.满足该Task已完成，且该Task不是一个map任务，也不是jobSetup或者jobCleanup任务，且该TaskAttempt是该Task成功的那个TaskAttempt，且tasksReportedClosed不包含该TaskAttempt。这里需要知道一个Task可能会有多个TaskAttempt，这是由于推测执行导致（可以去了解下推测执行），这多个TaskAttempt之中只要有一个完成，则该Task就完成，完成的那一个TaskAttempt会被标记在Task对象中（successfulTaskId参数）。还有一点，即当该任务是map任务时，并不关闭该TaskAttempt，注释给出的解释是：However,
for completed map tasks we do not close the task which actually was the one responsible for _completing_ the TaskInProgress. (不解)
c.满足该TaskAttempt已完成，但是未决定提交，且不是successfulTaskId参数标志的TaskAttempt，且tasksReportedClosed不包含该TaskAttempt。这个条件表示当多个TaskAttempt同时运行时，有一个已完成且成功提交，那么余下的就算成功了的TaskAttempt也会被关闭，因为一个Task只需要一次成功提交即可。
d.该TaskAttempt在tasksToKill队列中。tasksToKill队列存放着由客户端发起的kill命令指定kill的TaskAttempt。比如当我们手动在命令行或者其他地方执行hadoop job -kill时，会kill掉该Job所有的TaskAttempt。
由上判断出TaskAttempt对象需要关闭后，会判断如果该TaskAttempt需要被关闭的原因不是由于其所属的Job已完成，则对其创建一个KillTaskAction对象，并添加到心跳响应结果中。这里由于所属Job完成而需要关闭的TaskAttempt对象，并不作为KillTaskAction命令返回给TT。
下面第二处：
// add the stray attempts for uninited jobs
synchronized (trackerToTasksToCleanup) {
Set<TaskAttemptID> set = trackerToTasksToCleanup.remove(taskTracker);
if (set != null) {
for (TaskAttemptID id : set) {
killList.add(new KillTaskAction(id));
}
}
}以上就是JT如何判断哪些TaskAttempt需要被kill，并通过KillTaskAction向TT下达命令。
3）TT处理命令：
if (actions != null){
for(TaskTrackerAction action: actions) {
if (action instanceof LaunchTaskAction) {
addToTaskQueue((LaunchTaskAction)action);
} else if (action instanceof CommitTaskAction) {
CommitTaskAction commitAction = (CommitTaskAction)action;
if (!commitResponses.contains(commitAction.getTaskID())) {
LOG.info("Received commit task action for " +
commitAction.getTaskID());
commitResponses.add(commitAction.getTaskID());
}
} else {
addActionToCleanup(action);
}
}
}下面看看对KillTaskAction和KillJobAction的处理。
void addActionToCleanup(TaskTrackerAction action) throws InterruptedException {
String actionId = getIdForCleanUpAction(action);
// add the action to the queue only if its not added in the first place
String previousActionId = allCleanupActions.putIfAbsent(actionId, actionId);
if (previousActionId != null) {
return;
} else {
activeCleanupActions.put(action);
}
}if (action instanceof KillJobAction) {
purgeJob((KillJobAction) action);
} else if (action instanceof KillTaskAction) {
processKillTaskAction((KillTaskAction) action);
} else {
LOG.error("Non-delete action given to cleanup thread: " + action);
}3.KillJobAction
1）命令内容：
KillJobAction跟KillTaskAction很相似，只不过KillJobAction是kill job，而KillTaskAction是kill task。所以KillJobAction内部保存一个jobId（JobID）对象。
2）JT下达命令：
同KillJobAction一样，JT通过调用getJobsForCleanup()方法获取该TT上需要kill掉的job信息。
private List<TaskTrackerAction> getJobsForCleanup(String taskTracker) {
Set<JobID> jobs = null;
synchronized (trackerToJobsToCleanup) {
jobs = trackerToJobsToCleanup.remove(taskTracker);
}
if (jobs != null) {
// prepare the actions list
List<TaskTrackerAction> killList = new ArrayList<TaskTrackerAction>();
for (JobID killJobId : jobs) {
killList.add(new KillJobAction(killJobId));
if(LOG.isDebugEnabled()) {
LOG.debug(taskTracker + " -> KillJobAction: " + killJobId);
}
}
return killList;
}
return null;
}3）TT处理命令：
同上KillTaskAction。
4.CommitTaskAction
1）命令内容：
CommitTaskAction是指TT需要提交Task，内部保存一个taskId（TaskAttemptID）对象。
2）JT下达命令：
JT通过调用getTasksToSave()方法获取该TT需要提交的任务信息。
private synchronized List<TaskTrackerAction> getTasksToSave(
TaskTrackerStatus tts) {
List<TaskStatus> taskStatuses = tts.getTaskReports();
if (taskStatuses != null) {
List<TaskTrackerAction> saveList = new ArrayList<TaskTrackerAction>();
for (TaskStatus taskStatus : taskStatuses) {
if (taskStatus.getRunState() == TaskStatus.State.COMMIT_PENDING) {
TaskAttemptID taskId = taskStatus.getTaskID();
TaskInProgress tip = taskidToTIPMap.get(taskId);
if (tip == null) {
continue;
}
if (tip.shouldCommit(taskId)) {
saveList.add(new CommitTaskAction(taskId));
if (LOG.isDebugEnabled()) {
LOG.debug(tts.getTrackerName() +
" -> CommitTaskAction: " + taskId);
}
}
}
}
return saveList;
}
return null;
} public boolean shouldCommit(TaskAttemptID taskid) {
return !isComplete() && isCommitPending(taskid) &&
taskToCommit.equals(taskid);
}3）TT处理命令：
TT将接收到的CommitTaskAction命令存放在commitResponses队列中，该队列的作用是当Task完成时通过RPC请求向TT询问是否可以提交时，TT根据commitResponses队列中是否包含该Task信息来决定是否让Task进行提交操作。具体发生在Task的done()方法中。
5.LaunchTaskAction
1）命令内容：
LaunchTaskAction是五个命令中最复杂的一个，该命令指示TT进行Task的运行，所以涉及到MapReduce中最核心的问题——任务调度，即如何合理的调度各个任务。LaunchTaskAction内部保存了一个task（Task）对象，同时在序列化会先写入task.isMapTask()的值（boolean型），在反序列化时会首先读取isMapTask值。
2）JT下达命令：
List<Task> tasks = getSetupAndCleanupTasks(taskTrackerStatus);
if (tasks == null ) {
tasks = taskScheduler.assignTasks(taskTrackers.get(trackerName));
}
if (tasks != null) {
for (Task task : tasks) {
expireLaunchingTasks.addNewTask(task.getTaskID());
if(LOG.isDebugEnabled()) {
LOG.debug(trackerName + " -> LaunchTask: " + task.getTaskID());
}
actions.add(new LaunchTaskAction(task));
}
}3）TT处理命令：
TT接收到JT的LaunchTaskAction会调用addToTaskQueue()方法，根据Task的类型（Map/Reduce）分别添加到mapLauncher和reduceLauncher对象中。mapLauncher和reduceLauncher对象是以线程模式运行的任务启动器，其在TT初始化过程中实例化并启动。这两个线程会进行Task的启动。
以上就是心跳响应中的五种命令，有错误之处还望指出，谢谢！