【1】使用 NIO 完成网络通信的三个核心
① 通道（Channel）：负责连接
核心接口Channel，这里主要讲SelectableChannel。
java.nio.channels.Channel 接口：
|--SelectableChannel
|--SocketChannel(tcp)
|--ServerSocketChannel(tcp)
|--DatagramChannel(udp)
|--Pipe.SinkChannel(管道)
|--Pipe.SourceChannel(管道)
② 缓冲区（Buffer）：负责数据的存取。
参考上篇博文，这里不再赘述。
③ 选择器（Selector）
SelectableChannel 的多路复用器，用于监控 SelectableChannel 的 IO 状况。
与Socket类和ServerSocket类相对应，NIO也提供了SocketChannel和ServerSocketChannel两种不同的套接字实现。这两种新增的通道都支持阻塞和非阻塞模式。阻塞模式使用非常简单，但是性能和可靠性都不好，非阻塞模式则正好相反。一般来说，低负载、低并发的应用程序可以选择同步阻塞IO以降低编程复杂度；对于高负载，高并发的网络应用，需要使用NIO的非阻塞模式进行开发。
简单地讲Selector会不断地轮询注册在其上的Channel，如果某个Channel上面发生读或者写事件，这个Channel就处于就绪状态，会被Selector轮询出来，然后通过SelectionKey可以获取就绪Channel的集合，进行后续的IO操作。
一个多路复用器Selector可以同时轮询多个Channel，由于JDK使用了epoll()代替传统的select实现，所以它并没有最大连接句柄1024/2048的限制。这也就意味着只需要一个线程负责Selector的轮询，就可以接入成千上万的客户端。
【2】阻塞式SocketChannel与ServerSocketChannel实例
Java NIO中的SocketChannel是一个连接到TCP网络套接字的通道。
操作步骤：
- 打开SocketChannel
- 读写数据
- 关闭SocketChannel
Java NIO中的ServerSocketChannel 是一个可以监听新进来的TCP连接的通道，就像标准IO中的ServerSocket一样。
源码实例如下：
package com.jane;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import org.junit.Test;
public class TestBlockingNIO2 {
//客户端
@Test
public void client() throws IOException{
//1. 获取通道
SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
System.out.println(sChannel.hashCode());
FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
//2. 分配指定大小的缓冲区
ByteBuffer buf = ByteBuffer.allocate(1024);
//3. 读取本地文件，并发送到服务端
while(inChannel.read(buf) != -1){
buf.flip();
sChannel.write(buf);
buf.clear();
}
//4.输出完毕，Shutdown the connection for writing without closing the channel.
sChannel.shutdownOutput();
//5.接收服务端的反馈
int len = 0;
while((len = sChannel.read(buf)) != -1){
buf.flip();
System.out.println(new String(buf.array(), 0, len));
buf.clear();
}
//6.关闭通道
inChannel.close();
sChannel.close();
}
//服务端
@Test
public void server() throws IOException{
//1. 获取服务端通道
ServerSocketChannel ssChannel = ServerSocketChannel.open();
FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
//2. 绑定连接
ssChannel.bind(new InetSocketAddress(9898));
//3. 获取客户端连接的通道
SocketChannel sChannel = ssChannel.accept();
System.out.println(sChannel.hashCode());
//4. 分配指定大小的缓冲区
ByteBuffer buf = ByteBuffer.allocate(1024);
//5. 接收客户端的数据，并保存到本地
while(sChannel.read(buf) != -1){
buf.flip();
outChannel.write(buf);
buf.clear();
}
//接收完毕，Shutdown the connection for reading without closing the channel.
sChannel.shutdownInput();
//6.发送反馈给客户端
buf.put("服务端接收数据成功".getBytes());
buf.flip();
sChannel.write(buf);
//7.关闭通道
sChannel.close();
outChannel.close();
ssChannel.close();
}
}
其实和以前单独使用ServerSocket和Socket逻辑一样，以前使用的普通IO流，这里使用了通道。
参考博文：
ServerSocket与Socket简解；
Socket编码实践。
【3】多路复用器（Selector）
① Selector定义
选择器（Selector）是SelectableChannle 对象的多路复用器，Selector 可以同时监控多个SelectableChannel 的IO 状况。也就是说，利用Selector 可使一个单独的线程管理多个Channel。
Selector 是非阻塞IO 的核心。
SelectableChannle 的结构如下图：
② Selector的应用
- 创建Selector
// 获取选择器
Selector selector = Selector.open();
通过调用Selector.open() 方法创建一个Selector。
- 向选择器注册通道
SelectableChannel.register(Selector sel, int ops)
当调用register(Selector sel, int ops) 将通道注册选择器时，选择器对通道的监听事件，需要通过第二个参数ops 指定。
可以监听的事件类型（可使用SelectionKey 的四个常量表示）：
- 读: SelectionKey.OP_READ （int-1）
- 写: SelectionKey.OP_WRITE （int-4）
- 连接: SelectionKey.OP_CONNECT（int-8）
- 接收: SelectionKey.OP_ACCEPT （int-16）
public static final int OP_READ = 1 << 0;
public static final int OP_WRITE = 1 << 2;
public static final int OP_CONNECT = 1 << 3;
public static final int OP_ACCEPT = 1 << 4;
若注册时不止监听一个事件，则可以使用“位或”操作符连接。
ssChannel.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE);
③ SelectionKey是什么
SelectionKey：表示SelectableChannel 和Selector 之间的注册关系。每次向选择器注册通道时就会选择一个事件(选择键)。选择键包含两个表示为整数值的操作集。操作集的每一位都表示该键的通道所支持的一类可选择操作。
方法 | 描述 |
int interestOps() | 获取感兴趣事件集合 |
int readyOps() | 获取通道已经准备就绪的操作的集合 |
SelectableChannel channel() | 获取注册通道 |
Selector selector() | 返回选择器 |
boolean isReadable() | 检测Channal 中读事件是否就绪 |
boolean isWritable() | 检测Channal 中写事件是否就绪 |
boolean isConnectable() | 检测Channel 中连接是否就绪 |
boolean isAcceptable() | 检测Channel 中接收是否就绪 |
④ Selector 的常用方法
方法 | 描述 |
Set< | 所有的SelectionKey 集合。代表注册在该Selector上的Channel ==selectedKeys+remove掉的SelectionKey |
Set< | 被选择的SelectionKey 集合。返回此Selector的已选择键集 |
int select() | 监控所有注册的Channel，当它们中间有需要处理的IO 操作时，该方法返回，并将对应得的SelectionKey 加入被选择的SelectionKey 集合中，该方法返回这些Channel 的数量。 |
int select(long timeout) | 可以设置超时时长的select() 操作 |
int selectNow() | 执行一个立即返回的select() 操作，该方法不会阻塞线程 |
Selector wakeup() | 使一个还未返回的select() 方法立即返回 |
void close() | 关闭该选择器 |
【4】 Selector使用实例
SocketChannel向ServerSocketChannel非阻塞模式发送数据：
public class TestNonBlockingNIO {
//客户端
@Test
public void client() throws IOException{
//1. 获取通道
SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
//2. 切换非阻塞模式
sChannel.configureBlocking(false);
//3. 分配指定大小的缓冲区
ByteBuffer buf = ByteBuffer.allocate(1024);
//4. 发送数据给服务端
buf.put((new Date().toString() + "\n" + "你好啊，祖国").getBytes());
buf.flip();
sChannel.write(buf);
buf.clear();
//5. 关闭通道
sChannel.close();
}
//服务端
@Test
public void server() throws IOException{
//1. 获取通道，用于监听客户端连接，它是所有客户端连接的父管道
ServerSocketChannel ssChannel = ServerSocketChannel.open();
//2. 切换非阻塞模式
ssChannel.configureBlocking(false);
//3. 绑定连接
ssChannel.bind(new InetSocketAddress(9898));
//4. 创建多路复用器
Selector selector = Selector.open();
//5. 将通道注册到选择器上, 并且指定“监听接收事件”
ssChannel.register(selector, SelectionKey.OP_ACCEPT);
// FileChannel fileChannel = FileChannel.open(Paths.get("2.txt"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
//6. 轮询式的获取选择器上已经“准备就绪”的事件
while(selector.select() > 0){
//7. 获取当前选择器中所有注册的“选择键(已就绪的监听事件)”
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
while(it.hasNext()){
//8. 获取准备“就绪”的事件
SelectionKey sk = it.next();
//第一次 16 之后为1
System.out.println("当前SelectionKey："+sk.interestOps());
// ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
// byteBuffer.put(("当前SelectionKey："+sk.interestOps()).getBytes());
// byteBuffer.flip();
// fileChannel.write(byteBuffer);
// byteBuffer.clear();
//9. 判断具体是什么事件准备就绪
if(sk.isAcceptable()){
//10. 若“接收就绪”，获取客户端连接
SocketChannel sChannel = ssChannel.accept();
System.out.println("接收就绪。。");
//11. 切换非阻塞模式
sChannel.configureBlocking(false);
//12. 将新接入的客户端连接注册到多路复用器上，监听读操作，读取客户端发送的网络消息
sChannel.register(selector, SelectionKey.OP_READ);
}else if(sk.isReadable()){
//13. 获取当前选择器上“读就绪”状态的通道
SocketChannel sChannel = (SocketChannel) sk.channel();
System.out.println("读就绪。。");
//14. 读取数据
ByteBuffer buf = ByteBuffer.allocate(1024);
int len = 0;
while((len = sChannel.read(buf)) > 0 ){
buf.flip();
System.out.println(new String(buf.array(), 0, len));
buf.clear();
}
}
//15. 取消选择键 SelectionKey
it.remove();
}
}
}
}【5】DatagramChannel实例
【4】中主要针对TCP，DatagramChannel则主要针对UDP。
实例代码如下：
public class TestNonBlockingNIO2 {
@Test
public void send() throws IOException{
DatagramChannel dc = DatagramChannel.open();
dc.configureBlocking(false);
ByteBuffer buf = ByteBuffer.allocate(1024);
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
String str = scan.next();
buf.put((new Date().toString() + ":\n" + str).getBytes());
buf.flip();
dc.send(buf, new InetSocketAddress("127.0.0.1", 9898));
buf.clear();
}
dc.close();
}
@Test
public void receive() throws IOException{
DatagramChannel dc = DatagramChannel.open();
dc.configureBlocking(false);
dc.bind(new InetSocketAddress(9898));
Selector selector = Selector.open();
dc.register(selector, SelectionKey.OP_READ);
while(selector.select() > 0){
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
while(it.hasNext()){
SelectionKey sk = it.next();
if(sk.isReadable()){
ByteBuffer buf = ByteBuffer.allocate(1024);
dc.receive(buf);
buf.flip();
System.out.println(new String(buf.array(), 0, buf.limit()));
buf.clear();
}
}
it.remove();
}
}
}对比Socket而言，这里少了accept一步。
【6】管道(Pipe)
Java NIO 管道是2个线程之间的单向数据连接。
Pipe有一个source通道和一个sink通道。数据会被写到sink通道，从source通道读取。
代码示例如下：
@Test
public void test1() throws IOException{
//1. 获取管道
Pipe pipe = Pipe.open();
//2. 将缓冲区中的数据写入管道
ByteBuffer buf = ByteBuffer.allocate(1024);
Pipe.SinkChannel sinkChannel = pipe.sink();
buf.put("通过单向管道发送数据".getBytes());
//切换为读取模式
buf.flip();
sinkChannel.write(buf);
//3. 读取缓冲区中的数据
Pipe.SourceChannel sourceChannel = pipe.source();
//切换为读取模式
buf.flip();
int len = sourceChannel.read(buf);
System.out.println(new String(buf.array(), 0, len));
sourceChannel.close();
sinkChannel.close();
}
【7】NIO编程的优点
通过上面的代码实例，我们可以总结NIO编程的优点如下：
（1）客户端发起的连接操作是异步的，可以通过在多路复用器注册OP_CONNECT等待后续结果，不需要像之前的客户端那样被同步阻塞。
（2）SocketChannel的读写操作都是异步的，如果没有可读写的数据它不会同步等待，直接返回，这样IO通信线程就可以处理其他的链路，不需要同步等待这个链路可用。
（3）线程模型的优化：由于JDK的Selector在Linux等主流操作系统上通过epoll实现，它没有连接句柄数的限制(只受限于操作系统的最大句柄数或者对单个进程的句柄限制)，这意味着一个Selector线程可以同时处理成千上万个客户端连接，而且性能不会随着客户端的增加而线性下降。因此，它非常适合做高性能、高负载的网络服务器。
JDK1.7升级了NIO类库，升级后的NIO类库被称为NIO2.0，这个版本中Java正式提供了异步文件IO操作，同时提供了与UNIX网络编程事件驱动IO对应的AIO。
参考博文：NIO - NIO.2中的文件与资源支持
