HDFS源码分析之UnderReplicatedBlocks（二）

UnderReplicatedBlocks还提供了一个数据块迭代器BlockIterator，用于遍历其中的数据块。它是UnderReplicatedBlocks的内部类，有三个成员变量，如下：

1. // 当前迭代级别
2. private int level;
3. // 标志位：是否为特定复制优先级的迭代器
4. private boolean isIteratorForLevel = false;
5. // 数据块Block迭代器Iterator列表，存储各级别数据块迭代器
6. private final List<Iterator<Block>> iterators = new ArrayList<Iterator<Block>>();

其中，level代表了迭代器当前处于的迭代级别，表示正在哪个块复制级别迭代数据块；isIteratorForLevel是一个标志位，是否为特定复制优先级的迭代器的标志位，也就意味着只在特定级别进行迭代；而iterators则是一个数据块Block迭代器Iterator列表，由前往后、由高到低的存储各级别数据块迭代器。
        BlockIterator提供了两个构造函数，一个是无参构造函数：生成所有级别的数据块迭代器，另外一个是有参构造函数：生成指定级别的数据块迭代器，代码分别如下：

1. /**
2. * Construct an iterator over all queues.
3. * 无参构造函数：生成所有级别的数据块迭代器
4. */
5. private BlockIterator() {
6. // 当前迭代级别level设置为0
7. level=0;
8. // iterators中添加全部级别的数据块迭代器
9. for(int i=0; i<LEVEL; i++) {
10. iterators.add(priorityQueues.get(i).iterator());
11. }
12. }
13. /**
14. * Constrict an iterator for a single queue level
15. * 有参构造函数：生成指定级别的数据块迭代器
16. * @param l the priority level to iterate over
17. */
18. private BlockIterator(int l) {
19. // 当前迭代级别level设置为指定级别
20. level = l;
21. // 标志位：是否为特定复制优先级的迭代器设置为true
22. isIteratorForLevel = true;
23. // iterators中添加指定级别的数据块迭代器
24. iterators.add(priorityQueues.get(level).iterator());
25. }

注释很清晰，读者可自行阅读。另外，数据块是根据复制级别由高到低的顺序迭代的，当某一级别数据块迭代完毕，那么我们需要更新当前迭代级别，此时update()方法就完成这一个工作，代码如下：

1. // 如果需要，更新当前迭代级别（由高往低迭代）
2. private void update() {
3. // 标志位：是否为特定复制优先级的迭代器，为true的话，直接返回
4. if (isIteratorForLevel) {
5. return;
6. }
7. // 当前迭代级别小于LEVEL-1（也就是还没到最低级别），并且当前迭代级别已遍历所有数据块
8. while(level< LEVEL-1 && !iterators.get(level).hasNext()) {
9. // 当前迭代级别level加1
10. level++;
11. }
12. }

它会先判断标志位isIteratorForLevel：是否为特定复制优先级的迭代器，为true的话，直接返回；否则当当前迭代级别小于LEVEL-1（也就是还没到最低级别），并且当前迭代级别已遍历所有数据块，当前迭代级别level加1。

既然是一个迭代器，那么我们看下它最重要的两个方法，hasNext()和next()，分别如下：

hasNext()：判断是否还存在未迭代元素

1. // 判断是否还有下一个元素
2. @Override
3. public boolean hasNext() {
4. // 标志位：是否为特定复制优先级的迭代器，为true的话，直接返回iterators列表中第一个迭代器的判断下一个元素的结果
5. if (isIteratorForLevel) {
6. return iterators.get(0).hasNext();
7. }
8. // 如果需要，更新当前迭代级别（由高往低迭代）
9. update();
10. // 取当前级别的迭代器的判断是否存在下一个元素的结果
11. return iterators.get(level).hasNext();
12. }

hasNext()方法，也是先判断标志位isIteratorForLevel：是否为特定复制优先级的迭代器，为true的话，直接返回iterators列表中第一个迭代器的判断下一个元素的结果，否则，如果需要，调用update()方法更新当前迭代级别（由高往低迭代），取当前级别的迭代器的判断是否存在下一个元素的结果。

next()方法：跌倒下一个元素

1. // 取下一个元素
2. @Override
3. public Block next() {
4. // 标志位：是否为特定复制优先级的迭代器，为true的话，直接返回iterators列表中第一个迭代器的下一个元素
5. if (isIteratorForLevel) {
6. return iterators.get(0).next();
7. }
8. // 如果需要，更新当前迭代级别（由高往低迭代）
9. update();
10. // 取当前级别的迭代器的下一个元素
11. return iterators.get(level).next();
12. }

处理逻辑与hasNext()方法一致，不再赘述。

BlockIterator还提供了从迭代器中移除元素remove()方法及获取当前迭代级别的getPriority()方法，代码分别如下：

1. // 移除
2. @Override
3. public void remove() {
4. // 标志位：是否为特定复制优先级的迭代器，为true的话，直接返回iterators列表中第一个迭代器的移除结果
5. if (isIteratorForLevel) {
6. iterators.get(0).remove();
7. } else {
8. // 取当前级别的迭代器的移除的结果
9. iterators.get(level).remove();
10. }
11. }
12. // 获取当前迭代级别
13. int getPriority() {
14. return level;
15. }

UnderReplicatedBlocks还提供了按照优先级由高到低的顺序，获取指定数目的待复制数据块的chooseUnderReplicatedBlocks()方法，代码如下：

