HDFS源码分析之DataXceiverServer

DataXceiverServer是Hadoop分布式文件系统HDFS的从节点--数据节点DataNode上的一个后台工作线程，它类似于一个小型的服务器，被用来接收数据读写请求，并为每个请求创建一个工作线程以进行请求的响应。那么，有以下几个问题：

1、DataXceiverServer是什么？

2、DataXceiverServer是如何初始化的？

3、DataXceiverServer是如何工作的？

带着这些问题，本文将带着你进入DataNode的DataXceiverServer世界。

一、DataXceiverServer是什么？

DataXceiverServer是数据节点DataNode上一个用于接收数据读写请求的后台工作线程，为每个数据读写请求创建一个单独的线程去处理。它的成员变量如下：

1. // PeerServer是一个接口，实现了它的TcpPeerServer封装饿了一个ServerSocket，提供了Java Socket服务端的功能
2. private final PeerServer peerServer;
3. // 该DataXceiverServer所属DataNode实例datanode
4. private final DataNode datanode;
5. // Peer所在线程的映射集合peers
6. private final HashMap<Peer, Thread> peers = new HashMap<Peer, Thread>();
7. // Peer与DataXceiver的映射集合peersXceiver
8. private final HashMap<Peer, DataXceiver> peersXceiver = new HashMap<Peer, DataXceiver>();
9. // DataXceiverServer是否已关闭的标志位closed
10. private boolean closed = false;
11. /**
12. * Maximal number of concurrent xceivers per node.
13. * Enforcing the limit is required in order to avoid data-node
14. * running out of memory.
15. *
16. * 每个节点并行的最大DataXceivers数目。
17. * 为了避免dataNode运行内存溢出，执行这个限制是必须的。
18. * 定义是默认值为4096.
19. */
20. int maxXceiverCount =
21. DFSConfigKeys.DFS_DATANODE_MAX_RECEIVER_THREADS_DEFAULT;
22. // 集群数据块平衡节流器balanceThrottler
23. final BlockBalanceThrottler balanceThrottler;
24. /**
25. * We need an estimate for block size to check if the disk partition has
26. * enough space. Newer clients pass the expected block size to the DataNode.
27. * For older clients we just use the server-side default block size.
28. *
29. * 我们需要估计块大小以检测磁盘分区是否有足够的空间。
30. * 新客户端传递预期块大小给DataNode。
31. * 对于旧客户端而言我们仅仅使用服务器端默认的块大小。
32. */
33. final long estimateBlockSize;

其中，PeerServer类型的peerServer，实际上是DataXceiverServer实现功能最重要的一个类，在DataXceiverServer实例构造时，实际上传入的是实现了PeerServer接口的TcpPeerServer类，该类内部封装了一个ServerSocket，提供了Java Socket服务端的功能，用于监听来自客户端或其他DataNode的数据读写请求。

DataXceiverServer内部还存在对于其载体DataNode的实例datanode，这样该线程就能随时获得DataNode状态、提供的一些列服务等；

peers和peersXceiver是DataXceiverServer内部关于peer的两个数据结构，一个是Peer与其所在线程映射集合peers，另一个则是Peer与DataXceiver的映射集合peersXceiver，均是HashMap类型。Peer是什么呢？实际上就是对Socket的封装；

closed为DataXceiverServer是否已关闭的标志位；

maxXceiverCount为每个DataNode节点并行的最大DataXceivers数目，为了避免dataNode运行内存溢出，执行这个限制是必须的；

balanceThrottler是DataXceiverServer内部一个关于集群中数据库平衡的节流器的实现，它实现了对于数据块移动时带宽、数量的控制。

二、DataXceiverServer是如何初始化的？

在数据节点DataNode进程启动的startDataNode()方法中，会调用initDataXceiver()方法，完成DataXceiverServer的初始化，代码如下：

