netty-bind

ServerBootstrap在bind时，主要做了3个操作：init、register、bind

init

void init(Channel channel) throws Exception {
  final Map<ChannelOption<?>, Object> options = options0();
  synchronized (options) {
    setChannelOptions(channel, options, logger);
  }

  final Map<AttributeKey<?>, Object> attrs = attrs0();
  synchronized (attrs) {
    for (Entry<AttributeKey<?>, Object> e: attrs.entrySet()) {
      @SuppressWarnings("unchecked")
      AttributeKey<Object> key = (AttributeKey<Object>) e.getKey();
      channel.attr(key).set(e.getValue());
    }
  }

  ChannelPipeline p = channel.pipeline();

  final EventLoopGroup currentChildGroup = childGroup;
  final ChannelHandler currentChildHandler = childHandler;
  final Entry<ChannelOption<?>, Object>[] currentChildOptions;
  final Entry<AttributeKey<?>, Object>[] currentChildAttrs;
  synchronized (childOptions) {
    currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size()));
  }
  synchronized (childAttrs) {
    currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(childAttrs.size()));
  }
    //register后，ChannelInitializer的initChannel就会通过ChannelPipeline的fireChannelRegistered被调用，
    //initChannel方法返回后，ChannelInitializer会被从ChannelPipeline中删除。
    //pipeline.addLast(handler)会将我们设置的handler添加在pipeline中，如果我们添加的是一个ChannelInitializer，
    //执行完这个initChannel后，ChannelPipeline中就会有ChannelInitializer、ServerBootstrapAcceptor两个Handler，
    //registered事件继续在ChannelPipeline中传播，传至新添加的ChannelInitializer时，又会执行initChannel逻辑，
    //我们通常会在initChannel方法中进行添加handler操作，假设添加了h1、h2，
    //如果不通过execute执行添加ServerBootstrapAcceptor的操作（execute会将任务入队），
    //最后ChannelPipeline中就会有ServerBootstrapAcceptor、h1、h2。
  p.addLast(new ChannelInitializer<Channel>() {
    @Override
    public void initChannel(final Channel ch) throws Exception {
      final ChannelPipeline pipeline = ch.pipeline();
      ChannelHandler handler = config.handler();
      if (handler != null) {
        pipeline.addLast(handler);
      }

      ch.eventLoop().execute(new Runnable() {
        @Override
        public void run() {
            //ServerBootstrapAcceptor
          pipeline.addLast(new ServerBootstrapAcceptor(
                  ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
        }
      });
    }
  });
}

ServerBootstrapAcceptor主要就是将channel注册到selector上

private static class ServerBootstrapAcceptor extends ChannelInboundHandlerAdapter {
    //......
    
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        //io.netty.channel.Channel，该channel是对jdk的channel的包装，
        //在serverSocket accept到socket后，socket就会被包装为io.netty.channel.Channel，
        //然后通过pipeline.fireChannelRead传到这里，目前这一系列操作都是在boss线程中进行的。
      final Channel child = (Channel) msg;
        //将childHandler添加到accept的channel上
      child.pipeline().addLast(childHandler);

      setChannelOptions(child, childOptions, logger);

      for (Entry<AttributeKey<?>, Object> e: childAttrs) {
        child.attr((AttributeKey<Object>) e.getKey()).set(e.getValue());
      }

      try {
          //注册Channel，注册后channel就绑定在了特定的EventLoop上，
          //并且注册在与EventLoop对应的selector上，该channel之后的IO操作都是在EventLoop上进行的。
        childGroup.register(child).addListener(new ChannelFutureListener() {
          @Override
          public void operationComplete(ChannelFuture future) throws Exception {
            if (!future.isSuccess()) {
              forceClose(child, future.cause());
            }
          }
        });
      } catch (Throwable t) {
        forceClose(child, t);
      }
    }
    
    //......
}

register

register和bind都涉及到一个接口io.netty.channel.Channel.Unsafe

//Unsafe提供了提供了与真正的IO操作，比如从socket读数据、写数据，将channel注册到selector等。
interface Unsafe {
    //......
    
    void bind(SocketAddress localAddress, ChannelPromise promise);
    
    void connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise);

    void write(Object msg, ChannelPromise promise);

    void flush();
    
    /**
     * Schedules a read operation that fills the inbound buffer of the first {@link ChannelInboundHandler} in the
     * {@link ChannelPipeline}.  If there's already a pending read operation, this method does nothing.
     */
    void beginRead();
    
    /**
     * Register the {@link Channel} of the {@link ChannelPromise} and notify
     * the {@link ChannelFuture} once the registration was complete.
     */
    void register(EventLoop eventLoop, ChannelPromise promise);
     
    //......
}

//Unsafe实现的register方法，有删减
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
    //如果在worker线程中，则直接注册（即将channel注册在selector上）
    if (eventLoop.inEventLoop()) {
        register0(promise);
    } else {
        //如果不在worker线程中，则异步注册，如果worker线程未开启，execute会先开启线程再入队。
        eventLoop.execute(new Runnable() {
            @Override
            public void run() {
                register0(promise);
            }
        });
    }
}

bind

注册之后，就可以bind了，bind仍然会在eventLoop中执行，此后serverSocket就开始监听client请求了。