netty系列之（四）——新连接接入

Netty新连接接入处理逻辑:

• 检测新连接:新连接通过服务端Channel绑定的Selector轮询OP_ACCEPT事件
• 创建NioSocketChannel:基于JDK的Nio Channel创建NioSocketChannel即客户端Channel
• 分配线程及注册Selector:提供客户端Channel分配NioEventLoop,并且将Channel注册到NioEventLoop对应的Selector,Channel读写由NioEventLoop管理

• 向Selector注册读事件

  
  
  

  NioEventLoop

一、检测新连接：

• processSelectedKey(key,channel)[入口]
• NioMessageUnsafe.read():获取服务端Channel的Config和Pipeline,allocHandle处理接入数据读取Channel,调用continueReading()判断总连接数是否超过每次最大读的连接数
• doReadMessages()[while循环]:调用javaChannel()获取Channel,使用accept()获取SocketChannel封装成NioSocketChannel放到连接readBuf
• javaChannel().accept()

#NioEventLoop的processSelectedKey方法
private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
        final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();
        if (!k.isValid()) {
            final EventLoop eventLoop;
            try {
                eventLoop = ch.eventLoop();
            } catch (Throwable ignored) {
                // If the channel implementation throws an exception because there is no event loop, we ignore this
                // because we are only trying to determine if ch is registered to this event loop and thus has authority
                // to close ch.
                return;
            }
            // Only close ch if ch is still registered to this EventLoop. ch could have deregistered from the event loop
            // and thus the SelectionKey could be cancelled as part of the deregistration process, but the channel is
            // still healthy and should not be closed.
            // See https://github.com/netty/netty/issues/5125
            if (eventLoop != this || eventLoop == null) {
                return;
            }
            // close the channel if the key is not valid anymore
            unsafe.close(unsafe.voidPromise());
            return;
        }

        try {
            int readyOps = k.readyOps();
            // We first need to call finishConnect() before try to trigger a read(...) or write(...) as otherwise
            // the NIO JDK channel implementation may throw a NotYetConnectedException.
            if ((readyOps & SelectionKey.OP_CONNECT) != 0) {
                // remove OP_CONNECT as otherwise Selector.select(..) will always return without blocking
                // See https://github.com/netty/netty/issues/924
                int ops = k.interestOps();
                ops &= ~SelectionKey.OP_CONNECT;
                k.interestOps(ops);

                unsafe.finishConnect();
            }

            // Process OP_WRITE first as we may be able to write some queued buffers and so free memory.
            if ((readyOps & SelectionKey.OP_WRITE) != 0) {
                // Call forceFlush which will also take care of clear the OP_WRITE once there is nothing left to write
                ch.unsafe().forceFlush();
            }

            // Also check for readOps of 0 to workaround possible JDK bug which may otherwise lead
            // to a spin loop
            if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
                unsafe.read();
            }
        } catch (CancelledKeyException ignored) {
            unsafe.close(unsafe.voidPromise());
        }
    }

private final class NioMessageUnsafe extends AbstractNioUnsafe {

        private final List