Netty4 initAndRegister 解析

我们从框架的应用层面来分析，NioEventLoopGroup在netty中的使用。

这是我们需要配置的地方。

紧接着我们进入netty的运行中。ServerBootstrap.bind(PORT);

这是一个bind操作。我们来看一下NioEventLoopGroup在这个操作中的使用。

ChannelFuture regFuture = config().group().register(channel);

config()返回在ServerBootstrap中内部属性：private final ServerBootstrapConfig config = new ServerBootstrapConfig(this);

注意这里传入的是this即ServerBootstrap对象。

这个类主要是用来暴露我们的配置的，直接把我们配置的ServerBootstrap传递进来。

我们继续ChannelFuture regFuture = config().group().register(channel);

这里的config()返回一个ServerBootstrapConfig，然后调用他的group()。

这个类是ServerBootstrapConfig的父类。调用了ServerBootstrap.group().方法。注意因为group方法是在弗雷AbstractBootstrap中定义的，所以这里进入父类的group()方法中来。

这个方法直接返回EventLoopGroup对象。

我们在回过头来看我们最初的配置，来发现这个group属性究竟是什么。

我们配置了两个NioEventLoopGroup,一个一个线程的传递给了父类AbstractBootstrap.一个初始化给当前的ServerBootstrap的内部属性childGroup.

我们在回到这里ChannelFuture regFuture = config().group().register(channel);

现在通过AbstractBootstrap.group()方法返回了一个NioEventLoopGroup对象，即我们配置的第一个单线程的NioEventLoopGroup对象。

现在进入他的register(channel)方法。由于这个方法是在他的父类中定义的，所以我们进入他的父类MultithreadEventLoopGroup()中。

next()方法返回一个EventLoop对象。

下面重点分析这个chooser。（在=======以内，然后接着分析next()方法）

====================================================================

这个chooser是我们在初始化NioEventLoopGroup的时候初始化的。

回到我们初始化NioEventLoopGroup的地方：

还是这里。

重点注意这下面的这个SelectorProvider.provider(),在后面的构造方法NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler)中会用到。

下面就到了初始化chooser的地方了：

/**
     * Create a new instance.
     *
     * @param nThreads          the number of threads that will be used by this instance.
     * @param executor          the Executor to use, or {@code null} if the default should be used.
     * @param chooserFactory    the {@link EventExecutorChooserFactory} to use.
     * @param args              arguments which will passed to each {@link #newChild(Executor, Object...)} call
     */
    protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                            EventExecutorChooserFactory chooserFactory, Object... args) {
        if (nThreads <= 0) {
            throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
        }

        if (executor == null) {
            executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
        }

        children = new EventExecutor[nThreads];

        for (int i = 0; i < nThreads; i ++) {
            boolean success = false;
            try {
                children[i] = newChild(executor, args);
                success = true;
            } catch (Exception e) {
                // TODO: Think about if this is a good exception type
                throw new IllegalStateException("failed to create a child event loop", e);
            } finally {
                if (!success) {
                    for (int j = 0; j < i; j ++) {
                        children[j].shutdownGracefully();
                    }

                    for (int j = 0; j < i; j ++) {
                        EventExecutor e = children[j];
                        try {
                            while (!e.isTerminated()) {
                                e.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
                            }
                        } catch (InterruptedException interrupted) {
                            // Let the caller handle the interruption.
                            Thread.currentThread().interrupt();
                            break;
                        }
                    }
                }
            }
        }

        chooser = chooserFactory.newChooser(children);

        final FutureListener<Object> terminationListener = new FutureListener<Object>() {
            @Override
            public void operationComplete(Future<Object> future) throws Exception {
                if (terminatedChildren.incrementAndGet() == children.length) {
                    terminationFuture.setSuccess(null);
                }
            }
        };

        for (EventExecutor e: children) {
            e.terminationFuture().addListener(terminationListener);
        }

        Set<EventExecutor> childrenSet = new LinkedHashSet<EventExecutor>(children.length);
        Collections.addAll(childrenSet, children);
        readonlyChildren = Collections.unmodifiableSet(childrenSet);
    }

这个构造方法内容比较多。别的先不管，我们来看：chooser = chooserFactory.newChooser(children);

这个EventExecutorChooserFactory chooserFactory是我们上个构造方法中传过来的：

this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);

是一个DefaultEventExecutorChooserFactory.INSTANCE。

然后我们看他的newChooser(EventExecutor[] executors)方法。

