Java 1.4 开始引入 NIO 框架，提供了 Channel(通道)、Selector(IO复用器/选择器)、Buffer(缓冲区)，可构建多路复用、同步非阻塞的 IO 程序，同时在数据操作方式方面更接近操作系统底层所以性能更高。
在 Java 7 中，NIO 再次改进，引入异步非阻塞 IO 方式，基于事件和回调机制，也就是处理开始时不阻塞，处理完成后系统通知对应线程继续后续工作。这种方式也称为 NIO 2 或 AIO（Asynchronous IO）。
在 IO 中数据操作基于字节流或字符流，在 NIO 中数据基于 Channel 和 Buffer 进行操作
Channel(通道)：在缓冲区和位于通道另一侧的服务之间进行数据传输，支持单向或双向传输，支持阻塞或非阻塞模式
Buffer(缓冲区)：高效数据容器。本质上是一块内存区，用于数据的读写，NIO Buffer 将其包裹并提供开发时常用的接口，便于数据操作
Selector(IO复用器/选择器)：多路复用的重要组成部分，检查一个或多个Channel(通道)是否是可读、写状态，实现单线程管理多Channel(通道)，优于使用多线程或线程池产生的系统资源开销
NIO Channel
Channel 在缓冲区和位于通道另一侧的服务之间进行数据传输，支持单向或双向传输，支持阻塞或非阻塞模式
几种主要的 Channel 类型（FileChannel、DatagramChannel、SocketChannel、ServerSocketChannel）已覆盖了我们日常开发常见场景，如不同网络传输IO、文件IO。Channel 中的数据支持以异步方式存、取至 Buffer。
NIO Buffer
Buffer 是高效数据容器。它本质上是一块内存区，基于数组实现存储，用于数据的读写，NIO Buffer 将其包裹并提供开发时常用的接口，便于数据操作。
Client 向 Buffer 写入数据后，调用 flip() 将 Buffer 由写模式更改为读模式，此时 Channel 可以读取 Buffer 内数据，读取完成后可调用 clear() 或 compact() 重置缓冲区并允许数据写入
NIO Selector
Selector 是 NIO 多路复用的重要组成部分。它负责检查一个或多个Channel(通道)是否是可读、写状态，实现单线程管理多 Channel(通道)，优于使用多线程或线程池产生的系统资源开销
向 Selector 注册 Channel 时可指定的类型有四种：OP_READ、OP_WRITE、OP_CONNECT、OP_ACCEPT
// 读
public static final int OP_READ = 1 << 0;
// 写
public static final int OP_WRITE = 1 << 2;
// 连接;SocketChannel 独有，其它类型 channel 不支持
public static final int OP_CONNECT = 1 << 3;
// 接收;ServerSocketChannel 独有，其它类型 channel 不支持
public static final int OP_ACCEPT = 1 << 4;
注册时可以为同一通道注册多个感兴趣的事件，互相之间使用操作符 * | * 位或连接，如：
Channel.register(Selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE);
当 Channel(通道) 注册至 Selector 内后，便会产生一个对应的 SelectionKey，存储与此 Channel 相关的数据
NIO SelectionKey
SelectionKey 是 channel 在 Selector 内注册的标识，每个 channel 对应一个 SelectionKey， SelectionKey 内包含有如下属性：
-
interest Set：兴趣集合，当前 channel 感兴趣的操作 -
ready Set：就绪集合，此 SelectionKey 已经准备就绪的操作集合 -
Channel：通道，获取此 SelectionKey 对应的 channel -
Selector：选择器，管理此 channel 的 Selector -
Attach：附加对象，向 SelectionKey 中添加更多的信息，方便之后的数据操作判断或获取
FileChannel 主要方法
java.io.RandomAccessFile.getChannel()
FileChannel 类型通道实例从输入流中获取，如：FileInputStream.getChannel() 或 RandomAccessFile.getChannel()
java.nio.channels.FileChannel.read(buffer)
从 FileChannel 类通道中读取数据并存入指定的 buffer 中
java.nio.channels.FileChannel.write(buffer)
从指定的 buffer 中读取数据并向 FileChannel 类通道写入
java.nio.channels.FileChannel.position()
获取当前 position 位置
java.nio.channels.FileChannel.position(long newPosition)
从指定位置开始写入操作
java.nio.channels.FileChannel.truncate(long size)
指定长度并截取文件
java.nio.channels.spi.AbstractInterruptibleChannel.close()
关闭此通道
DatagramChannel 主要方法
java.nio.channels.DatagramChannel.open()
打开一个 DatagramChannel 类型通道
java.nio.channels.DatagramChannel.socket().bind(SocketAddress addr)
接收指定端口中的UDP协议数据
java.nio.channels.DatagramChannel.receive(buffer)
将数据写入到指定 buffer 中
java.nio.channels.DatagramChannel.send(ByteBuffer src, SocketAddress target)
将指定的 buffer 内的数据发送给指定的 IP地址+端口号
java.nio.channels.spi.AbstractInterruptibleChannel.close()
关闭此通道
SocketChannel 主要方法
java.nio.channels.SocketChannel.open()
打开一个 SocketChannel 类型通道
java.nio.channels.SocketChannel.connect(SocketAddress remote)
通过 Socket 方式连接至指定的IP地址+端口号
java.nio.channels.SocketChannel.read(buffet)
从 SocketChannel 类通道中读取数据并存入指定的 buffer 中
java.nio.channels.SocketChannel.write(buffer)
从指定的 buffer 中读取数据并向 SocketChannel 类通道写入
java.nio.channels.spi.AbstractSelectableChannel.configureBlocking(boolean block)
设置阻塞模式，false 为非阻塞
java.nio.channels.spi.AbstractInterruptibleChannel.close()
关闭此通道
ServerSocketChannel 主要方法
java.nio.channels.ServerSocketChannel.open()
打开一个 ServerSocketChannel 类型通道
java.nio.channels.ServerSocketChannel.bind(SocketAddress local)
监听指定端口下的TCP连接
ServerSocketChannel.accept()
监听新连接。通常用 while(true){} 方式循环监听，获取到新 channel 后根据其事件做对应操作
java.nio.channels.spi.AbstractSelectableChannel.configureBlocking(boolean block)
设置阻塞模式，false 为非阻塞
java.nio.channels.spi.AbstractInterruptibleChannel.close()
关闭此通道
Buffer 主要方法
java.nio.****Buffer.allocate(int capacity)
创建缓冲区并设定容量
java.nio.****Buffer..fwrap(byte[] array)
根据存入数组大小新建/更新缓冲区并重设容量为 array.length
java.nio.Buffer.flip()
将 Buffer 由写模式更改为读模式
java.nio.Buffer.clear()丨java.nio.Buffer.compact()
两者均为允许数据写入（由读模式更改为写模式）并重置缓冲区标识（capacity、position、 limit），但对待标识参数的具体处理不同，决定了后续操作对数据的影响也不同
capacity 表示缓冲区的最大容量。position 在读模式下指定读取开始位置的索引，由写模式切换过来时 position 会被置0。在写模式下指定写入元素下标，最大可用下标为 capacity -1，可用下标从 0 开始。limit 在读模式下代表本缓冲区内最多可读数据量。写模式下代表本缓冲区最多可用空间
clear() 与 compact() 的区别在于对 Buffer 内现存数据的后续使用造成的影响不同。clear() 会做如下操作： position = 0; limit = capacity; mark = -1; 也就是说数据虽未被删除，但当我们之后再次写入时，将不再关心是否保留它们而直接覆盖。而 compact() 会把所有未读数据拷贝至起始处，将position设为最后一个未读元素后，将limit设置为capacity，也就是说再次写入数据时不会覆盖未读数据，这些数据将被继续缓存并等待之后的使用
Selector 主要方法
java.nio.channels.Selector.select()
准备一组已准备好进行 I/O 操作的 channel 。以阻塞线程的方式，直到返回至少一个符合要求的 channel
java.nio.channels.Selector.select(long timeout)
准备一组已准备好进行 I/O 操作的 channel 。以阻塞线程的方式，直到返回至少一个符合要求的 channel 或者给定的超时时间到期
java.nio.channels.Selector.selectNow()
准备一组已准备好进行 I/O 操作的 channel 。以非阻塞线程的方式，如果没有符合要求的通道，则直接返回 0
java.nio.channels.Selector.selectedKeys()
准备好可进行 I/O 操作的 channel 后，调用此方法获取已就绪的 channel，之后遍历并判断 channel 对应的事件即可
SelectionKey 主要方法
java.nio.channels.SelectionKey.channel();
返回当前 SelectionKey 对应的 Channel ，即使其已关闭，也同样返回
java.nio.channels.SelectionKey.selector();
返回管理此 SelectionKey 的 Selectoe，即使其已关闭，也同样返回 Selectoe
java.nio.channels.SelectionKey.isValid();
返回当前 SelectionKey 是否有效的状态。SelectionKey 在创建时有效并持续保持，在被取消cancel()或删除removeKey(key)后变为无效，在 Channel 或 Seelctor 被关闭后同样变为无效
java.nio.channels.SelectionKey.cancel();
取消此 key 对应的 channel 在 selector 内取消。valid 也将更新为 false，此 key 将被添加至 cancelledkey 集合内
java.nio.channels.SelectionKey.interestOps();
获取 SelectionKey 中包含的 interest set， 存储的是我们设定的事件
java.nio.channels.SelectionKey.interestOps(int ops)
将此 key 对应的interst设置为指定值，此操作会对 ops 和 channel.validOps 进行校验，如果此ops不被当前channel支持，将抛出异常
java.nio.channels.SelectionKey.readyOps();
获取 SelectionKey 中包含的 ready set，存储的是准备就绪的事件。每次 select() 时，选择器都会对 ready set 进行更新，外部程序无法修改此集合.
java.nio.channels.SelectionKey.isReadable();
检测此键是否为"read"事件，等效于:k.,readyOps() & OP_READ != 0;还有isWritable(),isConnectable(),isAcceptable()
java.nio.channels.SelectionKey.attach(Object ob)
添加附件。若需要向 SelectionKey 添加更多数据信息，方便之后的操作，可通过 attach(Object ob) 或 register channel 时存入
java.nio.channels.SelectionKey.attachment();
获取附件。附件可在 Channe 生命周期中共享，但不可作为 socket 数据实现网络传输
应用源码实例
服务端
/**
* NIO Server
* @author liyongli 20191029
* */
public class NIOServerDemo {
// IO复用器丨选择器
private Selector NIOServerSelector;
// 数据通道
private ServerSocketChannel NIOServerSocketChannel;
public static void main(String[] args) {
// 先运行本类代码，再运行客户端代码
NIOServerDemo NIOServer = new NIOServerDemo();
// 初始化服务器配置
NIOServer.initServerSocketChannel("localhost", 8081);
// 启动监听
NIOServer.startNIOServerSelectorListener();
}
/**
* 注册 Channel
* @param hostname 主机地址
* @param port 端口号
* */
private void initServerSocketChannel(String hostname, int port){
try {
// 初始化IO复用器丨选择器
NIOServerSelector = Selector.open();
// 打开通道
NIOServerSocketChannel = ServerSocketChannel.open();
// 调整模式为非阻塞
NIOServerSocketChannel.configureBlocking(false);
// 设置端口
NIOServerSocketChannel.socket().bind(new InetSocketAddress(hostname, port));
// 注册此通道
NIOServerSocketChannel.register(NIOServerSelector, SelectionKey.OP_ACCEPT);
System.out.println("服务端准备就绪");
} catch (IOException e) {
System.out.println("服务端初始化失败");
e.printStackTrace();
}
}
/**
* 启动 Selector
* */
private void startNIOServerSelectorListener(){
while(true){
try {
// 选中通道
NIOServerSelector.select();
// 获取所有 key
Iterator NIOServerSelectorIterator = NIOServerSelector.selectedKeys().iterator();
while(NIOServerSelectorIterator.hasNext()){
// 获取 key
SelectionKey selectionKey = NIOServerSelectorIterator.next();
// 判断当前 channel 是否可接收 socket 连接
if(selectionKey.isAcceptable()){
// 复用
SocketChannel socketChannel = NIOServerSocketChannel.accept();
socketChannel.configureBlocking(false);
socketChannel.register(NIOServerSelector, SelectionKey.OP_READ);
// 判断当前通道是否可读取
}else if(selectionKey.isReadable()){
callClient(selectionKey);
}
// 删除已处理完成的 key
NIOServerSelectorIterator.remove();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 自动回复 Client
* */
private void callClient(SelectionKey selectionKey){
try {
// 获取对应通道
SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
// 新建缓冲区
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
// 读取通道数据并存入缓冲区
int index = socketChannel.read(byteBuffer);
// 若通道内有数据
if(index != -1){
System.out.println("服务端接收:" + new String(byteBuffer.array()));
// 自动回复（此处可添加对应业务逻辑）
socketChannel.write(ByteBuffer.wrap("hello client,im waiting for you!".getBytes()));
System.out.println("服务端回复:" + "hello client,im waiting for you!");
}else{
// 通道内无数据
socketChannel.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
客户端
/**
* NIO Client
* @author liyongli 20191029
* */
public class NIOClientDemo {
// 定义通道
private SocketChannel socketChannel;
public static void main(String[] args){
// 先运行服务端代码，再运行本类
NIOClientDemo NIOClient = new NIOClientDemo();
// 初始化连接服务器配置
NIOClient.initClientChannel("localhost", 8081);
// 发送消息
NIOClient.callServer("hello server,what are you doing?");
}
/**
* 初始化客户端 NIO Channel
* */
public void initClientChannel(String hostname, int port){
try {
// 初始化 socket
InetSocketAddress inetSocketAddress = new InetSocketAddress(hostname, port);
// 建立通道
socketChannel = SocketChannel.open(inetSocketAddress);
System.out.println("客户端准备就绪");
} catch (IOException e) {
System.out.println("初始化客户端失败");
e.printStackTrace();
}
}
/**
* 通信 Server
* */
public void callServer(String callStr){
// 将字符串转换为 byte 数组，便于稍后传输
byte[] requestByte = new String(callStr).getBytes();
// 创建一个1024 容量的 ByteBuffer
ByteBuffer byteBuffer = ByteBuffer.wrap(requestByte);
System.out.println("客户端发送：" + new String(byteBuffer.array()));
if(null != socketChannel){
try {
// 向通道写入数据
socketChannel.write(byteBuffer);
// 清空缓冲区（数据并未被删除，但位置、标记、限制被重置）
byteBuffer.clear();
// 读取被服务器更新的数据
socketChannel.read(byteBuffer);
System.out.println("客户端接收：" + new String(byteBuffer.array()));
// 关闭通道
socketChannel.close();
} catch (IOException e) {
System.out.println("通信出错");
e.printStackTrace();
}
}else{
System.out.println("请初始化客户端");
}
}
}
运行结果
服务端准备就绪
服务端接收:hello server,what are you doing?
服务端回复:hello client,im waiting for you!
客户端准备就绪
客户端发送：hello server,what are you doing?
客户端接收：hello client,im waiting for you!