@Override
public ChannelFuture register(Channel channel) {
    // 选择一个事件循环，并调用其register方法
    return next().register(channel);
}

@Override
public ChannelFuture register(Channel channel) {
    // 将通道对象封装为promise对象
    return register(new DefaultChannelPromise(channel, this));
}

@Override
public ChannelFuture register(final ChannelPromise promise) {
    ObjectUtil.checkNotNull(promise, "promise");
    // 通过通道的unsafe对象来进行注册
    promise.channel().unsafe().register(this, promise);
    return promise;
}

/*
 * 将通道注册到事件循环关联的选择器中
 */
@Override
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
    ObjectUtil.checkNotNull(eventLoop, "eventLoop");
    if (isRegistered()) {
        promise.setFailure(new IllegalStateException("registered to an event loop already"));
        return;
    }
    if (!isCompatible(eventLoop)) {
        promise.setFailure(
                new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));
        return;
    }

    // 绑定事件循环器
    AbstractChannel.this.eventLoop = eventLoop;

    // 判断当前线程是否是reactor线程
    if (eventLoop.inEventLoop()) {
        // 进行注册
        register0(promise);
    } else {
        try {
            /*
             * ====================
             * NioEventLoop的启动入口
             * ====================
             */
            eventLoop.execute(new Runnable() {
                @Override
                public void run() {
                    register0(promise);
                }
            });
        } catch (Throwable t) {
            logger.warn(
                    "Force-closing a channel whose registration task was not accepted by an event loop: {}",
                    AbstractChannel.this, t);
            closeForcibly();
            closeFuture.setClosed();
            safeSetFailure(promise, t);
        }
    }
}

@Override
protected void doRegister() throws Exception {
    boolean selected = false;

    // 为什么要自旋？可能是担心会注册失败，所以在循环中方便重试一次。
    for (;;) {
        try {
            /*
             * 拿到Java层面的channel（ServerSocketChannel），注册到java层面的selector上，
             * 并把netty中的channel作为附件挂在jdk层面的selector上，后续事件达到selector时，
             * 可以拿出netty层面的channel处理
             * 注意，这里注册的事件代码是0，表示还不关心任何事件，只是建立绑定关系。
             * 设置的附件是当前通道对象，在事件循环中会使用该通道对象的Unsafe对象来处理事件。
             *
             * 后续在通道Active的时候，会注册具体感兴趣的事件。
             */
            selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);
            return;
        } catch (CancelledKeyException e) {
            if (!selected) {
                // Force the Selector to select now as the "canceled" SelectionKey may still be
                // cached and not removed because no Select.select(..) operation was called yet.
                // 执行一次事件选择
                eventLoop().selectNow();
                // 再试一次注册，
                selected = true;
            } else {
                // We forced a select operation on the selector before but the SelectionKey is still cached
                // for whatever reason. JDK bug ?
                // 第二次还是失败的话则抛出异常
                throw e;
            }
        }
    }
}