1. /**
2. * Get a list of block lists to be replicated. The index of block lists
3. * represents its replication priority. Replication index will be tracked for
4. * each priority list separately in priorityToReplIdx map. Iterates through
5. * all priority lists and find the elements after replication index. Once the
6. * last priority lists reaches to end, all replication indexes will be set to
7. * 0 and start from 1st priority list to fulfill the blockToProces count.
8. *
9. * @param blocksToProcess - number of blocks to fetch from underReplicated blocks.
10. * @return Return a list of block lists to be replicated. The block list index
11. *         represents its replication priority.
12. */
13. public synchronized List<List<Block>> chooseUnderReplicatedBlocks(
14. int blocksToProcess) {
15. // initialize data structure for the return value
16. // 初始化做为返回值的数据结构，LEVEL大小的一个块列表的列表
17. List<List<Block>> blocksToReplicate = new ArrayList<List<Block>>(LEVEL);
18. // 每种优先级都添加一个空的数据块ArrayList列表
19. for (int i = 0; i < LEVEL; i++) {
20. blocksToReplicate.add(new ArrayList<Block>());
21. }
22. // 如果不存在需要复制的数据块，直接返回空的列表blocksToReplicate
23. if (size() == 0) { // There are no blocks to collect.
24. return blocksToReplicate;
25. }
26. int blockCount = 0;
27. // 按照优先级从高到低处理
28. for (int priority = 0; priority < LEVEL; priority++) {
29. // Go through all blocks that need replications with current priority.
30. // 构造指定级别priority的数据块迭代器BlockIterator实例neededReplicationsIterator
31. BlockIterator neededReplicationsIterator = iterator(priority);
32. // 根据指定级别priority从priorityToReplIdx中取之前已经处理到的位置索引replIndex
33. Integer replIndex = priorityToReplIdx.get(priority);
34. // skip to the first unprocessed block, which is at replIndex
35. // 利用replIndex，数据块迭代器跳过之前已处理的数据块，指向下一个该处理的正确位置
36. for (int i = 0; i < replIndex && neededReplicationsIterator.hasNext(); i++) {
37. neededReplicationsIterator.next();
38. }
39. // blocksToProcess的值不能超过所有待复制数据块总数
40. blocksToProcess = Math.min(blocksToProcess, size());
41. // 如果已获取到足够的数据块，即blockCount等于blocksToProcess，直接跳出循环
42. if (blockCount == blocksToProcess) {
43. break;  // break if already expected blocks are obtained
44. }
45. // Loop through all remaining blocks in the list.
46. // 通过迭代器neededReplicationsIterator迭代数据块，添加入返回集合blocksToReplicate中，
47. // 并累加索引位置replIndex
48. // 判断条件为当前已取数据块blockCount还未达到要求的blocksToProcess，
49. // 同时数据块迭代器neededReplicationsIterator还有下一个元素
50. while (blockCount < blocksToProcess
51. && neededReplicationsIterator.hasNext()) {
52. // 通过数据块迭代器neededReplicationsIterator取下一个数据块
53. Block block = neededReplicationsIterator.next();
54. // 将数据块添加到优先级priority对应的列表
55. blocksToReplicate.get(priority).add(block);
56. // 累加索引位置replIndex
57. replIndex++;
58. // 累加已获取数据块数目blockCount
59. blockCount++;
60. }
61. // 如果迭代器中已没有元素，且已处理到最高级别，重置位置索引priorityToReplIdx为0，跳出循环
62. if (!neededReplicationsIterator.hasNext()
63. && neededReplicationsIterator.getPriority() == LEVEL - 1) {
64. // reset all priorities replication index to 0 because there is no
65. // recently added blocks in any list.
66. for (int i = 0; i < LEVEL; i++) {
67. priorityToReplIdx.put(i, 0);
68. }
69. break;
70. }
71. // 记录索引位置replIndex
72. priorityToReplIdx.put(priority, replIndex);
73. }
74. // 返回获取到的数据块列表
75. return blocksToReplicate;
76. }

其处理逻辑大体如下：

1、初始化做为返回值的数据结构，LEVEL大小的一个块列表的列表blocksToReplicate；

2、每种优先级都添加一个空的数据块ArrayList列表；

3、如果不存在需要复制的数据块，直接返回空的列表blocksToReplicate；

4、按照优先级从高到低处理：

4.1、构造指定级别priority的数据块迭代器BlockIterator实例neededReplicationsIterator；

4.2、根据指定级别priority从priorityToReplIdx中取之前已经处理到的位置索引replIndex；

4.3、利用replIndex，数据块迭代器跳过之前已处理的数据块，指向下一个该处理的正确位置；

4.4、blocksToProcess的值不能超过所有待复制数据块总数；

4.5、如果已获取到足够的数据块，即blockCount等于blocksToProcess，直接跳出循环；

4.6、通过迭代器neededReplicationsIterator迭代数据块，添加入返回集合blocksToReplicate中，并累加索引位置replIndex，判断条件为当前已取数据块blockCount还未达到要求的blocksToProcess，同时数据块迭代器neededReplicationsIterator还有下一个元素：

4.6.1、通过数据块迭代器neededReplicationsIterator取下一个数据块；

4.6.2、将数据块添加到优先级priority对应的列表；

4.6.3、累加索引位置replIndex；

4.6.4、累加已获取数据块数目blockCount；

4.7、如果迭代器中已没有元素，且已处理到最高级别，重置位置索引priorityToReplIdx为0，跳出循环；

4.8、priorityToReplIdx中记录优先级priority对应索引位置replIndex；

5、返回获取到的数据块列表。

未完待续，敬请期待《HDFS源码分析之UnderReplicatedBlocks（二）》。