RPC入门总结（四）RPC IO基础：Netty原理和使用

转载：Java 编程思想（七） BIO/NIO/AIO的区别(Reactor和Proactor的区别)

转载：Java 编程思想（八）BIO/NIO/AIO的具体实现

转载：源码之下无秘密 ── 做最好的 Netty 源码分析教程

转载：架构设计：系统间通信（6）——IO通信模型和Netty 上篇

转载：架构设计：系统间通信（7）——IO通信模型和Netty 下篇

转载：Netty——基本使用介绍

转载：Netty系列之Netty线程模型

转载：Netty实现原理浅析

转载：Netty 之 Netty生产级的心跳和重连机制

一、Netty

Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。

二、Netty架构

Netty中包含的内容繁多，支持NIO和BIO模式，支持多种传输协议（HTTP/ProtoBuf/文本&二进制传输协议等），除此之外也支持安全特性，其特点如下：

1. 丰富的缓冲实现：

Netty使用自建的buffer API，而不是使用 NIO的 ByteBuffer来代表一个连续的字节序列。与 ByteBuffer相比这种方式拥有明显的优势。Netty使用新的 buffer 类型ChannelBuffer，ChannelBuffer被设计为一个可从底层解决 ByteBuffer 问题，并可满足日常网络应用开发需要的缓冲类型。这些很酷的特性包括： 
1. 如果需要，允许使用自定义的缓冲类型。 
2. 复合缓冲类型中内置的透明的零拷贝实现。 
3. 开箱即用的动态缓冲类型，具有像 StringBuffer 一样的动态缓冲能力。
4. 不再需要调用的 flip()方法。 
5. 正常情况下具有比 ByteBuffer更快的响应速度。

2.统一的异步I/O API

Netty有一个叫做 Channel 的统一的异步 I/O编程接口，这个编程接口抽象了所有点对点的通信操作。也就是说，如果你的应用是基于 Netty的某一种传输实现，那么同样的，你的应用也可以运行在 Netty 的另一种传输实现上。Netty提供了几种拥有相同编程接口的基本传输实现： 

  NIO-based TCP/IP transport (See org.jboss.netty.channel.socket.nio), 
  OIO-based TCP/IP transport (See org.jboss.netty.channel.socket.oio), 
  OIO-based UDP/IP transport, and 
  Local transport (See org.jboss.netty.channel.local). 
切换不同的传输实现通常只需对代码进行几行的修改调整，例如选择一个不同的 ChannelFactory实现。 
此外，你甚至可以利用新的传输实现没有写入的优势，只需替换一些构造器的调用方法即可，例如串口通信。而且由于核心 API 具有高度的可扩展性，你还可以完成自己的传输实现。 

3.基于拦截链模式的事件触发模型

一个定义良好并具有扩展能力的事件模型是事件驱动开发的必要条件。 Netty具有定义良好的I/O事件模型。由于严格的层次结构区分了不同的事件类型，因此 Netty也允许你在不破坏现有代码的情况下实现自己的事件类型。这是与其他框架相比另一个不同的地方。

很多 NIO 框架没有或者仅有有限的事件模型概念；在你试图添加一个新的事件类型的时候常常需要修改已有的代码，或者根本就不允许你进行这种扩展。 在一个ChannelPipeline内部一个ChannelEvent被一组ChannelHandler处理。这个管道是拦截过滤器 模式的一种高级形式的实现，因此对于一个事件如何被处理以及管道内部处理器间的交互过程，你都将拥有绝对的控制力。

Netty使用主从Reactor模式，在实现上，Netty中的Boss类充当mainReactor，NioWorker类充当subReactor（默认 NioWorker的个数是Runtime.getRuntime().availableProcessors()）。在处理新来的请求 时，NioWorker读完已收到的数据到ChannelBuffer中，之后触发ChannelPipeline中的ChannelHandler流。

4.适用快速开发的高级组件：

4.1.Codec框架：

从业务逻辑代码中分离协议处理部分总是一个很不错的想法。然而如果一切从零开始便会遭遇到实现上的复杂性。你不得不处理分段的消息。一些协议是多层的（例如构建在其他低层协议之上的协议）。一些协议过于复杂以致难以在一台主机（single state machine）上实现。 因此，一个好的网络应用框架应该提供一种可扩展，可重用，可单元测试并且是多层的 codec 框架，为用
户提供易维护的 codec 代码。 
Netty提供了一组构建在其核心模块之上的 codec 实现，这些简单的或者高级的 codec 实现帮你解决了大部分在你进行协议处理开发过程会遇到的问题，无论这些协议是简单的还是复杂的，二进制的或是简单文本的。

4.2.SSL/TSL支持：