　　@SuppressWarnings("unchecked")
    @Override
    public EventExecutorChooser newChooser(EventExecutor[] executors) {
        if (isPowerOfTwo(executors.length)) {
            return new PowerOfTwoEventExecutorChooser(executors);
        } else {
            return new GenericEventExecutorChooser(executors);
        }
    }

这里有个判断就是:判断是否为2的次方。

private static boolean isPowerOfTwo(int val) {
        return (val & -val) == val;
}

然后根据是否为2的次方分别进行两个构造方法。分别实现了EventExecutorChooser的next()方法。

    private static final class PowerOfTwoEventExecutorChooser implements EventExecutorChooser {
        private final AtomicInteger idx = new AtomicInteger();
        private final EventExecutor[] executors;

        PowerOfTwoEventExecutorChooser(EventExecutor[] executors) {
            this.executors = executors;
        }

        @Override
        public EventExecutor next() {
            return executors[idx.getAndIncrement() & executors.length - 1];
        }
    }

    private static final class GenericEventExecutorChooser implements EventExecutorChooser {
        private final AtomicInteger idx = new AtomicInteger();
        private final EventExecutor[] executors;

        GenericEventExecutorChooser(EventExecutor[] executors) {
            this.executors = executors;
        }

        @Override
        public EventExecutor next() {
            return executors[Math.abs(idx.getAndIncrement() % executors.length)];
        }
    }

这两个实现类只是对于next的方法有不同的实现。但是都是遍历每一个executors。

为什么要这样呢？

原因是位操作&  比 % 操作要高效。netty为了提高效率也是拼了。

总的来说这个DefaultEventExecutorChooserFactory非常简单，就上面这些内容。现在我们也知道了chooser是什么了，就是一个时限了遍历所有EventExecutor的next()方法的对象。功能非常简单，只有一个方法next。遍历每一个EventExecutor。

=====================================================================

好了到此为止我们分析玩了chooser，现在进入主逻辑。

上面我们分析道了这里：

同时我们通过＝＝＝＝中的内容我们也知道了EventLoopGroup是如何初始化内部属性EventExecutors的：

children[i] = newChild(executor, args);

