上一節說到註冊的入口，即
MultithreadEventLoopGroup:

    public ChannelFuture register(Channel channel) {
        return next().register(channel);
    }

註冊channel第一步呼叫了next()方法，next()是MultithreadEventLoopGroup裡邊的:

    public EventLoop next() {
        return (EventLoop) super.next();
    }

到了父類MultithreadEventExecutorGroup：

    public EventExecutor next() {
        return chooser.next();
    }

這裡出現了一個chooser：

private final EventExecutorChooserFactory.EventExecutorChooser chooser;

看一下他的結構,EventExecutorChooserFactory是一個工廠，生產各種Executor,，用EventExecutorChooserFactory的實現類DefaultEventExecutorChooserFactory看一下：

/**
 * Default implementation which uses simple round-robin to choose next {@link EventExecutor}.
 * 預設使用round-robin演算法選擇下一個例項的EventExecutor實現
 * round-robin：主要用在負載均衡方向，比如有5臺機器，第一次分請求到了第一臺機器，第二次到了第二臺機器，第三次請求到了第三臺請求，以此類推一直到第五臺機器，然後第六次又到了第一臺機器，這樣一個輪流的呼叫，處理負載，這裡的Executor陣列也是使用這種方式，保證數組裡邊的EventExecutor被均衡呼叫。
 */
 

public final class DefaultEventExecutorChooserFactory implements EventExecutorChooserFactory {
    public EventExecutorChooser newChooser(EventExecutor[] executors) {
        if (isPowerOfTwo(executors.length)) {
            return new PowerOfTwoEventExecutorChooser(executors);
        } else {
            return
 
 new GenericEventExecutorChooser(executors);
        }
    }

從這裡可以看到netty對效能的壓榨，當有2的指數個executor的時候使用PowerOfTwoEventExecutorChooser效能會比非指數個的GenericEventExecutorChooser效能高一點,PowerOfTwoEventExecutorChooser和GenericEventExecutorChooser都是DefaultEventExecutorChooserFactory 的靜態內部類，都有next()方法返回一個EventExecutor。以上是對chooser的建立的一個分析,
回到MultithreadEventExecutorGroup看一下對chooser的賦值：

//虛擬碼
public abstract class MultithreadEventExecutorGroup extends AbstractEventExecutorGroup {
    private final EventExecutor[] children;
    protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                            EventExecutorChooserFactory chooserFactory, Object... args) {
       children = new EventExecutor[nThreads];
         for (int i = 0; i < nThreads; i ++) {
            children[i] = newChild(executor, args);
         }   
        chooser = chooserFactory.newChooser(children);  
    }
}

children的來源是newChild()方法：

    /**
     * Create a new EventExecutor which will later then accessible via the {@link #next()}  method. This method will be
     * called for each thread that will serve this {@link MultithreadEventExecutorGroup}.
     *
     建立一個EventExecutor ，稍後可以呼叫next()方法，這個next()方法被每個執行緒呼叫，這些執行緒 是服務MultithreadEventExecutorGroup的
     */
    protected abstract EventExecutor newChild(Executor executor, Object... args) throws Exception;

這個是EventExecutor 的建立，接下來我們看一下register方法，我們打了一個斷點：

之後debug進入register方法，我們進入的是SingleThreadEventLoop:

/**
 * Abstract base class for {@link EventLoop}s that execute all its submitted tasks in a single thread.
 * EventLoop的基礎抽象類，所有提交的任務都會在一個執行緒裡邊執行。
 *
 */
public abstract class SingleThreadEventLoop extends SingleThreadEventExecutor implements EventLoop {
...略
    public ChannelFuture register(Channel channel) {
        return register(new DefaultChannelPromise(channel, this));
    }
    ...略
}

DefaultChannelPromise是ChannelFuture的具體實現， 其持有Channel 和當前的EventLoop。

    public DefaultChannelPromise(Channel channel, EventExecutor executor) {
        super(executor);
        this.channel = channel;
    }

父類->

public class DefaultPromise<V> extends AbstractFuture<V> implements Promise<V> {
    public DefaultPromise(EventExecutor executor) {
        this.executor = checkNotNull(executor, "executor");
    }
}

最後我們來到register方法：

public abstract class SingleThreadEventLoop extends SingleThreadEventExecutor implements EventLoop
    public ChannelFuture register(final ChannelPromise promise) {
        ObjectUtil.checkNotNull(promise, "promise");
        promise.channel().unsafe().register(this, promise);
        return promise;
    }
}

這個方法是註冊邏輯的真正的入口了，出現了unsafe物件，下一節介紹。