1. private void initDataXceiver(Configuration conf) throws IOException {
2. // find free port or use privileged port provided
3. // 找一个自由端口或使用已提供的特权端口
4. // 构造TcpPeerServer实例tcpPeerServer，它实现了PeerServer接口，提供了ServerSocket的功能
5. TcpPeerServer tcpPeerServer;
6. if (secureResources != null) {// 如果secureResources存在，根据secureResources创建tcpPeerServer
7. tcpPeerServer = new TcpPeerServer(secureResources);
8. } else {// 否则，根据配置信息创建tcpPeerServer
9. tcpPeerServer = new TcpPeerServer(dnConf.socketWriteTimeout,
10. DataNode.getStreamingAddr(conf));
11. }
12. // 设置数据接收缓冲区大小，默认为128KB
13. tcpPeerServer.setReceiveBufferSize(HdfsConstants.DEFAULT_DATA_SOCKET_SIZE);
14. // 获取Socket地址InetSocketAddress，赋值给DataNode成员变量streamingAddr
15. streamingAddr = tcpPeerServer.getStreamingAddr();
16. LOG.info("Opened streaming server at " + streamingAddr);
17. // 构造名字为dataXceiverServer的线程组threadGroup
18. this.threadGroup = new ThreadGroup("dataXceiverServer");
19. // 构造DataXceiverServer实例xserver，传入tcpPeerServer
20. xserver = new DataXceiverServer(tcpPeerServer, conf, this);
21. // 构造dataXceiverServer守护线程，并将xserver加入线程组threadGroup
22. this.dataXceiverServer = new Daemon(threadGroup, xserver);
23. // 将线程组里的所有线程设置为设置为守护线程，方便虚拟机退出时自动销毁
24. this.threadGroup.setDaemon(true); // auto destroy when empty
25. // 如果系统配置的参数dfs.client.read.shortcircuit为true（默认为false），
26. // 或者配置的参数dfs.client.domain.socket.data.traffic为true（默认为false），
27. //
28. if (conf.getBoolean(DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_KEY,
29. DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_DEFAULT) ||
30. conf.getBoolean(DFSConfigKeys.DFS_CLIENT_DOMAIN_SOCKET_DATA_TRAFFIC,
31. DFSConfigKeys.DFS_CLIENT_DOMAIN_SOCKET_DATA_TRAFFIC_DEFAULT)) {
32. DomainPeerServer domainPeerServer =
33. getDomainPeerServer(conf, streamingAddr.getPort());
34. if (domainPeerServer != null) {
35. this.localDataXceiverServer = new Daemon(threadGroup,
36. new DataXceiverServer(domainPeerServer, conf, this));
37. LOG.info("Listening on UNIX domain socket: " +
38. domainPeerServer.getBindPath());
39. }
40. }
41. // 构造短路注册实例
42. this.shortCircuitRegistry = new ShortCircuitRegistry(conf);
43. }

整个初始化工作很简单：

1、创建构造DataXceiverServer需要的TcpPeerServer实例tcpPeerServer，它内部封装了ServerSocket，是DataXceiverServer功能实现的最主要依托；

2、从tcpPeerServer中获取Socket地址InetSocketAddress，赋值给DataNode成员变量streamingAddr

3、然后构造DataXceiverServer实例xserver，传入tcpPeerServer；

4、构造dataXceiverServer守护线程，并将xserver加入之前创建的线程组threadGroup；

5、将线程组里的所有线程设置为设置为守护线程，方便虚拟机退出时自动销毁。

下面，我们再看下DataXceiverServer的构造方法，代码如下：

1. DataXceiverServer(PeerServer peerServer, Configuration conf,
2. DataNode datanode) {
3. // 根据传入的peerServer设置同名成员变量
4. this.peerServer = peerServer;
5. // 设置DataNode实例datanode
6. this.datanode = datanode;
7. // 设置DataNode中DataXceiver的最大数目maxXceiverCount
8. // 取参数dfs.datanode.max.transfer.threads，参数未配置的话，默认值为4096
9. this.maxXceiverCount =
10. conf.getInt(DFSConfigKeys.DFS_DATANODE_MAX_RECEIVER_THREADS_KEY,
11. DFSConfigKeys.DFS_DATANODE_MAX_RECEIVER_THREADS_DEFAULT);
12. // 设置估计块大小estimateBlockSize
13. // 取参数dfs.blocksize，参数未配置的话，默认值是128*1024*1024，即128M
14. this.estimateBlockSize = conf.getLongBytes(DFSConfigKeys.DFS_BLOCK_SIZE_KEY,
15. DFSConfigKeys.DFS_BLOCK_SIZE_DEFAULT);
16. //set up parameter for cluster balancing
17. // 设置集群平衡节流器
18. // 带宽取参数dfs.datanode.balance.bandwidthPerSec，参数未配置默认为1024*1024
19. // 最大线程数取参数dfs.datanode.balance.max.concurrent.moves，参数未配置默认为5
20. this.balanceThrottler = new BlockBalanceThrottler(
21. conf.getLong(DFSConfigKeys.DFS_DATANODE_BALANCE_BANDWIDTHPERSEC_KEY,
22. DFSConfigKeys.DFS_DATANODE_BALANCE_BANDWIDTHPERSEC_DEFAULT),
23. conf.getInt(DFSConfigKeys.DFS_DATANODE_BALANCE_MAX_NUM_CONCURRENT_MOVES_KEY,
24. DFSConfigKeys.DFS_DATANODE_BALANCE_MAX_NUM_CONCURRENT_MOVES_DEFAULT));
25. }

