HDFS源码分析数据块复制监控线程ReplicationMonitor（一）

ReplicationMonitor是HDFS中关于数据块复制的监控线程，它的主要作用就是计算DataNode工作，并将复制请求超时的块重新加入到待调度队列。其定义及作为线程核心的run()方法如下：

1. /**
2. * Periodically calls computeReplicationWork().
3. * 周期性调用computeReplicationWork()方法
4. */
5. private class ReplicationMonitor implements Runnable {
6. @Override
7. public void run() {
8. // 如果namesystem持续运行，while循环一直进行
9. while (namesystem.isRunning()) {
10. try {
11. // Process replication work only when active NN is out of safe mode.
12. if (namesystem.isPopulatingReplQueues()) {
13. // 计算数据节点工作
14. computeDatanodeWork();
15. // 将复制请求超时的块重新加入到待调度队列
16. processPendingReplications();
17. }
18. // 线程休眠replicationRecheckInterval时间
19. Thread.sleep(replicationRecheckInterval);
20. } catch (Throwable t) {
21. if (!namesystem.isRunning()) {
22. LOG.info("Stopping ReplicationMonitor.");
23. if (!(t instanceof InterruptedException)) {
24. LOG.info("ReplicationMonitor received an exception"
25. + " while shutting down.", t);
26. }
27. break;
28. } else if (!checkNSRunning && t instanceof InterruptedException) {
29. LOG.info("Stopping ReplicationMonitor for testing.");
30. break;
31. }
32. LOG.fatal("ReplicationMonitor thread received Runtime exception. ", t);
33. terminate(1, t);
34. }
35. }
36. }
37. }

ReplicationMonitor线程的run()方法运行逻辑比较清晰，如果namesystem持续运行，while循环一直进行，在这个循环内，仅当活跃NN不在安全模式时才会进行复制工作：

1、调用computeDatanodeWork()方法计算数据节点工作；

2、调用processPendingReplications()方法将复制请求超时的块重新加入到待调度队列

3、线程休眠replicationRecheckInterval时间后继续运行。

首先说下这个replicationRecheckInterval，它是名字节点检查新的复制工作的时间间隔，其初始化在BlockManager的构造函数中，代码如下：

1. this.replicationRecheckInterval =
2. conf.getInt(DFSConfigKeys.DFS_NAMENODE_REPLICATION_INTERVAL_KEY,
3. DFSConfigKeys.DFS_NAMENODE_REPLICATION_INTERVAL_DEFAULT) * 1000L;

其取值取参数dfs.namenode.replication.interval，参数未配置的话，默认为3秒。

再来看下计算数据节点工作的computeDatanodeWork()方法，它负责计算块复制、块无效工作可以被调度到数据节点的总数，数据节点将在接下来的心跳中被指派该工作，并返回被调度的复制或移除的块的数目，代码如下：

1. /**
2. * Compute block replication and block invalidation work that can be scheduled
3. * on data-nodes. The datanode will be informed of this work at the next
4. * heartbeat.
5. *
6. * 计算块复制、块无效工作可以被调度到数据节点的总数。数据节点将在接下来的心跳中被指派该工作。
7. * 返回被调度的复制或移除的块的数目
8. *
9. * @return number of blocks scheduled for replication or removal.
10. */
11. int computeDatanodeWork() {
12. // Blocks should not be replicated or removed if in safe mode.
13. // It's OK to check safe mode here w/o holding lock, in the worst
14. // case extra replications will be scheduled, and these will get
15. // fixed up later.
16. / 如果namesystem处于安全模式，直接返回0
17. if (namesystem.isInSafeMode()) {
18. return 0;
19. }
20. // 通过心跳管理器heartbeatManager获取存活数据节点数
21. final int numlive = heartbeatManager.getLiveDatanodeCount();
22. // blocksReplWorkMultiplier为集群每个周期每个DataNode平均待复制的数据块数量，
23. // blocksToProcess为每个周期集群需要复制的数据块数量
24. final int blocksToProcess = numlive
25. * this.blocksReplWorkMultiplier;
26. // blocksInvalidateWorkPct为集群每个周期每个DataNode平均待删除的无效数据块百分比
27. // nodesToProcess为集群每个周期待删除的无效数据块数量
28. final int nodesToProcess = (int) Math.ceil(numlive
29. * this.blocksInvalidateWorkPct);
30. // 计算复制工作量workFound
31. int workFound = this.computeReplicationWork(blocksToProcess);
32. // Update counters
33. // namesystem加写锁
34. namesystem.writeLock();
35. try {
36. // 调用updateState()方法更新相关状态
37. this.updateState();
38. // 将计算得到的复制工作量workFound赋值给被调度复制的数据块数scheduledReplicationBlocksCount
39. this.scheduledReplicationBlocksCount = workFound;
40. } finally {
41. // namesystem释放写锁
42. namesystem.writeUnlock();
43. }
44. // 计算删除无效块工作量，并累加到workFound
45. workFound += this.computeInvalidateWork(nodesToProcess);
46. // 返回总工作量workFound
47. return workFound;
48. }

