从IO到NIO再到Netty

Netty是一个基于NIO的异步事件驱动的网络应用框架，用于快速开发可维护的高性能协议服务器和客户端。Netty在Java NIO的基础上提供了更高层的抽象和封装，因此要想对Netty有所深入了解，势必要对Java.NIO有所了解，而NIO是对传统IO由阻塞向异步非阻塞IO的巨大跨越，因此了解传统Java.IO对了解Java.NIO也大有裨益。

传统IO

java.io最核心的一个概念是流（Stream），java.io可以看成是面向流的编程，它将数据的输入输出抽象为流，流是一组有顺序的，单向的，有起点和终点的数据集合，就像水流。在Java中，一个流要么是输入流，要么是输出流。按照流中的最小数据单元又分为字节流和字符流。

字节流：以 8 位（即1byte=8bit）作为一个数据单元，数据流中最小的数据单元是字节。它的顶级父类是InputStream和OutputStream。

字符流：以 16 位（即1char=2byte=16bit）作为一个数据单元，数据流中最小的数据单元是字符， Java 中的字符是 Unicode 编码，一个字符占用两个字节。它的顶级父类是Reader和Writer。

所有的Java IO流都是阻塞的，这意味着，当一条线程执行accept()，read()或者write()方法时，这条线程会一直阻塞直到有连接请求，或读取到了一些数据或者要写出去的数据已经全部写出，在这期间这条线程不能做任何其他的事情，而如果想支持多个连接，那就需为每个连接新开个线程去支持读写操作

非阻塞Reactor模式引入

随着网络应用的发展和网络服务的用户逐渐增多，需要有一种新的方案去解决传统网络的这种问题，在上世纪90年代，便提出了一种Reactor模式，Reactor模式是一种高并发事件驱动的网络服务模式，它的实现可以用Java实现、C++实现或其他语言实现，而java.nio就是依照reactor模式设计的，此外，其他的一些框架也采用（或实现）了Reactor模式，如Redis，Nginx，Netty（Netty是Java NIO更高层的抽象）等。多种Reactor模型的框架及流程图如下所示：

NIO网络编程

java.nio中拥有3个核心概念：selector，channel，buffer；java.nio中，面向块(block)或是缓冲区(buffer)编程的，buffer本身就是一块内存，实际就是个数组，数据的读.写都是通过buffer来实现的。java中的原生8种基本数据类型都有各自对应的buffer类型，（除Boolean外），如IntBuffer,CharBuffer,ByteBuffer,LongBuffer,ShortBuffer所有数据的读写都是通过buffer来进行的，永远不会出现直接channel中直接写入，读取数据与stream不同的是，channel是双向的，一个流只可能是InputStream或是OutputStream，channel则是双向的，channel打开后可以进行读又可以进行写。

java.nio就是依照reactor模式设计的，我们再看一个Java NIO网络编程的一个简单例子，由此将进入对传统Java NIO的介绍：

从上述代码可以看出，一个单线程的java.nio的网络编程流程基本为：

1.创建一个selector；

2.创建一个或多个Channel通道，注册到selector，并注册关心事件；

3.调用select()方法，阻塞等待关心事件发生，关心事件发生后，通过循环SelectionKey集合，再通过SelectionKey获取相关联的通道处理相应事件。

Java NIO有三大核心组件：

1.Channel

Java NIO中的所有I/O操作都基于Channel对象，就像流操作都要基于Stream对象一样。一个Channel（通道）代表和某一实体的连接，这个实体可以是文件、网络套接字等。也就是说，通道是Java NIO提供的一座桥梁，用于我们的程序和操作系统底层I/O服务进行交互。一个通道Channel，既可以读又可以写，而一个Stream是单向的。

2.Buffer

NIO中所使用的缓冲区不是一个简单的byte数组，而是封装过的Buffer类，通过它提供的API，我们可以灵活的操纵数据。在Java NIO当中，我们是面向（块）或是缓冲区（buffer）编程的。Buffer本身就是一块内存，底层实现除了数组之外，Buffer还提供了对于数据的结构化访问方式，并且可以追踪到系统的读写过程。