在构造DataXceiverServer时，会根据传入的peerServer设置同名成员变量、设置DataNode实例datanode等，并初始化两个重要的指标，第一个是设置DataNode中DataXceiver的最大数目maxXceiverCount，它取参数dfs.datanode.max.transfer.threads，参数未配置的话，默认值为4096；第二个便是设置估计块大小estimateBlockSize，它取参数取参数dfs.blocksize，参数未配置的话，默认值是128*1024*1024，即128M，最后，设置集群平衡节流器，带宽取参数dfs.datanode.balance.bandwidthPerSec，参数未配置默认为1024*1024，最大线程数取参数dfs.datanode.balance.max.concurrent.moves，参数未配置默认为5。

三、DataXceiverServer是如何工作的？

既然是一个线程，那么它的工作主要就体现在run()方法内，下面，我们来看下它的run()方法：

1. @Override
2. // 核心方法
3. public void run() {
4. Peer peer = null;
5. while (datanode.shouldRun && !datanode.shutdownForUpgrade) {// 如果标志位shouldRun为true，且没有为升级而执行shutdown
6. try {
7. // 阻塞，直到接收到客户端或者其他DataNode的连接请求
8. peer = peerServer.accept();
9. // Make sure the xceiver count is not exceeded
10. // 确保DataXceiver数目没有超过最大限制
11. /**
12. * DataNode的getXceiverCount方法计算得到，返回线程组的活跃线程数目
13. * threadGroup == null ? 0 : threadGroup.activeCount();
14. */
15. int curXceiverCount = datanode.getXceiverCount();
16. if (curXceiverCount > maxXceiverCount) {
17. throw new IOException("Xceiver count " + curXceiverCount
18. + " exceeds the limit of concurrent xcievers: "
19. + maxXceiverCount);
20. }
21. // 创建一个后台线程，DataXceiver，并加入到线程组datanode.threadGroup
22. new Daemon(datanode.threadGroup,
23. DataXceiver.create(peer, datanode, this))
24. .start();
25. } catch (SocketTimeoutException ignored) {
26. // wake up to see if should continue to run
27. // 等待唤醒看看是否能够继续运行
28. } catch (AsynchronousCloseException ace) {// 异步的关闭异常
29. // another thread closed our listener socket - that's expected during shutdown,
30. // but not in other circumstances
31. // 正如我们所预料的，只有在关机的过程中，通过其他线程关闭我们的侦听套接字，其他情况下则不会发生
32. if (datanode.shouldRun && !datanode.shutdownForUpgrade) {
33. LOG.warn(datanode.getDisplayName() + ":DataXceiverServer: ", ace);
34. }
35. } catch (IOException ie) {
36. IOUtils.cleanup(null, peer);
37. LOG.warn(datanode.getDisplayName() + ":DataXceiverServer: ", ie);
38. } catch (OutOfMemoryError ie) {
39. IOUtils.cleanup(null, peer);
40. // DataNode can run out of memory if there is too many transfers.
41. // Log the event, Sleep for 30 seconds, other transfers may complete by
42. // then.
43. // 数据节点可能由于存在太多的数据传输导致内存溢出，记录该事件，并等待30秒，其他的数据传输可能到时就完成了
44. LOG.warn("DataNode is out of memory. Will retry in 30 seconds.", ie);
45. try {
46. Thread.sleep(30 * 1000);
47. } catch (InterruptedException e) {
48. // ignore
49. }
50. } catch (Throwable te) {
51. LOG.error(datanode.getDisplayName()
52. + ":DataXceiverServer: Exiting due to: ", te);
53. datanode.shouldRun = false;
54. }
55. }
56. // Close the server to stop reception of more requests.
57. // 关闭服务器停止接收更多请求
58. try {
59. peerServer.close();
60. closed = true;
61. } catch (IOException ie) {
62. LOG.warn(datanode.getDisplayName()
63. + " :DataXceiverServer: close exception", ie);
64. }
65. // if in restart prep stage, notify peers before closing them.
66. // 如果在重新启动前准备阶段，在关闭前通知peers
67. if (datanode.shutdownForUpgrade) {
68. restartNotifyPeers();
69. // Each thread needs some time to process it. If a thread needs
70. // to send an OOB message to the client, but blocked on network for
71. // long time, we need to force its termination.
72. LOG.info("Shutting down DataXceiverServer before restart");
73. // Allow roughly up to 2 seconds.
74. for (int i = 0; getNumPeers() > 0 && i < 10; i++) {
75. try {
76. Thread.sleep(200);
77. } catch (InterruptedException e) {
78. // ignore
79. }
80. }
81. }
82. // Close all peers.
83. // 关闭所有的peers
84. closeAllPeers();
85. }