不同于传统阻塞式的 I/O实现，在 NIO模式下支持 SSL 功能是一个艰难的工作。你不能只是简单的包装一下流数据并进行加密或解密工作，你不得不借助于javax.net.ssl.SSLEngine，SSLEngine是一个有状态的实现，其复杂性不亚于 SSL 自身。你必须管理所有可能的状态，例如密码套件，密钥协商（或重新协商），证书交换以及认证等。此外，与通常期望情况相反的是 SSLEngine 甚至不是一个绝对的线程安全实现。 
在 Netty内部，SslHandler 封装了所有艰难的细节以及使用 SSLEngine 可能带来的陷阱。你所做的仅是配置并将该 SslHandler 插入到你的ChannelPipeline中。同样 Netty 也允许你实现像 StartTlS 那样所拥有的高级特性，这很容易。

4.3.HTTP实现：

HTTP 无疑是互联网上最受欢迎的协议，并且已经有了一些例如 Servlet 容器这样的 HTTP 实现。因此，为什么 Netty还要在其核心模块之上构建一套 HTTP 实现？ 
与现有的 HTTP 实现相比 Netty 的 HTTP 实现是相当与众不同的。在 HTTP 消息的低层交互过程中你将拥有绝对的控制力。这是因为 Netty的 HTTP 实现只是一些HTTP codec 和 HTTP 消息类的简单组合，这里不存在任何限制——例如那种被迫选择的线程模型。你可以随心所欲的编写那种可以完全按照你期望的工作方式工作的客户端或服务器端代码。这包括线程模型，连接生命期，快编码，以及所有 HTTP 协议允许你做的，所有的一切，你都将拥有绝对的控制力。 
 
由于这种高度可定制化的特性，你可以开发一个非常高效的 HTTP 服务器，例如： 
  要求持久化链接以及服务器端推送技术的聊天服务（e.g. Comet ） 
  需要保持链接直至整个文件下载完成的媒体流服务（e.g. 2小时长的电影） 
  需要上传大文件并且没有内存压力的文件服务（e.g. 上传1GB 文件的请求） 
  支持大规模 mash-up 应用以及数以万计连接的第三方 web services 异步处理平台 

4.4.Google Protocol Buffer整合：

Google Protocol Buffers 是快速实现一个高效的二进制协议的理想方案。通过使用 ProtobufEncoder 和ProtobufDecoder，你可以把 Google Protocol Buffers 编译器  (protoc)生成的消息类放入到Netty 的 codec实现中。

三、Netty的线程模型

1. 服务端线程模型

Netty的做法是服务端监听线程和IO线程分离，即主从Reactor的模型：

Netty的主从Reactor线程模型创建过程分为如下几步：

1. 从用户线程发起创建服务端操作

public class TestTCPNetty {
    static {
        BasicConfigurator.configure();
    }

    public static void main(String[] args) throws Exception {
        ServerBootstrap serverBootstrap = new ServerBootstrap(); //这就是主要的服务启动器
        EventLoopGroup bossLoopGroup = new NioEventLoopGroup(1); //BOSS线程池
        ThreadFactory threadFactory = new DefaultThreadFactory("work thread pool"); //WORK线程池
        int processorsNumber = Runtime.getRuntime().availableProcessors();  //CPU个数
        EventLoopGroup workLoogGroup = new NioEventLoopGroup(processorsNumber * 2, threadFactory, SelectorProvider.provider());
        serverBootstrap.group(bossLoopGroup , workLoogGroup);
        //如果是以下的申明方式，说明BOSS线程和WORK线程共享一个线程池
        //serverBootstrap.group(workLoogGroup);

        serverBootstrap.channel(NioServerSocketChannel.class);
        //当然也可以这样创建（那个SelectorProvider是不是感觉很熟悉？）
        //serverBootstrap.channelFactory(new ChannelFactory() {
        //  @Override
        //  public NioServerSocketChannel newChannel() {
        //      return new NioServerSocketChannel(SelectorProvider.provider());
        //  }
        //});

        //为了演示，这里我们设置了一组简单的ByteArrayDecoder和ByteArrayEncoder
        //Netty的特色就在这一连串“通道水管”中的“处理器”
        serverBootstrap.childHandler(new ChannelInitializer() {
            @Override
            protected void initChannel(NioSocketChannel ch) throws Exception {
                ch.pipeline().addLast(new ByteArrayEncoder());
                ch.pipeline().addLast(new TCPServerHandler());
                ch.pipeline().addLast(new ByteArrayDecoder());
            }
        });

        //========================设置netty服务器绑定的ip和端口
        serverBootstrap.option(ChannelOption.SO_BACKLOG, 128);
        serverBootstrap.childOption(ChannelOption.SO_KEEPALIVE, true);
        serverBootstrap.bind(new InetSocketAddress("0.0.0.0", 83));
        //还可以监控多个端口
        //serverBootstrap.bind(new InetSocketAddress("0.0.0.0", 84));
    }
}

