Netty hello world 入门源码分析

第一节简单提了什么是网络编程，Netty 做了什么，Netty 都有哪些功能组件。这一节就具体进入 Netty 的世界，我们从用 Netty 的功能实现基本的网络通信开始分析 各个组件的使用。

1. 一个简单的发送接收消息的例子

话不多说，先来实现一个发送接收消息的例子。本实例基于 SpringBoot 工程搭建。

项目类文件如下：

客户端和服务端的主要代码分为3个部分：启动器，ChannelInitializer，eventHandler。

相关代码已经上传 GitHub，请参阅：点我 (๑¯ ³ ¯๑)

Server端：

package com.rickiyang.learn.helloWorld;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import lombok.extern.slf4j.Slf4j;

/**
 * @author: rickiyang
 * @date: 2020/3/15
 * @description: server 端
 */
@Slf4j
public class HwServer {

    private int port;

    public HwServer(int port) {
        this.port = port;
    }

    public void start(){
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workGroup = new NioEventLoopGroup();

        ServerBootstrap server = new ServerBootstrap().group(bossGroup,workGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ServerChannelInitializer());

        try {
            ChannelFuture future = server.bind(port).sync();
            future.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            log.error("server start fail",e);
        }finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        HwServer server = new HwServer(7788);
        server.start();
    }
}

server initializer:

package com.rickiyang.learn.helloWorld;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import lombok.extern.slf4j.Slf4j;

/**
 * @author: rickiyang
 * @date: 2020/3/15
 * @description:
 */
@Slf4j
public class HwServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        log.info("server channelActive");
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        log.info(ctx.channel().remoteAddress()+"===>server: "+msg.toString());
        ctx.write("hi, received your msg");
        ctx.flush();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        super.exceptionCaught(ctx, cause);
        ctx.close();
    }

}

server handler:

package com.rickiyang.learn.helloWorld;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import lombok.extern.slf4j.Slf4j;

/**
 * @author: rickiyang
 * @date: 2020/3/15
 * @description:
 */
@Slf4j
public class HwServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        log.info("server channelActive");
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        log.info(ctx.channel().remoteAddress()+"===>server: "+msg.toString());
        ctx.write("hi, received your msg");
        ctx.flush();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        super.exceptionCaught(ctx, cause);
        ctx.close();
    }

}

客户端代码：

client:

package com.rickiyang.learn.helloWorld;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import lombok.extern.slf4j.Slf4j;

/**
 * @author: rickiyang
 * @date: 2020/3/15
 * @description:
 */
@Slf4j
public class HwClient {

    private  int port;
    private  String address;

    public HwClient(int port, String address) {
        this.port = port;
        this.address = address;
    }

    public void start(){
        EventLoopGroup group = new NioEventLoopGroup();

        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .handler(new ClientChannelInitializer());
        try {
            ChannelFuture future = bootstrap.connect(address,port).sync();
            future.channel().writeAndFlush("Hello world, i'm online");
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            log.error("client start fail",e);
        }finally {
            group.shutdownGracefully();
        }

    }

    public static void main(String[] args) {
        HwClient client = new HwClient(7788,"127.0.0.1");
        client.start();
    }
}

client initializer :

package com.rickiyang.learn.helloWorld;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

/**
 * Created by Administrator on 2017/3/11.
 */
public class ClientChannelInitializer extends  ChannelInitializer<SocketChannel> {

    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();

        pipeline.addLast("decoder", new StringDecoder());
        pipeline.addLast("encoder", new StringEncoder());

        // 客户端的逻辑
        pipeline.addLast("handler", new HwClientHandler());
    }
}

client handler :

package com.rickiyang.learn.helloWorld;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import lombok.extern.slf4j.Slf4j;

/**
 * @author: rickiyang
 * @date: 2020/3/15
 * @description:
 */
@Slf4j
public class HwClientHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        log.info("server say : " + msg.toString());
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        log.info("client channelActive");
        ctx.fireChannelActive();
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        log.info("Client is close");
    }


}