通过run()方法我们得知，当datanode正常运转的时候，DataXceiverServer线程主要负责在一个while循环中利用TcpPeerServer（也就是ServerSocket）的accept()方法阻塞，直到接收到客户端或者其他DataNode的连接请求，然后：

1、获得peer，即Socket的封装；

2、判断当前DataNode上DataXceiver线程数量是否超过阈值，如果超过的话，直接抛出IOException，利用IOUtils的cleanup()方法关闭peer后继续循环，否则继续3；

3、创建一个后台线程DataXceiver，并将其加入到datanode的线程组threadGroup中，并启动该线程，响应数据读写请求；

上面主流程还是非常简单的。我们先看下accept()方法在TcpPeerServer中的实现：

1. @Override
2. public Peer accept() throws IOException, SocketTimeoutException {
3. Peer peer = peerFromSocket(serverSocket.accept());
4. return peer;
5. }

它是通过调用peerFromSocket()方法来实现的，方法的入参是一个Socket，通过ServerSocket类型的serverSocket的accept()方法获得。peerFromSocket()方法代码如下：

1. public static Peer peerFromSocket(Socket socket)
2. throws IOException {
3. Peer peer = null;
4. boolean success = false;
5. try {
6. // TCP_NODELAY is crucial here because of bad interactions between
7. // Nagle's Algorithm and Delayed ACKs. With connection keepalive
8. // between the client and DN, the conversation looks like:
9. //   1. Client -> DN: Read block X
10. //   2. DN -> Client: data for block X
11. //   3. Client -> DN: Status OK (successful read)
12. //   4. Client -> DN: Read block Y
13. // The fact that step #3 and #4 are both in the client->DN direction
14. // triggers Nagling. If the DN is using delayed ACKs, this results
15. // in a delay of 40ms or more.
16. //
17. // TCP_NODELAY disables nagling and thus avoids this performance
18. // disaster.
19. // 设置TCP无延迟
20. socket.setTcpNoDelay(true);
21. // 获得SocketChannel
22. SocketChannel channel = socket.getChannel();
23. // 利用socket创建peer，如果通道channel为null，则创建基本的BasicInetPeer，否则创建NioInetPeer
24. if (channel == null) {
25. peer = new BasicInetPeer(socket);
26. } else {
27. peer = new NioInetPeer(socket);
28. }
29. // 标志位success设置为true
30. success = true;
31. return peer;
32. } finally {
33. if (!success) {// 如果创建不成功，peer不为空的话，关闭之
34. if (peer != null) peer.close();
35. // 关闭socket
36. socket.close();
37. }
38. }
39. }

其中，Peer是对Socket、输入输出流等的封装，有BasicInetPeer和NioInetPeer两种。BasicInetPeer代表了基本的Peer，封装了Socket、OutputStream、InputStream三者；而NioInetPeer代表了一种我们可通过使用非阻塞IO进行Socket通讯的一种Peer，封装了Socket、SocketInputStream、SocketOutputStream三者，具体代码不再列举，读者可自行查阅。

紧接着，我们说下对于异常的处理。整个过程中一共出现了5种异常，包括对它们的处理如下所示：

1、SocketTimeoutException：Socket连接超时异常，忽略直接进入下一个循环即可，继续阻塞侦听请求；

2、AsynchronousCloseException：异步关闭异常，这里我们需要通过判断DataNode的状态来决定是否继续进行循环，继续阻塞侦听请求；

