2022-01-19_netty服务端ServerBootstrap如何接受连接并后续处理读写事件学习笔记

20220119_netty服务端ServerBootstrap如何接受连接并后续处理读写事件学习笔记

1概述

非阻塞NIO,异步Future,高性能(单线程无锁),零拷贝(ByteBuf),Netty是基于NIO,它封装了JDK的NIO。可通过ChannelHandler对通讯框架进行灵活扩展。

本节主要学习一下netty服务端如何接受连接并后续处理读写事件

1.1父事件循环线程组的启动时序(略)

1.2接收连接后续处理时序

1.2.1父事件循环线程组

我们知道,服务端绑定成功后,会创建一个NioServerSocketChannel(即连接监听类型的通道),同时启动一个NioEventLoop线程,不断循环遍历selector中的有效的就绪事件OP_ACCEPT，可以接收成千上万个socket传输类型的通道。

另外，处理IO读写的通道(数据传输类型的通道)

1.2.1.1processSelectedKeys获取有效的事件

// netty-all-4.1.67.Final-sources.jar!\io\netty\channel\nio\NioEventLoop.java
    private SelectedSelectionKeySet selectedKeys;

@Override
    protected void run() {
        int selectCnt = 0;
        for (;;) {
            try {
                int strategy;
                try {
                    strategy = selectStrategy.calculateStrategy(selectNowSupplier, hasTasks());
                    switch (strategy) {
                    case SelectStrategy.CONTINUE:
                        continue;

                    case SelectStrategy.BUSY_WAIT:
                        // fall-through to SELECT since the busy-wait is not supported with NIO

                    case SelectStrategy.SELECT:
                             } else if (strategy > 0) {
                    final long ioStartTime = System.nanoTime();
                    try {
                        processSelectedKeys();

// netty-all-4.1.67.Final-sources.jar!\io\netty\channel\nio\NioEventLoop.java
    @Override
    protected void run() {
    }
private void processSelectedKeys() {
        if (selectedKeys != null) { // 就绪事件到来
            processSelectedKeysOptimized();
        } else {
            processSelectedKeysPlain(selector.selectedKeys());
        }
    }

private void processSelectedKeysOptimized() {
        for (int i = 0; i < selectedKeys.size; ++i) {
            final SelectionKey k = selectedKeys.keys[i];
            // null out entry in the array to allow to have it GC'ed once the Channel close
            // See https://github.com/netty/netty/issues/2363
            selectedKeys.keys[i] = null;

            final Object a = k.attachment();

            if (a instanceof AbstractNioChannel) {
                processSelectedKey(k, (AbstractNioChannel) a); // 服务端的NioSocketChannel,程序跑到这
            } else {
                @SuppressWarnings("unchecked")
                NioTask task = (NioTask) a;
                processSelectedKey(k, task);
            }

            if (needsToSelectAgain) {
                // null out entries in the array to allow to have it GC'ed once the Channel close
                // See https://github.com/netty/netty/issues/2363
                selectedKeys.reset(i + 1);

                selectAgain();
                i = -1;
            }
        }
    }

public static final int OP_ACCEPT = 1 << 4;

private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
    final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();  // 可访问底层 SelectableChannel
    ......
        // 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) {
            // readyOps==OP_ACCEPT
            unsafe.read();
        }
    } catch (CancelledKeyException ignored) {
        unsafe.close(unsafe.voidPromise());
    }
}

// netty-all-4.1.67.Final-sources.jar!\io\netty\channel\nio\AbstractNioMessageChannel.java
private final class NioMessageUnsafe extends AbstractNioUnsafe {

        private final List