NIO提供了多种 Buffer 类型与Java基本类型相对应（但没有BoolBuffer），如ByteBuffer、CharBuffer、IntBuffer等，区别就是读写缓冲区时的单位长度不一样。Buffer中有3个很重要的变量，它们是理解Buffer工作机制的关键，分别是capacity （总容量）、position （指针当前位置）、limit （读/写边界位置）。

capacity：最大容量，它永远不可能为负数，并且是不会变化的

limit：限制，它永远不可能为负数，并且不会大于capacity

position：下一个读或写的位置，它永远不可能为负数，并且不会大于limit

在对Buffer进行读/写的过程中，position会往后移动，而 limit 就是 position 移动的边界。由此不难想象，在对Buffer进行写入操作时，limit应当设置为capacity的大小，而对Buffer进行读取操作时，limit应当设置为数据的实际结束位置。（注意：将Buffer数据写入通道是Buffer 读取操作，从通道读取数据到Buffer是Buffer 写入操作）

在对Buffer进行读/写操作前，我们可以调用Buffer类提供的一些辅助方法来正确设置 position 和 limit 的值，主要有如下几个

flip(): 设置 limit 为 position 的值，然后 position 置为0。对Buffer进行读取操作前调用。

rewind(): 仅仅将 position 置0。一般是在重新读取Buffer数据前调用，比如要读取同一个Buffer的数据写入多个通道时会用到。

clear(): 回到初始状态，即 limit 等于 capacity，position 置0。重新对Buffer进行写入操作前调用。

compact(): 将未读取完的数据（position 与 limit 之间的数据）移动到缓冲区开头，并将 position 设置为这段数据末尾的下一个位置。其实就等价于重新向缓冲区中写入了这么一段数据。

3.Selector

Selector（选择器）是一个特殊的组件，用于采集各个通道的状态（或者说事件）。我们先将通道Channel注册到选择器Selector，并设置好关心的事件，然后就可以通过调用select()方法，静静地等待事件发生。

通道有如下4个事件可供我们监听：

Accept：有可以接受的连接

Connect：连接成功

Read：有数据可读

Write：可以写入数据了

一个channel注册到selector上，这个动作是通过selectionKey来表示的；一个selector会维护三种selectionKey的集合：

key set 表示注册到selector上面所有的selectionKey，通过keys()方法返回全集

selected-key set 表示感兴趣的selectionKey 通过selectedKeys()方法返回子集

SelectionKey是一个抽象类，表示selectableChannel在Selector中注册的标识。每个Channel向Selector注册时，都将会创建一个selectionKey选择键，将Channel与Selector建立了关系，并维护channel事件。可以通过cancel方法取消键，取消的键不会立即从selector中移除，而是添加到cancelledKeys中，在下一次select操作时移除它，所以在调用某个key时,需要使用isValid进行校验。

SelectionKey方法列表：

public abstract SelectableChannel channel():返回此选择键所关联的通道.即使此key已经被取消,仍然会返回.

public abstract Selector selector():返回此选择键所关联的选择器,即使此键已经被取消,仍然会返回.

public abstract boolean isValid():检测此key是否有效.当key被取消,或者通道被关闭,或者selector被关闭,都将导致此key无效.在AbstractSelector.removeKey(key)中,会导致selectionKey被置为无效.

public abstract void cancel():请求将此键取消注册.一旦返回成功,那么该键就是无效的,被添加到selector的cancelledKeys中.cancel操作将key的valid属性置为false,并执行selector.cancel(key)(即将key加入cancelledkey集合)

public abstract int interesOps():获得此键的interes集合.

public abstract SelectionKey interestOps(int ops):将此键的interst设置为指定值.此操作会对ops和channel.validOps进行校验.如果此ops不会当前channel支持,将抛出异常.

public abstract int readyOps():获取此键上ready操作集合.即在当前通道上已经就绪的事件.

public final boolean isReadable(): 检测此键是否为"read"事件.等效于:k.,readyOps() & OP_READ != 0;还有isWritable(),isConnectable(),isAcceptable()

public final Object attach(Object ob):将给定的对象作为附件添加到此key上.在key有效期间,附件可以在多个ops事件中传递.

