上节对Netty的做了简单介绍，这节分析下Netty启动流程，后面的源码分析都以Netty4.0.32版本为例，以下面启动代码为例子
public class TimeServer {
public void bind(int port) throws Exception {
// 1.配置服务端的NIO线程组
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
//2.配置参数
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.option(ChannelOption.SO_BACKLOG, 1024)
.handler(new LoggingServerHandler())
.childHandler(new ChildChannelHandler());
// 3.绑定端口，同步等待成功
ChannelFuture f = b.bind(port).sync();
//4. 等待服务端关闭
f.channel().closeFuture().sync();
} finally {
//5.优雅退出，释放线程池资源
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
组件介绍
EventLoopGroup
EventLoopGroup是Netty的线程池，为Acceptor Selector和IO Selector事件提供线程支持，EventLoopGroup在初始化的时候会创建相应配置数量的EventLoop来提供单个线程，EventLoop功能比较复杂，既是Select的轮询事件线程也是其他IO事件处理的线程。使用时调用EventLoopGroup#next()方法来获取EventLoop。Netty的线程比较复杂后面章节会详细说明。
NioServerSocketChannel
NioServerSocketChannel提供了JDK的Channel和selector的绑定功能，再绑定端口前会调用这个方法绑定操作。同时NioServerSocketChannel有个Unsafe内部类在初始化NioServerSocketChannel时会创建Unsafe作为他的成员变量。Unsafe提供了JDK层的io操作包括读、写、绑定端口等根据继承类不同的不同操作。
ChannelHandler
ChannelHandler是Netty的核心，它的继承包含了2个重要的处理器ChannelOutboundHandler和ChannelInboundHandler。ChannelOutboundHandler是写出IO事件的处理器。ChannelInboundHandler是写入IO事件的处理器同时也包含了多个触发器，包括连接断开触发器，异常触发器，注册完成触发器，取消注册触发器等，由于ChannelHandler比较复杂后面章节会详细说明。
ChannelFuture
ChannelFuture是Netty的异步事件等待器，Netty利用其来实现所有IO事件的异步化，ChannelFuture可以注册多个事件完成监听器，异步事件会在完成后回调监听器。
ServerBootstrap
ServerBootstrap是Netty配置及启动的入口，提供线程池、连接参数、线程池以及处理器的配置，同时提供了绑定端口的方法。
启动时序图
我们以b.bind(port)这行代码作为开始流程，时序图如下： ![]()
ServerBootstrap:
- 1.调用initAndRegister()创建并初始化channel
- 1.1.调用init(channel)设置配置并注册ChannelHandler
- 1.2.调用EventLoopGroup里的register(channel)将创建selector并注册到此channel上
- 2.调用doBind0()绑定端口并启动监听
- 2.1.调用Channel的bind(localAddress, promise)方法绑定端口
EventLoopGroup:
- 1.2.1.调用next()获取下个EventLoop
- 1.2.2.调用register(channel)委托给EventLoop去注册
EventLoop:
- 1.2.2.1.调用unsafe()获取channel中的unsafe对象
- 1.2.2.2.调用register(this, promise)委托unsafe注册
Channel:
- 1.2.2.2.1.调用doRegister()将创建selector并注册到此channel上
- 1.2.2.2.2.调用pipeline的fireChannelRegistered()触发注册成功事件
- 1.2.2.2.3.调用pipeline的fireChannelActive()触发激活成功事件
- 1.2.2.2.3.1.1.1.修改interestOps添加读操作位
- 2.1.1.委托ChannelPipeline调用bind(localAddress, promise)
- 2.1.1.1.1.1.调用doBind(localAddress)绑定端口
- 2.1.1.1.1.2.如果还未激活调用pipeline的fireChannelActive()触发激活成功事件
- 2.1.1.1.1.2.1.1.1修改interestOps添加读操作位
ChannelPipeline:
- 1.2.2.2.2.1.调用ChannelHandler链触发注册成功事件
- 1.2.2.2.3.1.调用ChannelHandler链触发激活成功事件，如果配置自动读则激活读事件
- 2.1.1.1.调用ChannelHandler链触发绑定事件
- 2.1.1.1.1.2.1.调用ChannelHandler链触发激活成功事件，如果配置自动读则激活读事件
HeadContext:
- 1.2.2.2.3.1.1.委托unsafe调用beginRead()开始读
- 2.1.1.1.1.委托Channel里的unsafe调用bind(localAddress, promise)
- 2.1.1.1.1.2.1.1.委托unsafe调用beginRead()开始读
源码分析
ServerBootstrap类的线程池、连接参数、线程池以及处理器的配置其实就是成员变量的复制这里就是不多讲，我们直接从b.bind()开始看。
b.bind()的方法直接将端口包装成类SocketAddress交给doBind()处理。doBind()源码如下
private ChannelFuture doBind(final SocketAddress localAddress) {
//初始化Channel并注册Selector
final ChannelFuture regFuture = initAndRegister();
final Channel channel = regFuture.channel();
if (regFuture.cause() != null) {
return regFuture;
}
//绑定监听端口并开始监听
if (regFuture.isDone()) {
ChannelPromise promise = channel.newPromise();
doBind0(regFuture, channel, localAddress, promise);
return promise;
} else {
final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
regFuture.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
Throwable cause = future.cause();
if (cause != null) {
promise.setFailure(cause);
} else {
promise.executor = channel.eventLoop();
}
doBind0(regFuture, channel, localAddress, promise);
}
});
return promise;
}
}
这个方法主要做了2件事
- 调用initAndRegister()初始化Channel并注册Selector
- 调用doBind0(）绑定监听端口并开始监听
注册Selector是默认是异步进行的这里Netty做了一个处理，如果注册Selector已完成则同步调用doBind0(）否则注册监听器等待Selector注册完成后调用doBind0(），这样保证整个doBind()方法的异步性。
接下来我们看下initAndRegister()的实现，源码如下：
final ChannelFuture initAndRegister() {
//初始化channel
final Channel channel = channelFactory().newChannel();
try {
init(channel);
} catch (Throwable t) {
channel.unsafe().closeForcibly();
return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
}
//注册Selector
ChannelFuture regFuture = group().register(channel);
if (regFuture.cause() != null) {
if (channel.isRegistered()) {
channel.close();
} else {
channel.unsafe().closeForcibly();
}
}
return regFuture;
}
initAndRegister()方法也是做了2件事
- 调用init()初始化Channel
- 调用group().register()注册Selector
channelFactory().newChannel()是创建你配置的Channel这里源码配置了NioServerSocketChannel，而init()的具体实现则是在NioServerSocketChannel中，init()源码如下:
void init(Channel channel) throws Exception {
...
ChannelPipeline p = channel.pipeline();
...
//将从线程组，从处理器，从配置，从属性封装成ServerBootstrapAcceptor处理器，共后续IOSelector使用。
p.addLast(new ChannelInitializer<Channel>() {
@Override
public void initChannel(Channel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
ChannelHandler handler = handler();
if (handler != null) {
pipeline.addLast(handler);
}
pipeline.addLast(new ServerBootstrapAcceptor(
currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
}
});
}
在上节中我们讲了Neety服务端线程模式可以是主从模型，所以它的配置也分主从配置，init()主要做的将主处理器（ChannelHandler）添加到主ChannelPipeline里，将 从线程组，从处理器（ChannelHandler），从配置，从属性封装成ServerBootstrapAcceptor处理器添加到主ChannelPipeline里，供后续触发客户端连接事件使用。
group().register()先是取了主线程组EventLoopGroup委托EventLoopGroup注册Selector，主线程组中也是调用next()委托给单线程EventLoop去处理
next().register(channel);
最后在EventLoop的register()中委托给Channel中的Unsafe处理（Unsafe是在Channel创建的时候被创建的）
channel.unsafe().register(this, promise);
我们来看下Unsafe中的register()的源码：
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
...
AbstractChannel.this.eventLoop = eventLoop;
//如果eventLoop是当前线程直接执行，否则交给传eventLoop线程处理
if (eventLoop.inEventLoop()) {
register0(promise);
} else {
try {
eventLoop.execute(new OneTimeTask() {
@Override
public void run() {
register0(promise);
}
});
} catch (Throwable t) {
closeForcibly();
closeFuture.setClosed();
safeSetFailure(promise, t);
}
}
}
Unsafe中的register()做的就是判断next()获取的线程是否是当前线程，如果是同步执行注册，否则异步执行注册，按例子中默认配置会异步调用register0()注册。
我们来看下register0()的源码
private void register0(ChannelPromise promise) {
try {
if (!promise.setUncancellable() || !ensureOpen(promise)) {
return;
}
boolean firstRegistration = neverRegistered;
//调用JDK去注册Selector
doRegister();
neverRegistered = false;
registered = true;
//设置注册成功通知监听器
safeSetSuccess(promise);
//触发注册成功事件
pipeline.fireChannelRegistered();
//如果是第一次则触发激活成功事件
if (firstRegistration && isActive()) {
pipeline.fireChannelActive();
}
} catch (Throwable t) {
closeForcibly();
closeFuture.setClosed();
safeSetFailure(promise, t);
}
}
register0()做了4件事
selectionKey = javaChannel().register(eventLoop().selector, 0, this);
- 设置注册成功通知监听器
- 触发注册成功事件
- 如果绑定成功则触发激活成功事件
触发注册成功事件和如果绑定成功触发激活成功事件其实是在主pipeline中链式调用用户的配置ChannelHandler，调用过程如下
图1
![]()
这里会有个疑问绑定是在注册selector之后进行的为什么这里可以触发激活成功事件，其实在safeSetSuccess(promise)代码执行之后已经通知监听器并开始执行绑定相关的代码了。
触发激活成功事件后如果配置了会触发开始读事件
public ChannelPipeline fireChannelActive() {
head.fireChannelActive();
//如果配置了会触发开始读事件
if (channel.config().isAutoRead()) {
channel.read();
}
return this;
}
读事件也是链式调用调用过程如下：
图2
![]()
可以看到最后调用HeadContext里的read()方法
public void read(ChannelHandlerContext ctx) {
unsafe.beginRead();
}
委托给unsafe去处理，处理的方式就是修改interestOps添加读操作位，由IOSelector去触发读事件
selectionKey.interestOps(interestOps | readInterestOp);
在NioServerSocketChannel中readInterestOp其实对应的是JDK中的SelectionKey.OP_ACCEPT，在ServerSocketChannel构造方法中定义:
public NioServerSocketChannel(ServerSocketChannel channel) {
super(null, channel, SelectionKey.OP_ACCEPT);
config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}
服务端启动后最先关心是客户端连接的，如果没有客户端的连接，后续无法IO操作，所以这里注册了SelectionKey.OP_ACCEPT来监听客户端的连接。
以上就是初始化Channel并注册Selector的流程
下面说下调用doBind0(）绑定监听端口并开始监听流程，doBind0(）代码如下：
private static void doBind0(
final ChannelFuture regFuture, final Channel channel,
final SocketAddress localAddress, final ChannelPromise promise) {
channel.eventLoop().execute(new Runnable() {
@Override
public void run() {
if (regFuture.isSuccess()) {
channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
} else {
promise.setFailure(regFuture.cause());
}
}
});
}
绑定端口是异步进行的，这里调用channel.eventLoop()获取的线程默认就是之前注册Selector的流程中next()获取的线程。绑定的流程其实也是在主pipeline中链式调用用户的配置ChannelHandler，如图2，可以看到最后调用HeadContext里的bind()方法
public void bind(ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise)
throws Exception {
unsafe.bind(localAddress, promise);
}
也是委托给unsafe去处理，处理的方式就是调用JDK里的绑定接口去绑定
javaChannel().socket().bind(localAddress);
如果绑定成功且之前没触发激活成功事件则触发之，这里的流程跟之前讲的一样就不累述。
以上就是绑定监听端口并开始监听的流程。
