netty源码解解析(4.0)-14 Channel NIO实现:读取数据

　　 本章分析Nio Channel的数据读取功能的实现。

　　Channel读取数据需要Channel和ChannelHandler配合使用，netty设计数据读取功能包括三个要素：Channel, EventLoop和ChannelHandler。Channel有个read方法，这个方法不会直接读取数据，它的作用是通知持有当前channel的eventLoop可以从这个这个channel读取数据了，这个方法被调用之后eventLoop会在channel有数据可读的时候从channel读出数据然后把数据放在channelRead事件中交给ChannelInboundHandler的channelRead方法处理，当eventLoop发现channel中暂时没时间可读会触发一个channelReadComplete事件。

 

　　read: Nio Channel通知eventLoop开始读数据

　　channel read方法的调用栈:

1 io.netty.channel.AbstractChannel#read
2 io.netty.channel.DefaultChannelPipeline#read
3 io.netty.channel.AbstractChannelHandlerContext#read
4 io.netty.channel.AbstractChannelHandlerContext#invokeRead
5 io.netty.channel.DefaultChannelPipeline.HeadContext#read
6 io.netty.channel.AbstractChannel.AbstractUnsafe#beginRead
7 io.netty.channel.nio.AbstractNioChannel#doBeginRead

 

 　　调用channel的read的方法，会触发read事件，通过pipeline调用AbstractChannel unsafe的beginRead方法，这个方法的语义是通知eventLoop可以从channel读数据了，但他没有实现具体功能，把具体功能留给doBeginRead实现。doBeginRead在AbstractChannel中定义，它是一个抽象方法。AbstractNioChannel实现了这个方法:

 1 @Override
 2 protected void doBeginRead() throws Exception {
 3     // Channel.read() or ChannelHandlerContext.read() was called
 4     if (inputShutdown) {
 5         return;
 6     }
 7 
 8     final SelectionKey selectionKey = this.selectionKey;
 9     if (!selectionKey.isValid()) {
10         return;
11     }
12 
13     readPending = true;
14 
15     final int interestOps = selectionKey.interestOps();
16     if ((interestOps & readInterestOp) == 0) {
17         selectionKey.interestOps(interestOps | readInterestOp);
18     }
19 }

　　这里的doBeginRead实现，只有第17行是核心代码：把readInterestOps保存是的read操作标志添加到SelectableChannel的SelectionKey中。这里的readInterestOps是一个类的属性，在AbstractNioChannel中，它没有明确的定义，只有一个抽象的定义:NIO中的一个可以可以当成read操作的的标志。在NIO中可以当成read的有SelectionKey.OP_READ和SelectionKey.OP_ACCEPT。readInterestOps在AbstractNioChannel的构造方法中使用传入的参数初始化，子类就可以根据需要确定interestOps的具体含义。

　　设置好beginRead之后，NioEventLoop就可以使用Selector得到检测到channel上的read事件了，下面是NioEventLoop中处理read事件的代码:

1 //io.netty.channel.nio.NioEventLoop#processSelectedKey(java.nio.channels.SelectionKey, io.netty.channel.nio.AbstractNioChannel)
2 if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
3     unsafe.read();
4 }

　　这里调用了unsafe的read的方法，在Channel的Unsafe中并没有定义这个方法，它在io.netty.channel.nio.AbstractNioChannel.NioUnsafe中定义，在io.netty.channel.nio.AbstractNioMessageChannel.NioMessageUnsafe和io.netty.channel.nio.AbstractNioByteChannel.NioByteUnsafe中有两个不同的实现。这两个实现的区别是：NioMessageUnsafe.read是把从channel中读出的数据转换成Object, NioByteUnsafe.read是从channel中读出byte数据流。下面来详解分析这两种实现。

　　

　　AbstractNioChannel.NioUnsafe.read实现：从channel读取数据

　　netty在NIO Channel的设计上，把读数据设计成独立的抽象层。之所以这样设计有两个方面的原因:

1. 在NIO中，三中不同类型的Channel读取的数据类型是不一样的，NioServerSocketChannel读出的是一个新建的NioSockeChannel, NioSocketChannel读出的byte数据流，NioDatagramChannel读出是数据报。
2. NIO三种Channel都运行在非阻塞模式下，相比于阻塞模式，非阻塞模式下读数据要处理的问题要复杂的多。使用Selector和非阻塞模式被动地读取数据，需要处理连接断开和socket异常，由于Selector使用的是边缘触发模式，一次read调用务必要把已经在socket recvbuffer中的数据全部读出来，否则可以导致数据丢失或数据接收不及时。把read独立出来处理读取数据的复杂性，代码结构会比较清晰。

　　接下来开始详细分析NioUnsafe read方法的两种不同的实现。　

 

　　io.netty.channel.nio.AbstractNioMessageChannel.NioMessageUnsafe.read实现: 从channel中读出Object

　　这个实现是主要功能是调用doReadMessages方法，从channel中读出Object消息，具体的类型这里没有限制，doReadMessages是一个抽象方法，留给子类实现, 下面是read方法的实现:

 1 //io.netty.channel.nio.AbstractNioMessageChannel.NioMessageUnsafe
 2 @Override
 3 public void read() {
 4     assert eventLoop().inEventLoop();
 5     final ChannelConfig config = config();
 6     if (!config.isAutoRead() && !isReadPending()) {
 7         // ChannelConfig.setAutoRead(false) was called in the meantime
 8         removeReadOp();
 9         return;
10     }
11 
12     final int maxMessagesPerRead = config.getMaxMessagesPerRead();
13     final ChannelPipeline pipeline = pipeline();
14     boolean closed = false;
15     Throwable exception = null;
16     try {
17         try {
18             for (;;) {
19                 int localRead = doReadMessages(readBuf);
20                 if (localRead == 0) {
21                     break;
22                 }
23                 if (localRead < 0) {
24                     closed = true;
25                     break;
26                 }
27 
28                 // stop reading and remove op
29                 if (!config.isAutoRead()) {
30                     break;
31                 }
32 
33                 if (readBuf.size() >= maxMessagesPerRead) {
34                     break;
35                 }
36             }
37         } catch (Throwable t) {
38             exception = t;
39         }
40         setReadPending(false);
41         int size = readBuf.size();
42         for (int i = 0; i < size; i ++) {
43             pipeline.fireChannelRead(readBuf.get(i));
44         }
45 
46         readBuf.clear();
47         pipeline.fireChannelReadComplete();
48 
49         if (exception != null) {
50             closed = closeOnReadError(exception);
51 
52             pipeline.fireExceptionCaught(exception);
53         }
54 
55         if (closed) {
56             if (isOpen()) {
57                 close(voidPromise());
58             }
59         }
60     } finally {
61         // Check if there is a readPending which was not processed yet.
62         // This could be for two reasons:
63         // * The user called Channel.read() or ChannelHandlerContext.read() in channelRead(...) method
64         // * The user called Channel.read() or ChannelHandlerContext.read() in channelReadComplete(...) method
65         //
66         // See https://github.com/netty/netty/issues/2254
67         if (!config.isAutoRead() && !isReadPending()) {
68             removeReadOp();
69         }
70     }
71 }

 

　　 第12行，得到一次循环读取消息的最大数量maxMessagesPerRead，这个配置的默认值因不同的channel类型而不同，io.netty.channel.ChannelConfig提供了setMaxMessagesPerRead方法设置这个配置的值。调节这个值的大小可以影响I/O操作在eventLoop线程分配的执行时间，它的值越大，I/O操作站的时间越大。

　　18-36行，使用doReadMessages读取消息，并把消息放到readBuf中，readBuf是List