public final Object attachment():获取附件.一个channel的附件,可以再当前Channel(或者说是SelectionKey)生命周期中共享,但是attachment数据不会作为socket数据在网络中传输.

为什么要用Selector？

如果用阻塞I/O，需要多线程（浪费内存），如果用非阻塞I/O，需要不断重试（耗费CPU）。Selector的出现解决了这尴尬的问题，非阻塞模式下，通过Selector，我们的线程只为已就绪的通道工作，不用盲目的重试了。比如，当所有通道都没有数据到达时，也就没有Read事件发生，我们的线程会在select()方法处被挂起，从而让出了CPU资源。

Selector的使用：

创建一个Selector，并注册一个Channel。注意：要将 Channel 注册到 Selector，首先需要将 Channel 设置为非阻塞模式，否则会抛异常。

Selector selector = Selector.open();

channel.configureBlocking(false);

SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

register()方法的第二个参数名叫“interest set”，也就是你所关心的事件集合。如果你关心多个事件，用一个“按位或运算符”分隔，比如：SelectionKey.OP_READ | SelectionKey.OP_WRITE。

这种写法一点都不陌生，支持位运算的编程语言里都这么玩，用一个整型变量可以标识多种状态，它是怎么做到的呢，其实很简单，举个例子，首先预定义一些常量，它们的值（二进制）如下：

可以发现，它们值为1的位都是错开的，因此对它们进行按位或运算之后得出的值就没有二义性，可以反推出是由哪些变量运算而来。怎么判断呢，没错，就是“按位与”运算。比如，现在有一个状态集合变量值为 0011，只需要判断 “0011 & OP_READ” 的值是 1 还是 0 就能确定集合是否包含 OP_READ 状态。

然后，注意 register() 方法返回了一个SelectionKey的对象，这个对象包含了本次注册的信息，也可以通过它修改注册信息。

Netty对Java NIO的抽象

Netty 是一个利用 Java 的高级网络的能力，隐藏其背后的复杂性而提供一个易于使用的 API 的客户端/服务器框架。Netty 是一款提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。

ChannelInboundHandler:入栈处理器，对于入栈而言，只会走1和3处理器；ChannelOutboundHandler：出栈处理器，对于出栈，只会走2处理器

Nettty 有如下几个核心组件：

Bootstrap or ServerBootstrap

EventLoop

EventLoopGroup

ChannelPipeline

Channel

Future or ChannelFuture

ChannelInitializer

ChannelHandler

Bootstrap

一个Netty应用通常由一个Bootstrap开始，它主要作用是配置整个Netty程序，串联起各个组件。

Channel

Channel 是 Netty 网络操作抽象类，它除了包括基本的 I/O 操作，如 bind、connect、read、write 之外，还包括了 Netty 框架相关的一些功能，如获取该 Channe l的 EventLoop。

在传统的网络编程中，作为核心类的 Socket ，它对程序员来说并不是那么友好，直接使用其成本还是稍微高了点。而Netty 的 Channel 则提供的一系列的 API ，它大大降低了直接与 Socket 进行操作的复杂性。而相对于原生 NIO 的 Channel，Netty 的 Channel 具有如下优势（摘自《Netty权威指南》）：

在 Channel 接口层，采用 Facade 模式进行统一封装，将网络 I/O 操作、网络 I/O 相关联的其他操作封装起来，统一对外提供。

Channel 接口的定义尽量大而全，为 SocketChannel 和 ServerSocketChannel 提供统一的视图，由不同子类实现不同的功能，公共功能在抽象父类中实现，最大程度地实现功能和接口的重用。

具体实现采用聚合而非包含的方式，将相关的功能类聚合在 Channel 中，有 Channel 统一负责和调度，功能实现更加灵活。

EventLoop

Netty 基于事件驱动模型，使用不同的事件来通知我们状态的改变或者操作状态的改变。它定义了在整个连接的生命周期里当有事件发生的时候处理的核心抽象。

Channel 为Netty 网络操作抽象类，EventLoop 主要是为Channel 处理 I/O 操作，两者配合参与 I/O 操作。

下图是Channel、EventLoop、Thread、EventLoopGroup之间的关系（摘自《Netty In Action》）：

一个 EventLoopGroup 包含一个或多个 EventLoop。