代码很简单，主要功能就是启动 服务端 和 客户端， 然后实现一个简单的 handler ，在handler 中获取消息并打印，本地先启动服务端 main 函数，再启动客户端即可。

2. 从 EventLoopGroup 开始说起

观看客户端 和 服务端 的启动类，我们看到都有相同的特性：

创建 EventLoopGroup 去监听 channel，然后使用定义的 handler处理对应的事件。

Netty 是一个异步事件驱动的 NIO 框架，所有IO操作都是异步非阻塞的。Netty 实际上是使用 Threads（多线程）处理 I/O 事件。

EventLoopGroup 是个啥东西呢？我们回想一下 Reactor 模型，主要的操作是使用 Selector 监听 channel 上的事件，Reactor 模型有三种结构，首先是单线程模型：

这种模型显而易见始终只有一个 Acceptor 线程在处理客户端连接事件和服务端产生的读写事件，好处是始终只有一个线程在工作不会产生并发带来的一系列问题。但是不足之处也显而易见：

1. 一个线程来处理对于现在的多核系统来说有点浪费资源；
2. 虽然是使用异步非阻塞I/O处理，但是面对大并发的请求场景，很有可能会负载过重，堆积事件，这样客户端就会有超时发生，然后重复发送请求，必然会造成系统超载；
3. 单线程如果挂掉了系统就停止了，这种场景如何处理。

所以这种单线程模型对于当今系统的发展是没有适用场景的。接着又演变出多线程的 Reactor 模型。

在多线程模型下，Acceptor 是一个单独的线程专门处理 Client 的请求连接事件，所有的 I/O 操作都由一个特定的 NIO 线程池负责，每个客户端都与一个特定的 NIO 线程池绑定，因此这个客户端连接中的所有 I/O 操作都是在同一个线程中完成的。客户端连接是很多的，但是 NIO 线程很少，所以 一个 NIO 线程可以同时绑定到多个客户端连接中。

从上面的模型找缺点的话，很显然能发现还是有单点的问题：处理客户端连接请求的线程仍旧只有一个，如果这个线程挂了，整个系统将不可用。所以这种超级并发的情况也要考虑啊，系统不能有单点，接着改：

现在的系统就没有单点问题了，但是也增加了复杂性。

我们刚才在说 EventLoopGroup ，为啥突然又转到了 Reactor 模型上去了呢？ 前面说过，Netty 是基于 NIO 编程的，NIO 又是基于 Reactor 模型的，自然 Netty 的编程模型也是 Reactor 。而 EventLoopGroup 其实就是来设置 Reactor 模型的类型根据不同的参数方式。

我们来看 Server 启动类中的写法：

EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workGroup = new NioEventLoopGroup();

ServerBootstrap server = new ServerBootstrap().group(bossGroup,workGroup)
    .channel(NioServerSocketChannel.class)
    .childHandler(new ServerChannelInitializer());

这里创建了两个 group，下面 bootstrap set group的时候 set了两个线程池，即 Acceptor 使用一个线程池，一个 Reactor 线程池。但是可以看到两个线程池都没有设置大小，进去 NioEventLoopGroup 的构造方法可以看到 默认值是 0，即初始化为0，不开启线程，当有事件进来的时候会开启一个线程来处理。那么如果将 workGroup 设置为多个线程的时候，上面这种写法就是 Reactor 的多线程模型。

我们再来看另一种写法：

EventLoopGroup bossGroup = new NioEventLoopGroup();

ServerBootstrap server = new ServerBootstrap().group(bossGroup)
    .channel(NioServerSocketChannel.class)
    .childHandler(new ServerChannelInitializer());

这里的 group() 方法与上面的区别在于只有一个参数，进入方法内部看看：

@Override
public ServerBootstrap group(EventLoopGroup group) {
    return group(group, group);
}