通常情况下，服务端的创建是在用户进程启动的时候进行，因此一般由Main函数或者启动类负责创建，服务端的创建由业务线程负责完成。在创建服务端的时候实例化了2个EventLoopGroup，1个EventLoopGroup实际就是一个EventLoop线程组，负责管理EventLoop的申请和释放。

EventLoopGroup管理的线程数可以通过构造函数设置，如果没有设置，默认取-Dio.netty.eventLoopThreads，如果该系统参数也没有指定，则为可用的CPU内核数 × 2。

bossGroup线程组实际就是Acceptor线程池，负责处理客户端的TCP连接请求，如果系统只有一个服务端端口需要监听，则建议bossGroup线程组线程数设置为1。

workerGroup是真正负责I/O读写操作的线程组，通过ServerBootstrap的group方法进行设置，用于后续的Channel绑定。当WORK线程发现操作系统有一个它感兴趣的IO事件时（例如SocketChannel的READ事件）则调用相应的ChannelHandler事件。当某个channel失效后（例如显示调用ctx.close()）这个channel将从绑定的EventLoop中被剔除。

EventLoopGroup 的初始化过程:

1. EventLoopGroup(其实是MultithreadEventExecutorGroup) 内部维护一个类型为EventExecutorchildren 数组, 其大小是 nThreads, 这样就构成了一个线程池。

2. 如果我们在实例化NioEventLoopGroup时, 如果指定线程池大小, 则 nThreads 就是指定的值, 反之是处理器核心数 * 2

3.MultithreadEventExecutorGroup中会调用 newChild 抽象方法来初始化 children 数组

4. 抽象方法 newChild 是在 NioEventLoopGroup 中实现的, 它返回一个NioEventLoop实例.

NioEventLoop 属性:

SelectorProvider   provider 属性: NioEventLoopGroup 构造器中通过 SelectorProvider.provider() 获取一个 SelectorProvider

Selector                    selector 属性: NioEventLoop 构造器中通过调用通过 selector = provider.openSelector() 获取一个selector对象.

2. Acceptor线程绑定监听端口，启动NIO服务端

Channel createChannel() {
    EventLoop eventLoop = group().next();
    return channelFactory().newChannel(eventLoop, childGroup);
}

其中group()返回的就是bossGroup，它的next方法用于从线程组中获取可用线程：

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

服务端Channel创建完成之后，将其注册到多路复用器Selector上，用于接收客户端的TCP连接，核心代码如下：

public NioServerSocketChannel(EventLoop eventLoop, EventLoopGroup childGroup) {
    super(null, eventLoop, childGroup, newSocket(), SelectionKey.OP_ACCEPT);
    config = new DefaultServerSocketChannelConfig(this, javaChannel.socket());
}

一个 NioSocketChannel 所需要做的工作:

• 调用 NioSocketChannel.newSocket(DEFAULT_SELECTOR_PROVIDER) 打开一个新的 Java NIO SocketChannel

• AbstractChannel(Channel parent) 中初始化AbstractChannel的属性:

  • parent 属性置为 null

  • unsafe 通过newUnsafe() 实例化一个 unsafe 对象, 它的类型是 AbstractNioByteChannel.NioByteUnsafe内部类

  • pipeline 是 new DefaultChannelPipeline(this) 新创建的实例. Each channel has its own pipeline and it is created automatically when a new channel is created.

• AbstractNioChannel 中的属性:

  • SelectableChannel ch 被设置为 Java SocketChannel, 即 NioSocketChannel#newSocket 返回的 Java NIO SocketChannel.

  • readInterestOp 被设置为 SelectionKey.OP_READ

  • SelectableChannel ch 被配置为非阻塞的 ch.configureBlocking(false)

• NioSocketChannel 中的属性:

  • SocketChannelConfig config = new NioSocketChannelConfig(this, socket.socket())

3. 如果监听到客户端连接，则创建客户端SocketChannel连接，重新注册到workerGroup的IO线程上。

首先看Acceptor如何处理客户端的接入：

try{
    int readyOps = k.readyOps();
    if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
        unsafe.read();
        if (!ch.isOpen()) {
            return;
        }
    }
}

调用unsafe的read（）方法，对于NioServerSocketChannel，它调用了NioMessageUnsafe的read()方法，代码如下：

Throwable exception = null;
try{
    for (; ; ) {
        int localRead = doReadMessages(readBuf);
        if (localRead == 0) {
            break;
        }
        if (localRead < 0) {
            closed = true;
            break;
        }
    }
}

最终它会调用NioServerSocketChannel的doReadMessages方法，代码如下：

protected int doReadMessages(List