但是这个newChild(executor,args)方法是在子类NioEventLoopGroup中实现的：

    @Override
    protected EventLoop newChild(Executor executor, Object... args) throws Exception {
        return new NioEventLoop(this, executor, (SelectorProvider) args[0],
            ((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) args[2]);
    }

＝＝＝＝＝＝＝＝＝＝＝＝＝＝这里插入分析一下NioEventLoop构造方法＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

上面的selectorProvider就是在上面我们划了重点注意的地方：

上面紧接着初始化了内部属性private Selector selector;这是一个java.nio.channels.Selector类型的内部属性。

这个属性在后面注册channel到selector的时候将作为参数传入channel的注册方法中。

所以我们接着看下这个openSelector()方法：

    private Selector openSelector() {
        try {
            unwrappedSelector = provider.openSelector();
        } catch (IOException e) {
            throw new ChannelException("failed to open a new selector", e);
        }

        if (DISABLE_KEYSET_OPTIMIZATION) {
            return unwrappedSelector;
        }

        final SelectedSelectionKeySet selectedKeySet = new SelectedSelectionKeySet();

        Object maybeSelectorImplClass = AccessController.doPrivileged(new PrivilegedAction<Object>() {
            @Override
            public Object run() {
                try {
　　　　　　　　　　　　//重点2-1。这里设置了SelectorImpl.
                    return Class.forName(
                            "sun.nio.ch.SelectorImpl",
                            false,
                            PlatformDependent.getSystemClassLoader());
                } catch (Throwable cause) {
                    return cause;
                }
            }
        });

        if (!(maybeSelectorImplClass instanceof Class) ||
                // ensure the current selector implementation is what we can instrument.
                !((Class<?>) maybeSelectorImplClass).isAssignableFrom(unwrappedSelector.getClass())) {
            if (maybeSelectorImplClass instanceof Throwable) {
                Throwable t = (Throwable) maybeSelectorImplClass;
                logger.trace("failed to instrument a special java.util.Set into: {}", unwrappedSelector, t);
            }
            return unwrappedSelector;
        }

        final Class<?> selectorImplClass = (Class<?>) maybeSelectorImplClass;

        Object maybeException = AccessController.doPrivileged(new PrivilegedAction<Object>() {
            @Override
            public Object run() {
                try {
                    Field selectedKeysField = selectorImplClass.getDeclaredField("selectedKeys");
                    Field publicSelectedKeysField = selectorImplClass.getDeclaredField("publicSelectedKeys");

                    Throwable cause = ReflectionUtil.trySetAccessible(selectedKeysField);
                    if (cause != null) {
                        return cause;
                    }
                    cause = ReflectionUtil.trySetAccessible(publicSelectedKeysField);
                    if (cause != null) {
                        return cause;
                    }

                    selectedKeysField.set(unwrappedSelector, selectedKeySet);
                    publicSelectedKeysField.set(unwrappedSelector, selectedKeySet);
                    return null;
                } catch (NoSuchFieldException e) {
                    return e;
                } catch (IllegalAccessException e) {
                    return e;
                }
            }
        });

        if (maybeException instanceof Exception) {
            selectedKeys = null;
            Exception e = (Exception) maybeException;
            logger.trace("failed to instrument a special java.util.Set into: {}", unwrappedSelector, e);
            return unwrappedSelector;
        }
        selectedKeys = selectedKeySet;
        logger.trace("instrumented a special java.util.Set into: {}", unwrappedSelector);
        return new SelectedSelectionKeySetSelector(unwrappedSelector, selectedKeySet);
    }

nio中大量使用了AccessController.doPrivileged可以关于这个的使用可以参考《java 的 AccessController.doPrivileged使用》。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

也就是说上面箭头所指的2处返回的是一个NioEventLoop对象。

也就是说next().register(channel)调用的是NioEventLoop.register(channel);

这就是netty的eventloop线程模型的应用了。每个EventLoop有一个Selector, boss用Selector处理accept, worker用Selector处理read,write等

这个方法是在它的父类SingleThreadEventLoop中定义的：

首先构造一个DefaultChannelPromise(channel, this)对象。

然后进入register(new DefaultChannelPromise(channel, this))方法。

promise.channel()返回的就是我们构造promise时传入的channel。还记得channel是怎么构造的吗：

这里的channelFactory.newChannel()返回的是一个我们之前配置的channel类型的channel实例：（这块细节可以参考我的另一篇博客《ChannelFactory初始化》）

因为NioServerSocketChannel没有定义unsafe()这个方法。所以我们一直找到了它的祖祖父类：

这个NioMessageUnsafe是AbstractNioMessageChannel的内部类。

知道了unsafe的类型后我们继续主流程：promise.channel().unsafe().register(this, promise);

现在进入NioMessageUnsafe.register(this,promise);同样调用的是它的父类中的register方法：

内容比较多我们用代码展示：

下面体现了netty中channel与eventloop的一一对应关系。体现了eventloop线程处理channel工作的逻辑。

        @Override
        public final void register(EventLoop eventLoop, final ChannelPromise promise) {
            if (eventLoop == null) {
                throw new NullPointerException("eventLoop");
            }
　　　　　　　//这里体现了一个channel只能对应一个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;
            }
　　　　　　　//注册到channel
            AbstractChannel.this.eventLoop = eventLoop;
　　　　　　　//判断当前线程是否为此eventloop线程
            if (eventLoop.inEventLoop()) {
                register0(promise);
            } else {
　　　　　　　　　 //如果当前线程不是此eventloop线程
                try {
                    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);
                }
            }
        }

上面就体现了eventloop的在netty中的应用。

我们直接看这个方法好了：register0(promise);这个方法就定义在上面方法的下面：

        private void register0(ChannelPromise promise) {
            try {
                // check if the channel is still open as it could be closed in the mean time when the register
                // call was outside of the eventLoop
                if (!promise.setUncancellable() || !ensureOpen(promise)) {
                    return;
                }
                boolean firstRegistration = neverRegistered;
                doRegister();
                neverRegistered = false;
                registered = true;

                // Ensure we call handlerAdded(...) before we actually notify the promise. This is needed as the
                // user may already fire events through the pipeline in the ChannelFutureListener.
                pipeline.invokeHandlerAddedIfNeeded();

                safeSetSuccess(promise);
                pipeline.fireChannelRegistered();
                // Only fire a channelActive if the channel has never been registered. This prevents firing
                // multiple channel actives if the channel is deregistered and re-registered.
                if (isActive()) {
                    if (firstRegistration) {
                        pipeline.fireChannelActive();
                    } else if (config().isAutoRead()) {
                        // This channel was registered before and autoRead() is set. This means we need to begin read
                        // again so that we process inbound data.
                        //
                        // See https://github.com/netty/netty/issues/4805
                        beginRead();
                    }
                }
            } catch (Throwable t) {
                // Close the channel directly to avoid FD leak.
                closeForcibly();
                closeFuture.setClosed();
                safeSetFailure(promise, t);
            }
        }