/**
     * Set the {@link EventLoopGroup} for the parent (acceptor) and the child (client). These
     * {@link EventLoopGroup}'s are used to handle all the events and IO for {@link ServerChannel} and
     * {@link Channel}'s.
     */
public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
    super.group(parentGroup);
    if (childGroup == null) {
        throw new NullPointerException("childGroup");
    }
    if (this.childGroup != null) {
        throw new IllegalStateException("childGroup set already");
    }
    this.childGroup = childGroup;
    return this;
}

很明显它调用了带两个 EventLoopGroup 参数的 group方法，即两个 group 线程池使用的是同一个。这就是 Reactor 的单线程模型。

还有一个 Reactor 的主从多线程模型，这个在 Netty 中是没有实现的，即你将 bossGroup 的线程设置为大于1，这个不会改变 Acceptor 的时候事件处理方式，因为在服务端启动的时候 ServerSocketChannel 只会绑定到 bossGroup 中的一个线程，即使你设置了多个，启动的时候只会使用一个。Netty 官方认为处理连接请求的时候没有必要使用多线程的方式。

现在我们了解到 EventLoopGroup 的作用是初始化线程池的，那就一起看看它是怎么实现的吧。

首先看一下 EventLoopGroup 的类结构图：

可以看到它继承了 ScheduledExecutorService，即 EventLoopGroup 有线程池调度的能力。上面在代码中我们使用的是 EventLoopGroup 的子类 NioEventLoopGroup， 还有一个OioEventLoopGroup也可以使用。继续看 NioEventLoopGroup 的类结构：

可以看到继承关系为：NioEventLoopGroup -> MultithreadEventLoopGroup -> MultithreadEventExecutorGroup。

先看一下我们使用的默认无参构造方法：

public NioEventLoopGroup() {
    this(0);
}

这里默认设置为 0 ，但是后面的逻辑会判断如果为 0，那么会将 线程数设置为当前 CPU * 2。

public NioEventLoopGroup(int nThreads) {
    this(nThreads, (Executor) null);
}

这个构造函数将 线程执行的 Executor 设置为空，后面会判断为空重新构造一个 Executor。

public NioEventLoopGroup(int nThreads, Executor executor) {
    this(nThreads, executor, SelectorProvider.provider());
}

public NioEventLoopGroup(
    int nThreads, ThreadFactory threadFactory, final SelectorProvider selectorProvider) {
    this(nThreads, threadFactory, selectorProvider, DefaultSelectStrategyFactory.INSTANCE);
}

public NioEventLoopGroup(int nThreads, Executor executor, final SelectorProvider selectorProvider,
                             final SelectStrategyFactory selectStrategyFactory) {
    super(nThreads, executor, selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject());
}

上面第一个构造方法是使用了 JDK 的 NIO 生成一个 Selector，第二个是生成一个 Selector 默认策略。接着进入第三个构造方法，这里使用了父类 MultithreadEventLoopGroup 的 构造方法，还 set 了一个线程拒绝策略。

跟进父类的构造方法：

protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
    super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
}

private static final int DEFAULT_EVENT_LOOP_THREADS;

static {
    DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
        "io.netty.eventLoopThreads", Runtime.getRuntime().availableProcessors() * 2));

    if (logger.isDebugEnabled()) {
        logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
    }
}

这里对线程数进行了判断，如果是 0 则赋默认值，这里的默认值就是当前核心数 * 2。

接下来又调用了它的父类 MultithreadEventExecutorGroup 的构造器：

protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
    this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
}

再点击进入，终于能看到一段实质性的代码了，太不容易：