3、IOException：此时，对应于上述主流程的第2步，我们需要关闭Socket后进入下一个循环，继续阻塞侦听请求；

4、OutOfMemoryError：内存溢出错误，这种情况下数据节点可能由于存在太多的数据传输导致内存溢出，记录该事件，并等待30秒，其他的数据传输可能到时就完成了。我们需要做的就是，首先需要利用IOUtils的cleanup()方法关闭peer，记录警告日志信息，然后线程休眠30秒，等待DataNode其他数据读写服务完成后，进入下一个循环，继续阻塞侦听请求；

5、Throwable：无话可说，DataNode就是为提高数据存储、读写服务而生的，既然出现了Throwable，那么DataNode也应该停止了，记录error日志信息，设置datanode的shouldRun为false，退出循环。

从上面的异常可以看出，DataNode中DataXceiverServer的设计是很严谨与合理的，DataNode能够提供大吞吐量的数据读写服务与此不无关系。

当Throwable发生，退出循环后，我们就需要做一些列的关闭操作，关闭peerServer，设置DataXceiverServer标志位closed为true，关闭所有的peers等。其中关闭所有的peers的closeAllPeers()方法如下：

1. // Close all peers and clear the map.
2. synchronized void closeAllPeers() {
3. // 记录info日志信息
4. LOG.info("Closing all peers.");
5. // 循环关闭所有的peer
6. for (Peer p : peers.keySet()) {
7. IOUtils.cleanup(LOG, p);
8. }
9. // 清空peer数据集合
10. peers.clear();
11. peersXceiver.clear();
12. }

代码非常简单，不再赘述。

并且，如果在重新启动前准备阶段，在关闭peers之前，需要先通知它们，通知的方式就是通过调用restartNotifyPeers()方法，获取peers的每个peer所在线程，通过interrupt()方法打断它们，代码如下：

1. // Notify all peers of the shutdown and restart.
2. // datanode.shouldRun should still be true and datanode.restarting should
3. // be set true before calling this method.
4. synchronized void restartNotifyPeers() {
5. assert (datanode.shouldRun == true && datanode.shutdownForUpgrade);
6. for (Peer p : peers.keySet()) {
7. // interrupt each and every DataXceiver thread.
8. // 中断每个DataXceiver线程
9. peers.get(p).interrupt();
10. }
11. }

并且，每个线程需要一些时间去完成自己。如果一个线程需要发送OOB至客户端，但是在网络上被阻塞的了一段时间，我们需要强迫使其停止。此时，我们需要大约2秒的时间等待它们的完成。

另外，这里我们需要说下集群数据块平衡节流器balanceThrottler的实现，其成员变量、构造方法代码如下：

1. /** A manager to make sure that cluster balancing does not
2. * take too much resources.
3. *
4. * It limits the number of block moves for balancing and
5. * the total amount of bandwidth they can use.
6. *
7. * 确保集群平衡不占用太多资源的一种手段或管理者。
8. * 它限制了为集群平衡所做的块移动的数量及它们所占用的总宽带，是一种节流器的概念。
9. */
10. static class BlockBalanceThrottler extends DataTransferThrottler {
11. private int numThreads;// 表示当前移动数据块的线程数numThreads
12. private int maxThreads;// 表示移动数据块的最大线程数maxThreads
13. /**Constructor
14. * 构造方法
15. * @param bandwidth Total amount of bandwidth can be used for balancing
16. */
17. private BlockBalanceThrottler(long bandwidth, int maxThreads) {
18. super(bandwidth);
19. // 设置移动数据块的最大线程数maxThreads
20. this.maxThreads = maxThreads;
21. LOG.info("Balancing bandwith is "+ bandwidth + " bytes/s");
22. LOG.info("Number threads for balancing is "+ maxThreads);
23. }
24. }

可以看到，它内部有三个非常重要的指标，表示当前移动数据块的线程数的numThreads， 和表示移动数据块的最大线程数maxThreads，还有数据传输的带宽bandwidth。在其构造方法内，会调用父类的构造方法设置带宽bandwidth，并在子类中设置移动数据块的最大线程数maxThreads。那么它是如何实现集群内数据库移动节流控制的呢？答案就在方法acquire()中，代码如下：