computeDatanodeWork()方法的处理逻辑大体如下：

1、如果namesystem处于安全模式，直接返回0；

2、通过心跳管理器heartbeatManager获取存活数据节点数numlive；

3、计算每个周期集群需要复制的数据块数量blocksToProcess：存活数据节点数numlive乘以集群每个周期每个DataNode平均待复制的数据块数量blocksReplWorkMultiplier，blocksReplWorkMultiplier取参数dfs.namenode.replication.work.multiplier.per.iteration，参数未配置的话默认为2；

4、计算集群每个周期待删除的无效数据块数量nodesToProcess：存活数据节点数numlive乘以集群每个周期每个DataNode平均待删除的无效数据块百分比blocksInvalidateWorkPct，blocksInvalidateWorkPct取参数dfs.namenode.invalidate.work.pct.per.iteration，参数未配置的话默认为0.32f，计算结果向上取整；

5、调用computeReplicationWork()方法，传入blocksToProcess，计算复制工作量workFound；

6、namesystem加写锁；

7、调用updateState()方法更新相关状态；

8、将计算得到的复制工作量workFound赋值给被调度复制的数据块数scheduledReplicationBlocksCount；

9、namesystem释放写锁；

10、调用computeInvalidateWork()方法，传入nodesToProcess()，计算删除无效块工作量，并累加到workFound；

11、返回总工作量workFound。

下面，我们看下计算复制工作量的computeReplicationWork()方法，代码如下：

1. /**
2. * Scan blocks in {@link #neededReplications} and assign replication
3. * work to data-nodes they belong to.
4. *
5. * The number of process blocks equals either twice the number of live
6. * data-nodes or the number of under-replicated blocks whichever is less.
7. *
8. * @return number of blocks scheduled for replication during this iteration.
9. */
10. int computeReplicationWork(int blocksToProcess) {
11. List<List<Block>> blocksToReplicate = null;
12. // namesystem加写锁
13. namesystem.writeLock();
14. try {
15. // Choose the blocks to be replicated
16. // 通过neededReplications的chooseUnderReplicatedBlocks()方法，
17. // 选取blocksToProcess个待复制的数据块，放入blocksToReplicate列表，
18. // blocksToReplicate是一个数据块列表的列表，外层的位置索引代表数据块复制的优先级
19. blocksToReplicate = neededReplications
20. .chooseUnderReplicatedBlocks(blocksToProcess);
21. } finally {
22. // namesystem释放写锁
23. namesystem.writeUnlock();
24. }
25. // 调用computeReplicationWorkForBlocks()方法，进行实际数据块复制操作，传入待复制数据块列表的列表，位置索引代表复制的优先级
26. return computeReplicationWorkForBlocks(blocksToReplicate);
27. }

computeReplicationWork()方法比较短，逻辑也很清晰，如下：

1、namesystem加写锁；

2、通过neededReplications的chooseUnderReplicatedBlocks()方法，选取blocksToProcess个待复制的数据块，放入blocksToReplicate列表，blocksToReplicate是一个数据块列表的列表，外层的位置索引代表数据块复制的优先级：

关于如何通过neededReplications的chooseUnderReplicatedBlocks()方法选取blocksToProcess个待复制的数据块，请参考《HDFS源码分析之UnderReplicatedBlocks（二）》一文；

3、namesystem释放写锁；

4、调用computeReplicationWorkForBlocks()方法，进行实际数据块复制操作，传入待复制数据块列表的列表，位置索引代表复制的优先级。