下面分析下doRegister()然后回来继续分析

＝＝＝＝＝＝＝＝＝＝我们开个分区分析下doRegister()方法＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

eventloop中除了定义了一个线程外，它还包含了selector等操作。

循环执行selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);

一直到成功为止。

import java.nio.channels.SelectableChannel;

public abstract SelectionKey register(Selector sel, int ops, Object att)；这歌是个抽象方法。

然后这歌ServerSocketChannelImpl中并没有定义register(Selector sel, int ops, Object att)方法，所以我们就在SelectableChannel的子类中找。在AbstractSelectableChannel中找到了这个方法的实现，通过debug的确也定为到了这个方法：

java.nio.channels.spi.AbstractSelectableChannel;

    /**
     * Registers this channel with the given selector, returning a selection key.
     *
     * <p>  This method first verifies that this channel is open and that the
     * given initial interest set is valid.
     *
     * <p> If this channel is already registered with the given selector then
     * the selection key representing that registration is returned after
     * setting its interest set to the given value.
     *
     * <p> Otherwise this channel has not yet been registered with the given
     * selector, so the {@link AbstractSelector#register register} method of
     * the selector is invoked while holding the appropriate locks.  The
     * resulting key is added to this channel's key set before being returned.
     * </p>
     *
     * @throws  ClosedSelectorException {@inheritDoc}
     *
     * @throws  IllegalBlockingModeException {@inheritDoc}
     *
     * @throws  IllegalSelectorException {@inheritDoc}
     *
     * @throws  CancelledKeyException {@inheritDoc}
     *
     * @throws  IllegalArgumentException {@inheritDoc}
     */
    public final SelectionKey register(Selector sel, int ops,
                                       Object att)
        throws ClosedChannelException
    {
        synchronized (regLock) {
            if (!isOpen())
                throw new ClosedChannelException();
            if ((ops & ~validOps()) != 0)
                throw new IllegalArgumentException();
            if (blocking)
                throw new IllegalBlockingModeException();
            SelectionKey k = findKey(sel);
            if (k != null) {
                k.interestOps(ops);
                k.attach(att);
            }
            if (k == null) {
                // New registration
                synchronized (keyLock) {
                    if (!isOpen())
                        throw new ClosedChannelException();
                    k = ((AbstractSelector)sel).register(this, ops, att);
                    addKey(k);
                }
            }
            return k;
        }
    }

该实现是通过spi的机制实现的（关于spi可参考《java中的SPI机制》）

SelectableChannel的register(Selector selector, ...)和Selector的select()方法都会操作Selector对象的共享资源all-keys集合.

根据这个方法的注释我们可以很直观的看到这个方法的作用：Registers this channel with the given selector, returning a selection key

仔细看k = ((AbstractSelector)sel).register(this, ops, att);

这个地方喝我们平时经常写的nio代码是一样的。

分析完这个方法后我们再来分析下eventLoop().unwrappedSelector()；

这个东西我们在上面分析过了，直接返回NioEventLoop 的private Selector unwrappedSelector;属性。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

然后我们继续回到register0(ChannelPromise promise)方法中来。上面我们分析完了doRegister();

doRegister()主要完成了channel注册到eventloop中selector的操作。

下面分析isActive()方法，这个方法定义在NioServerSocketChannel中：

　　@Override
    public boolean isActive() {
        return javaChannel().socket().isBound();
    }

这个方法Returns the binding state of the ServerSocket.

如果是绑定状态并且是第一次注册则进入：

pipeline.fireChannelActive();

((ChannelInboundHandler) handler()).channelInactive(this);

这里穿进来this（AbstractChannelHandlerContext）。ChannelInboundHandler.channelInactive(this)中完成业务逻辑后还可以返回到这个方法。

正如我所说，默认情况下所有的handler都没有具体的业务都返回到上层方法来。

到此为止我们就分析完了AbstactBootstrap.doBind(..)方法中的initAndRegister()方法，并在这个过程中观察了NioEventLoopGroup的使用。

结下来就到了bind环节。有兴趣的可以参考我的另一篇博客《netty4 ServerBootstrap.bind(port) debug》。