一个 EventLoop 在它的生命周期内只能与一个Thread绑定。

所有有 EnventLoop 处理的 I/O 事件都将在它专有的 Thread 上被处理。

一个 Channel 在它的生命周期内只能注册与一个 EventLoop。

一个 EventLoop 可被分配至一个或多个 Channel 。

当一个连接到达时，Netty 就会注册一个 Channel，然后从 EventLoopGroup 中分配一个 EventLoop 绑定到这个Channel上，在该Channel的整个生命周期中都是有这个绑定的 EventLoop 来服务的。

ChannelFuture

Netty 为异步非阻塞，即所有的 I/O 操作都为异步的，因此，我们不能立刻得知消息是否已经被处理了。Netty 提供了 ChannelFuture 接口，通过该接口的 addListener() 方法注册一个 ChannelFutureListener，当操作执行成功或者失败时，监听就会自动触发返回结果。

ChannelInitializer

当一个链接建立时，我们需要知道怎么来接收或者发送数据，当然，我们有各种各样的Handler实现来处理它，那么ChannelInitializer便是用来配置这些Handler，它会提供一个ChannelPipeline，并把Handler加入到ChannelPipeline。

ChannelHandler

Handler为了支持各种协议和处理数据的方式，便诞生了Handler组件。Handler主要用来处理各种事件，这里的事件很广泛，比如可以是连接、数据接收、异常、数据转换等。ChannelHandler 为 Netty 中最核心的组件，它充当了所有处理入站和出站数据的应用程序逻辑的容器。ChannelHandler 主要用来处理各种事件，这里的事件很广泛，比如可以是连接、数据接收、异常、数据转换等。

ChannelHandler 有两个核心子类 ChannelInboundHandler 和 ChannelOutboundHandler，其中 ChannelInboundHandler 用于接收、处理入站数据和事件，而 ChannelOutboundHandler 则相反。

ChannelPipeline

一个Netty应用基于ChannelPipeline机制，这种机制需要依赖于EventLoop和EventLoopGroup，因为它们三个都和事件或者事件处理相关。ChannelPipeline 为 ChannelHandler 链提供了一个容器并定义了用于沿着链传播入站和出站事件流的 API。一个数据或者事件可能会被多个 Handler 处理，在这个过程中，数据或者事件经流 ChannelPipeline，由 ChannelHandler 处理。在这个处理过程中，一个 ChannelHandler 接收数据后处理完成后交给下一个 ChannelHandler，或者什么都不做直接交给下一个 ChannelHandler。

当一个数据流进入 ChannlePipeline 时，它会从 ChannelPipeline 头部开始传给第一个 ChannelInboundHandler ，当第一个处理完后再传给下一个，一直传递到管道的尾部。与之相对应的是，当数据被写出时，它会从管道的尾部开始，先经过管道尾部的 “最后” 一个ChannelOutboundHandler，当它处理完成后会传递给前一个 ChannelOutboundHandler 。

当 ChannelHandler 被添加到 ChannelPipeline 时，它将会被分配一个 ChannelHandlerContext，它代表了 ChannelHandler 和 ChannelPipeline 之间的绑定，数据在各个Handler之间传递，这需要调用方法中传递的ChanneHandlerContext来操作，在netty的API中提供了两个基类分ChannelOutboundHandlerAdapter和ChannelOutboundHandlerAdapter，他们仅仅实现了调用ChanneHandlerContext来把消息传递给下一个Handler，因为我们只关心处理数据，因此我们的程序中可以继承这两个基类来帮助我们做这些，而我们仅需实现处理数据的部分即可。其中 ChannelHandler 添加到 ChannelPipeline 过程如下：

1.一个 ChannelInitializer 的实现被注册到了 ServerBootStrap中

2.当 ChannelInitializer.initChannel() 方法被调用时，ChannelInitializer 将在 ChannelPipeline 中安装一组自定义的 ChannelHandler

3.ChannelInitializer 将它自己从 ChannelPipeline 中移除

我们知道InboundHandler和OutboundHandler在ChannelPipeline中是混合在一起的，那么它们如何区分彼此呢？其实很容易，因为它们各自实现的是不同的接口，对于inbound event，Netty会自动跳过OutboundHandler,相反若是outbound event，ChannelInboundHandler会被忽略掉。