/**
     * 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));
    }

    //上面我们有个构造函数传 executor == null。在这里判断如果为空，则创建一个新的ThreadPerTaskExecutor
    if (executor == null) {
        executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
    }
	// 这里就是创建指定大小的线程池，线程池中的每一个元素都是一个 EventLoop
    children = new EventExecutor[nThreads];

    for (int i = 0; i < nThreads; i ++) {
        boolean success = false;
        try {
            //存入了一个 NIOEventLoop 类实例
            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;
                    }
                }
            }
        }
    }
	//实例化线程工厂执行器选择器: 根据children获取选择器
    chooser = chooserFactory.newChooser(children);

    //为每一个 EventLoop 线程添加一个 线程终止的监听器
    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);
    }
	// 到这里 eventLoop 就创建完毕，接着做了一个操作：把 eventLoop 添加进一个新的不可变的 set集合中，即声明只读属性
    Set<EventExecutor> childrenSet = new LinkedHashSet<EventExecutor>(children.length);
    Collections.addAll(childrenSet, children);
    readonlyChildren = Collections.unmodifiableSet(childrenSet);
}

这段代码的实质就是来创建 EventLoop 实例，并 set 线程执行。

1. 首先校验 executor 是否为空，如果是空，则新建一个 ThreadPerTaskExecutor 对象。这个 executor 是用来执行线程池中的所有的线程，也就是所有的 NioEventLoop，其实从 NioEventLoop 构造器中也可以知道，NioEventLoop 构造器中都传入了executor这个参数
2. 接着创建了一个指定大小的线程池，这里的线程池就是用来执行我们的 EventLoop，即监听事件。
3. 下面就开始往线程池中放东西了，for 循环的开始是一个 newChild(executor, args)方法，这个方法主要实现的功能就是 new 出一个 NioEventLoop 实例，具体可以参考 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]);
}

4. eventLoop 创建完毕，下面的操作就是一个安全性保护，这里就可以使用了。当有 I/O 事件来，就从线程池中取出一个线程来执行，那么怎么取就是根据 chooser 选择器的策略来执行， 调用选择器的 next()方法。

这里线程的初始化就结束了，所以这么多的转跳只做了一个事情：创建 Selector 的线程池。

3. NioEventLoop 做了什么

上面分析了 EventLoopGroup 的作用是定义了一个线程池，创建 EventLoop，而EventLoop 的作用不言而喻，按照 Reactor 模型来理解，大概就是两件事：监听连接请求，将事件分发给 handler 处理。下面我们就详细分析一下 NioEventLoop 的代码。

入口就是 newChild()方法，返回的是 EventLoopGroup 的构造函数。

NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
             SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler) {
    super(parent, executor, false, DEFAULT_MAX_PENDING_TASKS, rejectedExecutionHandler);
    if (selectorProvider == null) {
        throw new NullPointerException("selectorProvider");
    }
    if (strategy == null) {
        throw new NullPointerException("selectStrategy");
    }
    provider = selectorProvider;
    selector = openSelector();
    selectStrategy = strategy;
}

//父类构造函数
protected SingleThreadEventLoop(EventLoopGroup parent, Executor executor,
                                boolean addTaskWakesUp, int maxPendingTasks,
                                RejectedExecutionHandler rejectedExecutionHandler) {
    super(parent, executor, addTaskWakesUp, maxPendingTasks, rejectedExecutionHandler);
    //创建了一个指定大小的队列
    tailTasks = newTaskQueue(maxPendingTasks);
}

//父类的父类构造函数
protected SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor,
                                    boolean addTaskWakesUp, int maxPendingTasks,
                                    RejectedExecutionHandler rejectedHandler) {
    super(parent);
    this.addTaskWakesUp = addTaskWakesUp;
    this.maxPendingTasks = Math.max(16, maxPendingTasks);
    this.executor = ObjectUtil.checkNotNull(executor, "executor");
    taskQueue = newTaskQueue(this.maxPendingTasks);
    rejectedExecutionHandler = ObjectUtil.checkNotNull(rejectedHandler, "rejectedHandler");
}

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

    if (DISABLE_KEYSET_OPTIMIZATION) {
        return selector;
    }

    final SelectedSelectionKeySet selectedKeySet = new SelectedSelectionKeySet();

    Object maybeSelectorImplClass = AccessController.doPrivileged(new PrivilegedAction