## 传统的BIO编程
网络编程的基本模型是 Client/Server 模型，也就是两个进程之间进行相互通信，其中服务端提供位置信息(绑定的IP地址和监听端口)，客户端通过连接操作向服务端监听的地址发起连接请求，通过三次握手建立连接，如果连接建立成功，双方就可以通过网络套接字(Socket) 进行通信。
在基于传统同步阻塞模型开发中， ， ， ，
### BIO通信模型
通过下面的通信模型图可以发现，采用 BIO 通信模型的服务端，通常由一个独立的 Acceptor线程 负责监听客户端的连接，它接收到客户
端连接请求之后为每个客户端创建一个新的线程进行链路处理，处理完成之后，通过输出流返回应答给客户端，线程销毁。这就是典型的 “一请求一应答” 通信模型。
该模型最大的问题就是缺乏弹性伸缩能力， ， ，
在高性能服务器应用领域，往往需要面向成千上万个客户端的并发连接，这种模型显然无法满足高性能、高并发接入的场景。为了改进 一线程一连接 模型， ， ，
## 伪异步IO编程
为了解决 同步阻塞IO 面临的一个链路需要一个线程处理的问题，后来有人对它的线程模型进行了优化，后端通过一个线程池来处理多个客户端的请求接入，形成 客户端个数M： ， ，
### 伪异步IO模型图
采用线程池和任务队列可以实现一种叫做 伪异步的IO通信框架， ， ， ，
伪异步 IO通信框架 采用了线程池实现，因此避免了为每个请求都创建一个独立线程造成的线程资源耗尽问题。但是由于它底层的通信依然采用同步阻塞模型，因此无法从根本上解决问题。
### 伪异步IO编程弊端分析
要对 伪异步IO编程 的弊端进行深入分析，首先我们看两个 Java同步IO 的 API说明，
```java
public abstract class InputStream implements Closeable {
/**
* Reads the next byte of data from the input stream. The value byte is
* returned as an < code > int</ code > in the range < code > 0</ code > to
* < code > 255</ code > . If no byte is available because the end of the stream
* has been reached, the value < code > -1</ code > is returned. This method
* blocks until input data is available, the end of the stream is detected,
* or an exception is thrown.
*
* < p > A subclass must provide an implementation of this method.
*
* @return the next byte of data, or < code > -1</ code > if the end of the
* stream is reached.
* @exception IOException if an I/O error occurs.
*/
public abstract int read() throws IOException;
}
```
注意其中的一句话 ** “This method blocks until input data is available, the end of the stream is detected, or an exception is thrown”**，当对 Socket 的输入流进行读取操作的时候，它会一直阻塞下去，直到发生如下三种事件。
- 有数据可读；
- 可用数据已经读取完毕；
- 发生空指针或者 IO异常。
这意味着当对方发送请求或者应答消息比较缓慢，或者网络传输较慢时，读取输入流一方的通信线程将被长时间阻塞，如果对方要 60s 才能够将数据发送完成，读取一方的 IO线程 也将会被同步阻塞 60s， ，
下面我们接着对输出流进行分析，还是看 JDK IO类库 输出流的 API文档，
```java
public abstract class OutputStream implements Closeable, Flushable {
/**
* Writes an array of bytes. This method will block until the bytes are *actually written.
*
* @param b the data.
* @exception IOException if an I/O error occurs.
* @see java.io.OutputStream#write(byte[], int, int)
*/
public void write(byte b[]) throws IOException {
write(b, 0, b.length);
}
}
```
当调用 OutputStream 的 write()方法 写输出流的时候，它将会被阻塞，直到所有要发送的字节全部写入完毕，或者发生异常。学习过 TCP/IP 相关知识的人都知道，当消息的接收方处理缓慢的时候，将不能及时地从 TCP缓冲区 读取数据，这将会导致发送方的 TCP window size 不断减小，直到为 0， ， ，
通过对输入和输出流的 API文档 进行分析，我们了解到读和写操作都是同步阻塞的，阻塞的时间取决于对方 IO线程 的处理速度和 网络IO 的传输速度。本质上来讲，我们无法保证生产环境的网络状况和对方的应用程序能足够快，如果我们的应用程序依赖对方的处理速度，它的可靠性就非常差。也许在实验室进行的性能测试结果令人满意，但是一旦上线运行，面对恶劣的网络环境和良莠不齐的第三方系统，问题就会如火山一样喷发。
伪异步IO 实际上仅仅是对之前 IO线程模型 的一个简单优化，它无法从根本上解决 同步IO 导致的通信线程阻塞问题。下面我们就简单分析下通信对方返回应答时间过长会引起的级联故障。
1. 服务端处理缓慢， ，
2. 采用伪异步I/O的线程正在读取故障服务节点的响应， ，
3. 假如所有的可用线程都被故障服务器阻塞，
4. 由于线程池采用阻塞队列实现，当队列积满之后，后续入队列的操作将被阻塞。
5. 由于前端只有一个Accptor线程接收客户端接入， ， ，
6. 由于几乎所有的连接都超时，调用者会认为系统已经崩溃，无法接收新的请求消息。
## NIO编程
与 Socket类 和 ServerSocket类 相对应，
己的需要来选择合适的模式。一般来说，低负载、低并发的应用程序可以选择 同步阻塞IO， ； ，
### NIO类库简介
NIO类库 是在 JDK 1.4 中引入的。NIO 弥补了原来 同步阻塞IO 的不足，它在 标准Java代码 中提供了高速的、面向块的IO。下面我们简单看一下 NIO类库 及其 相关概念。
**1、缓冲区Buffer**
Buffer对象 包含了一些要写入或者要读出的数据。在 NIO类库 中加入 Buffer对象， ， ， ； ，
缓冲区实质上是一个数组。通常它是一个字节数组（ ） ， ， （ ） ， ， ， ， （ ） ， ：
除了ByteBuffer， ， ，
**2、通道Channel**
Channel 是一个通道，它就像自来水管一样，网络数据通过 Channel 读取和写入。通道与流的不同之处在于通道是双向的，可以用于读、写，或者二者同时进行；流是单向的，要么是 InputStream， ， ，
**3、多路复用器Selector**
多路复用器Selector 是 Java NIO编程 的基础，熟练地掌握 Selector 对于 NIO编程 至关重要。多路复用器提供选择已经就绪的任务的能力。简单来讲， ，
一个 多路复用器Selector 可以同时轮询多个 Channel，
### NIO服务端序列图
下面，我们看一下 NIO服务端 的主要创建过程。
1、打开 ServerSocketChannel， ，
父管道，示例代码如下。
```java
ServerSocketChannel acceptorSvr = ServerSocketChannel.open();
```
2、绑定监听端口， ，
```java
acceptorSvr.socket().bind(new InetSocketAddress(InetAddress.getByName("IP"), port));
acceptorSvr.configureBlocking(false);
```
3、创建 Reactor线程， ，
```java
Selector selector = Selector.open();
New Thread (new ReactorTask()).start();
```
4、将 ServerSocketChannel 注册到 Reactor线程 的 多路复用器Selector 上，监听 ACCEPT事件，
```java
SelectionKey key = acceptorSvr.register(selector, SelectionKey.OP_ ACCEPT, ioHandler);
```
5、多路复用器在线程 run()方法 的无限循环体内轮询 准备就绪的Key，
```java
int num = selector.select();
Set selectedKeys = selector.selectedKeys();
Iterator it = selectedKeys.iterator();
while (it.hasNext()) {
SelectionKey key = (SelectionKey) it.next();
// .... deal with IO event ...
```
6、多路复用器Selector 监听到有新的客户端接入，处理新的接入请求，完成 TCP三次握手， ，
```java
SocketChannel channel = svrChannel.accept();
```
7、设置客户端链路为非阻塞模式，
```java
channel.configureBlocking(false);
channel.socket().setReuseAddress(true);
......
```
8、将新接入的客户端连接注册到 Reactor线程 的多路复用器上，监听读操作，读取客户端发送的网络消息，示例代码如下。
```java
SelectionKey key = socketChannel.register(selector, SelectionKey.OP_READ, ioHandler);
```
9、异步读取客户端请求消息到缓冲区，
```java
int readNumber = channel.read(receivedBuffer);
```
10、对 ByteBuffer 进行编解码，如果有半包消息指针 reset， ， ，
```java
List messageList = null;
while (byteBuffer.hasRemain()) {
byteBuffer.mark();
Object message = decode(byteBuffer) ;
if (message == null) {
byteBuffer.reset();
break;
}
messageList.add(message);
}
if (!byteBuffer.hasRemain()) {
byteBuffer.clear();
} else {
byteBuffer.compact();
}
if (messageList != null & & !messageList.isEmpty()) {
for (Object message : messageList) {
handlerTask(message);
}
}
```
11、将 POJO对象 encode 成 ByteBuffer， ， ，
```java
socketChannel.write(byteBuffer);
```
注意：如果发送区 TCP缓冲区满， ， ， ， ，
### NIO 客户端序列图
1、打开 SocketChannel，
```java
SocketChannel clientChannel = SocketChannel.open();
```
2、设置 SocketChannel 为非阻塞模式，同时设置客户端连接的 TCP参数，
```java
clientChannel.configureBlocking(false);
socket.setReuseAddress(true);
socket.setReceiveBufferSize(BUFFER_SIZE);
socket.setSendBufferSize(BUFFER_SIZE);
```
3、异步连接服务端，
```java
boolean connected = clientChannel.connect( new InetSocketAddress("ip", port) );
```
4、判断是否连接成功， ， ， ， ， ， ， ，
```java
if (connected) {
clientChannel.register(selector, SelectionKey.OP_READ, ioHandler);
} else {
clientChannel.register(selector, SelectionKey.OP_CONNECT, ioHandler);
}
```
5、向 Reactor线程 的多路复用器注册 OP_CONNECT 状态位，监听服务端的 TCP ACK应答，
```java
clientChannel.register(selector, SelectionKey.OP_CONNECT, ioHandler);
```
6、创建 Reactor线程， ，
```java
Selector selector = Selector.open();
New Thread( new ReactorTask() ).start();
```
7、多路复用器在线程 run()方法 的无限循环体内轮询 准备就绪的Key，
```java
int num = selector.select();
Set selectedKeys = selector.selectedKeys();
Iterator it = selectedKeys.iterator();
while (it.hasNext()) {
SelectionKey key = (SelectionKey) it.next();
// ... deal with IO event ...
}
```
8、接收 connect事件， ，
```java
if (key.isConnectable()) {
// handlerConnect();
}
```
9、判断连接结果， ， ，
```java
if(channel.finishConnect()) {
registerRead();
}
```
10、注册读事件到多路复用器，
```java
clientChannel.register(selector, SelectionKey.OP_READ, ioHandler);
```
11、异步读客户端请求消息到缓冲区，
```java
int readNumber = channel.read(receivedBuffer);
```
12、对 ByteBuffer 进行编解码，如果有半包消息接收缓冲区 Reset， ， ， ，
```java
List messageList = null;
while (byteBuffer.hasRemain()) {
byteBuffer.mark();
object message = decode(byteBuffer);
if (message == nu11) {
byteBuffer.reset();
break;
}
messageList.add(message);
}
if (!byteBuffer.hasRemain()) {
byteBuffer.clear();
} else {
byteBuffer.compact();
}
if ( messageList != null & & !messageList.isEmpty() )
for (Object message : messageList) {
handlerTask(message);
}
}
```
13、将 POJO对象 encode成 ByteBuffer， ，
```java
socketChannel.write(buffer);
```
## AIO编程
NIO2.0 引入了新的异步通道的概念，并提供了异步文件通道和异步套接字通道的实现。异步通道提供以下两种方式获取获取操作结果。
- 通过 java.util.concurrent.Future类 来表示异步操作的结果;
- 在执行异步操作的时候传入一个 java.nio.channels.CompletionHandler接口 的实现类作为操作完成的回调。
NIO2.0 的异步套接字通道是真正的 异步非阻塞IO，
由于在实际开发中使用较少，所以这里不对 AIO 进行详细分析。
## 四种IO编程模型的对比
对比之前，这里再澄清一下 “伪异步IO” 的概念。伪异步IO 的概念完全来源于实践，并没有官方说法。在 JDK NIO编程 没有流行之前，为了解决 Tomcat 通信线程同步IO 导致业务线程被挂住的问题，大家想到了一个办法，在通信线程和业务线程之间做个缓冲区，这个缓冲区用于隔离 IO线程 和业务线程间的直接访问，这样业务线程就不会被 IO线程 阻塞。而对于后端的业务侧来说，将消息或者 Task 放到线程池后就返回了，它不再直接访问 IO线程 或者进行 IO读写，
## 选择 Netty 开发项目的理由
从可维护性角度看，由于 NIO 采用了异步非阻塞编程模型，而且是一个 IO线程 处理多条链路，它的调试和跟踪非常麻烦，特别是生产环境中的问题，我们无法进行有效的调试和跟踪，往往只能靠一些日志来辅助分析，定位难度很大。
### 为什么不选择 Java原生NIO 进行开发
1. NIO 的类库和 API 使用起来非常繁杂，需要熟练掌握 Selector、ServerSocketChannel、SocketChannel、ByteBuffer 等。
2. 需要具备其他的额外技能做铺垫，例如，熟悉 Java多线程编程。这是因为 NIO编程 涉及到 Reactor模式，
3. 可靠性能力补齐，工作量和难度都非常大。例如客户端面临：断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常码流的处理，等问题。
4. JDK NIO 的 BUG， ， ，
### 为什么选择 Netty 进行开发
Netty 是业界最流行的 NIO框架 之一，它的健壮性、功能、性能、可定制性和可扩展性在同类框架中都是首屈一指的，已经得到成百上千的商用项目验证，例如 Hadoop 的 RPC框架 Avro ，阿里的 RPC框架 Dubbo 就使用了 Netty 作为底层通信框架。通过对Netty的分析，
- API使用简单， ；
- 功能强大，预置了多种编解码功能，支持多种主流协议；
- 定制能力强，可以通过 ChannelHandler 对通信框架进行灵活地扩展；
- 性能高，通过与其他业界主流的 NIO框架 对比，
- 成熟、稳定， ，
- 社区活跃，版本迭代周期短，发现的 BUG 可以被及时修复，同时，更多的新功能会加入；
- 经历了大规模的商业应用考验，
正是因为这些优点，
