IO模型之NIO代码及其实践详解
简介
NIO我们一般认为是New I/O（也是官方的叫法），因为它是相对于老的I/O类库新增的（ JDK 1.4中的java.nio.*包中引入新的Java I/O库）。但现在都称之为Non-blocking I/O，即非阻塞I/O，因为这样叫，更能体现它的特点。而下文中的NIO，不是指整个新的I/O库，而是非阻塞I/O。
NIO提供了与传统BIO模型中的Socket和ServerSocket相对应的SocketChannel和ServerSocketChannel两种不同的套接字通道实现。
新增的两种通道都支持阻塞和非阻塞两种模式。
阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。
对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用NIO的非阻塞模式来开发。
NIO实现基础
NIO对应linux IO 模型的IO多路复用模型，netty、tomcat（tomcat 6及以后版本，tomcat 6之前是基于BIO）的实现也是基于NIO。
I/O复用模型，是同步非阻塞，这里的非阻塞是指I/O读写，对应的是recvfrom操作，因为数据报文已经准备好，无需阻塞。说它是同步，是因为，这个执行是在一个线程里面执行的。有时候，还会说它又是阻塞的，实际上是指阻塞在select上面，必须等到读就绪、写就绪等网络事件。有时候我们又说I/O复用是多路复用，这里的多路是指N个连接，每一个连接对应一个channel，或者说多路就是多个channel。复用，是指多个连接复用了一个线程或者少量线程(在Tomcat中是Math.min(2,Runtime.getRuntime().availableProcessors()))。
NIO的注册、轮询等待、读写操作协作关系如下图：
多路复用器 Selector
Selector的英文含义是“选择器”，Selector是Java NIO 编程的基础，也可以称为为“轮询代理器”、“事件订阅器”、“channel容器管理机”都行。
Selector中也会维护一个“已经注册的Channel”的容器(select使用数组，poll使用链表，epoll是红黑树+双向链表，因为JDK使用了epoll()代替传统的select实现，所以没有最大连接句柄1024/2048(32*32/32*64)的限制，应用程序将向Selector对象注册需要它关注的Channel，以及具体的某一个Channel会对哪些IO事件感兴趣。
Selector提供选择已经就绪的任务的能力：Selector会不断轮询注册在其上的Channel，如果某个Channel上面发生读或者写事件，这个Channel就处于就绪状态，会被Selector轮询出来，然后通过SelectionKey可以获取就绪Channel的集合，进行后续的I/O操作。所以，只需要一个线程负责Selector的轮询，就可以接入成千上万的客户端。
通道 Channel
通道表示打开到 IO 设备(例如：文件、套接字，所以Channel有这两种实现：SelectableChannel 用户网络读写；FileChannel 用于文件操作)的连接。
其中SelectableChannel有以下几种实现：
- 所有被Selector（选择器）注册的通道，只能是继承了SelectableChannel类的子类。
- ServerSocketChannel：应用服务器程序的监听通道。只有通过这个通道，应用程序才能向操作系统注册支持“多路复用IO”的端口监听。同时支持UDP协议和TCP协议。
- ScoketChannel：TCP Socket套接字的监听通道，一个Socket套接字对应了一个客户端IP：端口 到 服务器IP：端口的通信连接。
- DatagramChannel：UDP 数据报文的监听通道。
Channel相比IO中的Stream流更加高效（底层的操作系统的通道一般都是全双工的，可以异步双向传输，所以全双工的Channel比流能更好的映射底层操作系统的API），但是必须和Buffer一起使用（若需要使用 NIO 系统，需要获取用于连接 IO 设备的Channel通道以及用于容纳数据的缓冲区Buffer。然后操作缓冲区，对数据进行处理。即通道中的数据总是要先读到一个Buffer，或者总是要从一个Buffer中写入）。也可以通过Channel通道向操作系统写数据。
缓冲区Buffer
Buffer是Channel操作读写的组件，包含一些要写入或者读出的数据。在NIO库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的；在写入数据时，也是写入到缓冲区中。任何时候访问NIO中的数据，都是通过缓冲区进行操作。缓冲区实际上是一个数组，并提供了对数据结构化访问以及维护读写位置等信息。
具体的缓存区有这些：ByteBuffe、CharBuffer、 ShortBuffer、IntBuffer、LongBuffer、FloatBuffer、DoubleBuffer。他们实现了相同的接口：Buffer。但是在我们网络传输中都是使用byte数据类型。如图：
Buffer中有三个重要参数：
- 位置（position）：当前缓冲区（Buffer）的位置，将从该位置往后读或写数据。
- 容量（capacity）：缓冲区的总容量上限。
- 上限（limit）：缓冲区的实际容量大小。
写模式下position为写入多少数据的位数标识，limit等于capacity；读模式下从position读到limit，position为0。写读模式切换使用flip()方法。
flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0，并将limit设置成之前position的值。
public Buffer flip() {
limit = position;
position = 0;
mark = -1;
return this;
}
代码实现
服务端代码实现
public class MultiplexerNioServer implements Runnable {
private ServerSocketChannel serverSocketChannel;
private Selector selector;
private volatile boolean stop = false;
/**
* 初始化多路复用器 绑定监听端口
*
* @param port
*/
public MultiplexerNioServer(int port) {
try {
serverSocketChannel = ServerSocketChannel.open();//获得一个serverChannel
selector = Selector.open();////创建选择器 获得一个多路复用器
serverSocketChannel.configureBlocking(false);//设置为非阻塞模式 如果为 true，则此通道将被置于阻塞模式；如果为 false，则此通道将被置于非阻塞模式
serverSocketChannel.socket().bind(new InetSocketAddress(port), 1024);//绑定一个端口和等待队列长度
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);//把selector注册到channel，关注链接事件
} catch (IOException e) {
e.printStackTrace();
System.exit(1);
}
}
public void stop() {
this.stop = true; // 优雅停机
}
public void run() {
while (!stop) {
try {
//无论是否有读写事件发生，selector每隔1s被唤醒一次。如果一定时间内没有事件，就需要做些其他的事情，就可以使用带超时的
int client = selector.select(1000);
System.out.println("1:"+client);
// 阻塞,只有当至少一个注册的事件发生的时候才会继续.
// int client = selector.select(); 不设置超时时间为线程阻塞，但是IO上支持多个文件描述符就绪
if (client == 0) {
continue;
}
System.out.println("2:"+client);
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> it = selectionKeys.iterator();
SelectionKey key = null;
while (it.hasNext()) {
key = it.next();
it.remove();
try {
//处理事件
handle(key);
} catch (Exception e) {
if (key != null) {
key.cancel();
if (key.channel() != null) {
key.channel().close();
}
}
}
}
} catch (Throwable e) {
e.printStackTrace();
}finally {
}
}
if (selector != null) {
// selector关闭后会自动释放里面管理的资源
try {
selector.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void handle(SelectionKey key) throws IOException {
if (key.isValid()) {
//连接事件
if (key.isAcceptable()) {
ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
// 通过ServerSocketChannel的accept创建SocketChannel实例
// 完成该操作意味着完成TCP三次握手，TCP物理链路正式建立
SocketChannel sc = ssc.accept();//3次握手
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_READ);//连接建立后关注读事件
}
//读事件
if (key.isReadable()) {
SocketChannel socketChannel = (SocketChannel) key.channel();
ByteBuffer readbuffer = ByteBuffer.allocate(1024);//写 0 1024 1024
// ByteBuffer readbuffer = ByteBuffer.allocateDirect(1024); //申请直接内存，也就是堆外内存
// 读取请求码流，返回读取到的字节数
int readBytes = socketChannel.read(readbuffer);
// 读取到字节，对字节进行编解码
if (readBytes > 0) {
// 将缓冲区当前的limit设置为position=0，用于后续对缓冲区的读取操作
readbuffer.flip();//读写模式反转
// 将缓冲区可读字节数组复制到新建的数组中
byte[] bytes = new byte[readbuffer.remaining()];
readbuffer.get(bytes);
String body = new String(bytes, "UTF-8");
System.out.println("input is:" + body);
res(socketChannel, body);
}else if(readBytes < 0){
// 链路已经关闭 释放资源
key.cancel();
socketChannel.close();
}else{
// 没有读到字节忽略
}
}
}
}
private void res(SocketChannel channel, String response) throws IOException {
if (response != null && response.length() > 0) {
byte[] bytes = response.getBytes();
ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
writeBuffer.put(bytes);
writeBuffer.flip();
channel.write(writeBuffer);
System.out.println("res end");
}
}
}可以看到，创建NIO服务端的主要步骤如下：
- 打开ServerSocketChannel，监听客户端连接；
- 绑定监听端口，设置连接为非阻塞模式；
- 创建Reactor线程，创建多路复用器并启动线程。
- 将ServerSocketChannel注册到Reactor线程中的Selector上，监听ACCEPT事件
- Selector轮询准备就绪的key
- Selector监听到新的客户端接入，处理新的接入请求，完成TCP三次握手，简历物理链路
- 设置客户端链路为非阻塞模式
- 将新接入的客户端连接注册到Reactor线程的Selector上，监听读操作，读取客户端发送的网络消息
- 异步读取客户端消息到缓冲区
- 对Buffer编解码，处理半包消息，将解码成功的消息封装成Task
- 将应答消息编码为Buffer，调用SocketChannel的write将消息异步发送给客户端
服务端启动
public class NioServer {
public static void main(String[] args) {
int port=8080;
MultiplexerNioServer nioServer=new MultiplexerNioServer(port);
new Thread(nioServer,"nioserver-001").start();
}
}启动服务端后，打印堆栈信息可以看到，会一直阻塞在 select() 操作，等待请求的到来：
通过控制台手动建立连接，测试如下：
客户端代码实现
public class NioClientHandler implements Runnable {
private String host;
private int port;
private Selector selector;
private SocketChannel socketChannel;
private volatile boolean stop;
public NioClientHandler(String host, int port) {
this.host = host;
this.port = port;
try {
// 创建选择器
selector = Selector.open();
// 打开监听通道
socketChannel = SocketChannel.open();
// 如果为 true，则此通道将被置于阻塞模式；如果为 false，则此通道将被置于非阻塞模式
socketChannel.configureBlocking(false); // 开启非阻塞模式
} catch (IOException e) {
e.printStackTrace();
System.exit(1);
}
}
public void run() {
try {
doConnect();
} catch (IOException e) {
e.printStackTrace();
System.exit(1);
}
while (!stop) {
try {
int wait=selector.select(1000);
if(wait==0){
continue;
}
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> it = selectionKeys.iterator();
SelectionKey key = null;
while (it.hasNext()) {
key = it.next();
it.remove();
try {
handle(key);
} catch (Exception e) {
if (key != null) {
key.cancel();
if (key.channel() != null) {
key.channel().close();
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
if (selector != null) {
try {
selector.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private void doConnect() throws IOException {
if (socketChannel.connect(new InetSocketAddress(host, port))) {
socketChannel.register(selector, SelectionKey.OP_READ);
doWrite(socketChannel);
}else{
socketChannel.register(selector, SelectionKey.OP_CONNECT);
}
}
private void handle(SelectionKey key) throws IOException {
if (key.isValid()) {
SocketChannel sc = (SocketChannel) key.channel();
if (key.isConnectable()) {
if (sc.finishConnect()) {
sc.register(selector, SelectionKey.OP_READ);
doWrite(sc);
} else {
System.exit(1);
}
}
if (key.isReadable()) {
ByteBuffer readBuffer = ByteBuffer.allocate(1024);
int readBytes = sc.read(readBuffer);
if (readBytes > 0) {
readBuffer.flip();
byte[] bytes=new byte[readBuffer.remaining()];
readBuffer.get(bytes);
String body=new String(bytes,"UTF-8");
System.out.println("res"+body);
this.stop=true;
}else if(readBytes<0){
key.cancel();
sc.close();
}
}
}
}
private void doWrite(SocketChannel sc) throws IOException {
// 将消息编码为字节数组
byte[] request = "0123456789".getBytes();
// 根据数组容量创建ByteBuffer
ByteBuffer writeBuffer = ByteBuffer.allocate(request.length);
// 将字节数组复制到缓冲区
writeBuffer.put(request);
// flip读写切换操作
writeBuffer.flip();
sc.write(writeBuffer);
if (!writeBuffer.hasRemaining()) {
System.out.println("写入完成");
}
}
}启动客户端
public class NioClient {
public static void main(String[] args) {
new Thread(new NioClientHandler("localhost", 8080), "nioClient-001").start();
}
}启动客户端后，会向服务端写一些数据，然后再从服务端接收数据，如下图所示：
客户端获得服务端的回复后会自动断开同服务端的连接，客户端的一次请求就此完成。
BIO、NIO、AIO对比
|
参考： |