1. /** Check if the block move can start.
2. * 检测block移动是否可以开始
3. *
4. * Return true if the thread quota is not exceeded and
5. * the counter is incremented; False otherwise.
6. */
7. synchronized boolean acquire() {
8. / 当前线程数numThreads大于等于最大线程数maxThreads时，返回false，block不可以移动
9. if (numThreads >= maxThreads) {
10. return false;
11. }
12. // 否则，当前线程数numThreads累加，并返回true，block可以移动
13. numThreads++;
14. return true;
15. }

在移动数据块block之前，会调用acquire()方法，确认一个数据块是否可以移动。实际上是当前线程数numThreads大于等于最大线程数maxThreads时，返回false，block不可以移动；否则，当前线程数numThreads累加，并返回true，block可以移动。就是这么简单，而当数据块移动完毕后，则调用release()方法，标志移动已完成，线程计数器减一，代码如下：

1. /** Mark that the move is completed. The thread counter is decremented. */
2. // 标志移动已完成，线程计数器减一
3. synchronized void release() {
4. / 当前线程数numThreads减1
5. numThreads--;
6. }

另外，DataXceiverServer中还提供了一些功能性方法，比如：

1、实现了杀死DataXceiverServer线程的kill()方法，代码如下：

1. void kill() {
2. // DataXceiverServer线程被kill时，需要确定datanode的标志位shouldRun为false，或者标志位shutdownForUpgradetrue
3. // 也就意味着，当datanode不应该继续运行，或者为了升级而关闭时，DataXceiverServer线程才可以被kill
4. assert (datanode.shouldRun == false || datanode.shutdownForUpgrade) :
5. "shoudRun should be set to false or restarting should be true"
6. + " before killing";
7. try {
8. // 关闭peerServer，即关闭ServerSocket
9. this.peerServer.close();
10. // 设置标志位closed为true
11. this.closed = true;
12. } catch (IOException ie) {
13. LOG.warn(datanode.getDisplayName() + ":DataXceiverServer.kill(): ", ie);
14. }
15. }

2、添加一个Peer的addPeer()方法，代码如下：

1. synchronized void addPeer(Peer peer, Thread t, DataXceiver xceiver)
2. throws IOException {
3. // 首先判断DataXceiverServer线程的标志位closed，为true时，说明服务线程已被关闭，不能再提供Socket通讯服务
4. if (closed) {
5. throw new IOException("Server closed.");
6. }
7. // 将peer与其所在线程t的映射关系加入到peers中
8. peers.put(peer, t);
9. // 将peer与其所属DataXceiver xceiver映射关系加入到peersXceiver中
10. peersXceiver.put(peer, xceiver);
11. }

3、关闭一个Peer的closePeer()方法，代码如下：

1. // 关闭Peer
2. synchronized void closePeer(Peer peer) {
3. // 从数据结构peers、peersXceiver移除peer对应记录
4. peers.remove(peer);
5. peersXceiver.remove(peer);
6. // 利用IOUtils的cleanup关闭peer，即关闭socket
7. IOUtils.cleanup(null, peer);
8. }

4、关闭所有Peer的closeAllPeers()方法，代码如下：

1. // Close all peers and clear the map.
2. synchronized void closeAllPeers() {
3. // 记录info日志信息
4. LOG.info("Closing all peers.");
5. // 利用IOUtils的cleanup()方法循环关闭所有的peer，即关闭socket
6. for (Peer p : peers.keySet()) {
7. IOUtils.cleanup(LOG, p);
8. }
9. // 清空peer数据集合peers、peersXceiver
10. peers.clear();
11. peersXceiver.clear();
12. }

上述代码非常简单，并且注释详细，读者可自行阅读与分析，这里不再做详细介绍。

部分未叙述细节放至DataXceiver的分析文章中去讲，敬请留意！

总结

DataXceiverServer是数据节点DataNode上一个用于接收数据读写请求的后台工作线程，为每个数据读写请求创建一个单独的线程去处理。它提供了一请求一线程的模式，并对线程数目做了控制，对接收数据读写请求时发生的各种异常做了很好的容错处理，特别是针对内存溢出异常，允许等待短暂时间再继续提供服务，避免内存使用高峰期等等。而且，线程组与后台线程的应用，也大大简化可这些线程的管理工作；对数据读写请求处理线程的数目，集群内数据块移动线程数目都做了严格控制，避免资源无节制耗费等。这些设计很好的支撑了HDFS大吞吐量数据的性能要求，可以说，是一个很好的设计方案，值得我们在其他类似需求的系统中借鉴。