当一个ChannelHandler被加入到ChannelPipeline中时，它便会获得一个ChannelHandlerContext的引用，而ChannelHandlerContext可以用来读写Netty中的数据流。因此，现在可以有两种方式来发送数据，一种是把数据直接写入Channel，一种是把数据写入ChannelHandlerContext，它们的区别是写入Channel的话，数据流会从Channel的头开始传递，而如果写入ChannelHandlerContext的话，数据流会流入管道中的下一个Handler。

Netty的服务端，一般会启动两个NioEventLoopGroup线程组（个人感觉用组比用池更准确，这里组指数组），一个为bossGroup线程组，处理客户端的连接请求；一个workerGroup线程组，用来处理IO事件。实例化NioEventLoopGroup时，如果在这里没有设置参数，也没有在JVM参数里设置“-Dio.netty.eventLoopThreads=x”，那么这个线程组的默认线程数为CPUx2，否则为设置的参数值，对于bossGroup来说，即使是创建了CPUx2的线程数，其实只有一个处于工作状态。

Channels、Events 和 IO之间的关系

一个Channel会对应一个EventLoop，而一个EventLoop会对应着一个线程，也就是说，仅有一个线程在负责一个Channel的IO操作。如下图所示：

当一个连接到达，Netty会注册一个channel，然后EventLoopGroup会分配一个EventLoop绑定到这个channel,在这个channel的整个生命周期过程中，都会由绑定的这个EventLoop来为它服务，而这个EventLoop就是一个线程。

netty中的bytebuf

ByteBuf是一个存储字节的容器，最大特点就是使用方便，它既有自己的读索引和写索引，方便你对整段字节缓存进行读写，也支持get/set，方便你对其中每一个字节进行读写，bytebuf结构：

从0到readerIndex表示已经读过的字节，可以丢弃的字节；readerIndex到writerIndex表示可以读取的字节；writerIndex到capacity可以写的字节数。

ByteBuf有三种使用模式：

1.Heap Buffer 堆缓冲区：堆缓冲区是ByteBuf最常用的模式，他将数据存储在堆空间。

2.Direct Buffer 直接缓冲区：直接缓冲区是ByteBuf的另外一种常用模式，他的内存分配都不发生在堆，jdk1.4引入的nio的ByteBuffer类允许jvm通过本地方法调用分配内存，这样做有两个好处：1)、通过免去中间交换的内存拷贝, 提升IO处理速度; 直接缓冲区的内容可以驻留在垃圾回收扫描的堆区以外。2)、DirectBuffer 在 -XX:MaxDirectMemorySize=xxM大小限制下, 使用 Heap 之外的内存, GC对此”无能为力”,也就意味着规避了在高负载下频繁的GC过程对应用线程的中断影响.

3.Composite Buffer 复合缓冲区：复合缓冲区相当于多个不同ByteBuf的视图，这是netty提供的，jdk不提供这样的功能。

```

if (executor == null) {

//后续Netty对各种IO事件的处理就是通过此executor创建线程处理的

executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());

}

//创建NIOEventLoop数组

children = new EventExecutor[nThreads];

for (int i = 0; i < nThreads; i ++) {

boolean success = false;

try {

//实例化每个NIOEventLoop，每个NIOEventLoop公用Executor、SelectorProvider、EventExecutorChooserFactory、RejectedExecutionHandlers

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 {

//......

}

//选择器，选择由哪个NIOEventLoop处理，注意这里以children作为传参

chooser = chooserFactory.newChooser(children);

```

在实例化NIOEventLoopGroup时，首先创建了一个Executor，而Executor的作用就是通常被用来代替显示地创建线程的，Executor对象可以用来执行Runnable任务，该接口将“任务提交”从任务的运行机制中解耦出来，包括线程使用、调度等细节。NIOEventLoopGroup其实是一个NIOEventLoop的数组，每个NIOEventLoop都公用了一个Executor，后续创建线程的事都由Executor来创建，由threadFactory.newThread(command).start();

closeFuture方法是等待关闭，加上sync()方法，该方法会阻塞；如果没有sync()，它会立即返回。