目录
1 原理剖析
jdk1.4之前是没有NIO的，传统IO是阻塞式的，即客户端有一个请求时，服务端就需要创建一个线程来处理请求，如果并发特别高，服务端会面临创建太多线程导致内存泄露等问题，并且有的连接不做任何事情却一直占用一个线程造成资源浪费。当然这些问题可以在服务端使用线程池来解决，但是性能上存在瓶颈。这时候NIO就应运而生。
NIO中一个线程可以管理多个连接，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
1.1 BIO原理
同步阻塞式IO，服务端使用accept等待接收客户端的请求，接收到请求之后建立通讯套接字进行读写操作，此时不再接收其他客户端的请求，等待当前客户端操作执行完成。如果客户端请求并发非常高，需要服务端开启多线程来处理，处理逻辑是这样的：每次accept阻塞等待客户端的请求，当接收到请求立即建立通讯套接字并启动一个线程来处理通讯套接字的读写操作，accept就可以继续阻塞等待下一个客户端的请求。如下图所示：
1.2 NIO原理
同步非阻塞式IO，有三部分组成，缓冲区，通道，多路复用器。在NIO中一个线程可以服务多个通道（channel） ，当前线程从channel中读写数据 ，如果无数据可用，线程就可以干别的事情。线程通常将非阻塞IO的空闲时间用于在其他通道上执行IO操作。这就是一个线程可以管理多个通道的原理 。
NIO使用的设计模式是reactor模式，提供了Selector类，我们把需要探知的socketchannel告诉Selector，就可以做其他事情了，Selector会通知我们，传回一组SelectionKey，我们读取这些key，就会获得我们刚刚注册过的socketchannel，然后从这个Channel中读取数据，之后就可以处理这些数据 。
Selector内部原理实际是在做一个对所注册的channel的轮询访问，不断的轮询(目前就这一个算法)，一旦轮询到一个channel有所注册的事情发生，比如数据来了，他就会站起来报告，交出一把钥匙，让我们通过这把钥匙来读取这个channel的内容。
NIO实现原理如下图所示：
有图可以看到NIO的工作原理：
1.由一个专门的线程来处理所有的IO事件，并负责分发；
2.事件驱动机制：事件到的时候触发，而不是同步的去监视事件；
3.线程通讯：线程之间通过wait,notify等方式通讯。保证每次上下文切换都是有意义的。
1.3 BIO和NIO对比
| NIO | BIO |
| 面向缓冲区 | 面向流 |
| 同步非阻塞IO | 同步阻塞IO |
| 一个线程管理多个连接 | 一个线程管理一个连接 |
2 编码实现
2.1 NIO服务端
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
public class NIOServer {
//通道管理器
private Selector selector;
/**
* 获得一个ServerSocket通道，并对该通道做一些初始化的工作
*
* @param port 绑定的端口号
* @throws IOException
*/
public void initServer(int port) throws IOException {
// 获得一个ServerSocket通道
ServerSocketChannel serverChannel = ServerSocketChannel.open();
// 设置通道为非阻塞
serverChannel.configureBlocking(false);
// 将该通道对应的ServerSocket绑定到port端口
serverChannel.socket().bind(new InetSocketAddress(port));
// 获得一个通道管理器
this.selector = Selector.open();
//将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后，
//当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞。
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
listen();
}
/*
* @Author boy
* @Description 轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
* @Date 2019/11/21 11:46 PM
* @Param []
* @return void
*/
@SuppressWarnings("unchecked")
public void listen() throws IOException {
// 轮询访问selector
while (true) {
//当注册的事件到达时，方法返回；否则,该方法会一直阻塞
selector.select();
// 获得selector中选中的项的迭代器，选中的项为注册的事件
Iterator ite = this.selector.selectedKeys().iterator();
while (ite.hasNext()) {
SelectionKey key = (SelectionKey) ite.next();
// 删除已选的key,以防重复处理
ite.remove();
// 客户端请求连接事件
if (key.isAcceptable()) {
ServerSocketChannel server = (ServerSocketChannel) key
.channel();
// 获得和客户端连接的通道
SocketChannel channel = server.accept();
// 设置成非阻塞
channel.configureBlocking(false);
//在这里可以给客户端发送信息哦
channel.write(ByteBuffer.wrap(new String("向客户端发送了一条信息").getBytes()));
//在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。
channel.register(this.selector, SelectionKey.OP_READ);
// 获得了可读的事件
} else if (key.isReadable()) {
read(key);
}
}
}
}
/*
* @Author boy
* @Description 处理读取客户端发来的信息的事件
* @Date 2019/11/21 11:47 PM
* @Param [key]
* @return void
*/
public void read(SelectionKey key) throws IOException {
// 服务器可读取消息:得到事件发生的Socket通道
SocketChannel channel = (SocketChannel) key.channel();
// 创建读取的缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer);
byte[] data = buffer.array();
String msg = new String(data).trim();
System.out.println("服务端收到信息：" + msg);
ByteBuffer outBuffer = ByteBuffer.wrap(msg.getBytes());
channel.write(outBuffer);// 将消息回送给客户端
}
public static void main(String[] args) throws IOException {
NIOServer server = new NIOServer();
server.initServer(9999);
}
}
2.2 NIO客户端
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
/**
* @ClassName NIOClient
* @Description TODO
* @Author boy
* @Date 2019/11/20 11:11 AM
*/
public class NIOClient {
//通道管理器
private Selector selector;
/*
* @Author boy
* @Description 获得一个Socket通道，并对该通道做一些初始化的工作
* @Date 2019/11/21 11:48 PM
* @Param [ip, port]
* @return void
*/
public void initClient(String ip, int port) throws IOException {
// 获得一个Socket通道
SocketChannel channel = SocketChannel.open();
// 设置通道为非阻塞
channel.configureBlocking(false);
// 获得一个通道管理器
this.selector = Selector.open();
// 客户端连接服务器,其实方法执行并没有实现连接，需要在listen（）方法中调
//用channel.finishConnect();才能完成连接
channel.connect(new InetSocketAddress(ip, port));
//将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_CONNECT事件。
channel.register(selector, SelectionKey.OP_CONNECT);
}
/*
* @Author boy
* @Description 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
* @Date 2019/11/21 11:49 PM
* @Param []
* @return void
*/
@SuppressWarnings("unchecked")
public void listen() throws IOException {
// 轮询访问selector
while (true) {
selector.select();
// 获得selector中选中的项的迭代器
Iterator ite = this.selector.selectedKeys().iterator();
while (ite.hasNext()) {
SelectionKey key = (SelectionKey) ite.next();
// 删除已选的key,以防重复处理
ite.remove();
// 连接事件发生
if (key.isConnectable()) {
SocketChannel channel = (SocketChannel) key
.channel();
// 如果正在连接，则完成连接
if (channel.isConnectionPending()) {
channel.finishConnect();
}
// 设置成非阻塞
channel.configureBlocking(false);
//在这里可以给服务端发送信息哦
channel.write(ByteBuffer.wrap(new String("向服务端发送了一条信息").getBytes()));
//在和服务端连接成功之后，为了可以接收到服务端的信息，需要给通道设置读的权限。
channel.register(this.selector, SelectionKey.OP_READ);
// 获得了可读的事件
} else if (key.isReadable()) {
read(key);
}
}
}
}
/*
* @Author boy
* @Description 处理读取服务端发来的信息 的事件
* @Date 2019/11/21 11:49 PM
* @Param [key]
* @return void
*/
public void read(SelectionKey key) throws IOException {
//和服务端的read方法一样
}
public static void main(String[] args) throws IOException {
NIOClient client = new NIOClient();
client.initClient("localhost", 9999);
client.listen();
}
}