JAVA NIO整理
I/O模型
Java共支持3种网络编程模型I/O模式：BIO、NIO、AIO。
BIO： 同步并阻塞。就是Java原生的IO，一请求一应答，一个连接一个线程，即客户端有连接请求时服务端就需要启动一个线程处理，并且如果这个连接没做任何事情会造成不必要的线程开销。可以使用线程池机制来改善。
NIO： 同步非阻塞，服务器实现模式为一个线程处理多个请求（连接），客户端发送的链接请求都会注册到多路复用器上，多路复用器轮训到连接有IO请求就处理。
AIO： 异步非阻塞，NIO2版本，目前来说应用还不是很广泛。
BIO以流的方式处理数据，NIO以块的方式处理数据，块IO的效率比流IO高很多。BIO基于字节流和字符流进行操作，而NIO基于Channel(通道)和Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区或从缓冲区写入到通道。Selector选择器用于监听多个通道的事件，比如连接请求，数据到达。因此使用单个线程就可以监听多个客户端通道。
NIO三个核心原理：Selector、Channel、Buffer
1、每个Channel都对应一个Buffer
2、Selelctor对应一个线程，一个线程对应一个Channel连接
3、下图反应了有三个channel注册到该selector
4、Selector会根据不同事件在各个通道上切换
5、Buffer是一个内存块，底层是一个数组
6、NIO的Buffer可以读也可以写，需要filp方法切换
Buffer： 是一个可以读写数据的内存块，对象里提供了一组方法可以更轻松使用内存块，程序读写数据都必须经过Buffer。常用Buffer子类有ByteBuffer、ShortBuffer、CharBuffer、IntBuffer、LongBuffer、DoubleBuffer、FloatBuffer，它们可以将对应的数据存储到缓冲区。
Buffer类定义了所有的缓冲区都具有的四个属性：
private int position = 0; // 位置，下一个要被读或写的元素的索引，每次读写缓存区数据时都会改变这个值，为下次读写作准备
private int limit; // 缓冲区终点，不能对超过极限的位置进行读写操作，可以修改
private int capacity; // 可以容纳的最大数据量，缓冲区创建时就被设定且不可改变
private int mark = -1; // 标记
主要方法：
public abstract class Buffer {
// 返回此缓冲区的容量
public final int capacity() {}
// 返回缓冲区容量
public final int position() {}
// 设置缓冲区容量
public final Buffer position(int newPosition) {}
// 返回此缓冲区的限制
public final int limit() {}
// 设置此缓冲区的限制
public final Buffer limit(int newLimit) {}
// 清除缓冲区，将各个标记恢复到初始状态，但是数据并没有真正擦除
public final Buffer clear() {
}
// 反转此缓冲区
public final Buffer flip() {
limit = position;
position = 0;
mark = -1;
return this;
}
// 当前位置和限制之间是否有元素
public final boolean hasRemaining() {
return position < limit;
}
// 此缓冲区是否为只读 抽象方法
public abstract boolean isReadOnly();
// 此缓冲区是否具有可访问的底层实现数组 抽象方法 since 1.6
public abstract boolean hasArray();
// 返回底层数组实现 抽象方法 since 1.6
public abstract Object array();
}
Buffer类最常用的子类是用于网络传输的ByteBuffer：
public abstract class ByteBuffer extends Buffer implements Comparable<ByteBuffer>
{
// 创建直接缓冲区
public static ByteBuffer allocateDirect(int capacity) {
return new DirectByteBuffer(capacity);
}
// 设置缓冲区的初始容量
public static ByteBuffer allocate(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
return new HeapByteBuffer(capacity, capacity);
}
/** 存取相关API **/
// 从当前位置position上get，get之后position自动+1
public abstract byte get();
// 从当前位置上添加，put之后，position自动+1
public abstract ByteBuffer put(byte b);
// 从绝对位置get
public abstract byte get(int index);
// 从绝对位置上put
public abstract ByteBuffer put(int index, byte b);
// 其他api
......
}
Channel： 我们知道BIO中stream流是单向的，例如FileInputStream对象只能进行读取。而NIO中的通道是双向的，可读也可写。
Channel类是一个接口：
public interface Channel extends Closeable {}
常用的Channel类有：FileChannel用于文件读写、DatagramChannel用于UDP数据读写、ServerSocketChannel和SocketChannel用于TCP数据读写。
FileChannel抽象类：
// 从通道读取数据放入缓冲区（注意读写要站在内存Buffer的角度看）
public abstract int read(ByteBuffer dst);
public abstract long read(ByteBuffer[] dsts, int offset, int length);
// 将缓冲区的数据写入到通道
public abstract int write(ByteBuffer src);
// 将目标通道中数据复制到当前通道
public abstract long transferFrom(ReadableByteChannel src, long position, long count);
// 将数据从当前通道复制给目标通道
public abstract long transferTo(long position, long count, WritableByteChannel target)
下面一个实例帮助理解，ByteBuffer和FileChannel，实现一个txt文件内容拷贝到另一个txt文件：
public static void main(String[] args) throws Exception {
// 读取磁盘中的输入流
FileInputStream inputStream = new FileInputStream("c://test/a.txt");
FileChannel inputStreamChannel = inputStream.getChannel();
FileOutputStream outputStream = new FileOutputStream("c://test/b.txt");
FileChannel outputStreamChannel = outputStream.getChannel();
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
while (true){
// 清空Buffer
byteBuffer.clear();
// 将输入通道中的数据读到缓冲区中
int read = inputStreamChannel.read(byteBuffer);
if(read == -1){
break;
}
// 将缓冲区中的数据写入到输出通道中
byteBuffer.flip();
outputStreamChannel.write(byteBuffer);
}
inputStream.close();
outputStream.close();
}
关于Buffer和Channel的注意事项和细节：
1、ByteBuffer支持类型化put和get，put放入的是什么类型，get就应该使用相应类型的方法取出，否则可能有BufferUnderflowException。
2、一个普通的Buffer可以转成只读Buffer，使用buffer.asReadOnlyBuffer()方法。
3、NIO还提供一种系统级别比较高的MappedByteBuffer抽象类，可以让文件直接在内存（堆外内存）修改，操作系统不需要拷贝一次。
4、NIO还支持分散读取(Scattering Reads)与聚集写入(Gathering Writes)：分散读取指将通道中的数据分散读到多个缓冲区中，采用buffer数组依次写入；聚集写入指将多个缓冲区的数据聚集写到通道中，采用buffer数组，依次读。
Selector： Selector能检测多个注册的通道上是否有事件发生，多个Channel以事件的方式可以注册到同一个Selector。
特点说明：
1、IO线程NioEventLoop(时间轮训)聚合了Selector(多路复用)，可以同时并发处理成百上千个客户端连接。
2、当线程从某客户端Socket通道进行读写数据时，若没有数据可用，该线程可以进行其他任务。
3、线程通常将非阻塞IO的空闲时间用于在其他通道上执行IO操作，所以单独的线程可以管理多个输入和树池通道。
4、由于读写操作都是非阻塞的，这就可以充分提升IO线程的运行效率，避免由于频繁I/O阻塞导致的线程挂起。
5、一个I/O线程可以并发处理N个客户端连接和读写操作，这从根本上解决了传统同步阻塞IO一连接一线程模型，架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。
Selector API介绍：
public abstract class Selector implements Closeable {
// 得到一个选择器对象
public static Selector open() throws IOException {}
// 监控所有注册的通道，当其中有IO操作可以进行时，将对应的SelectionKey加入到内部集合中并返回，阻塞方法，参数用来设置超时时间，在规定时间没有事件就会返回。
public abstract int select(long timeout) throws IOException;
// 从内部集合几种得到所有的SelectionKey
public abstract Set<SelectionKey> selectedKeys();
// 不阻塞，立马返回
public abstract int selectNow() throws IOException;
// 唤醒Selector
public abstract Selector wakeup();
}
NIO非阻塞网络编程原理分析：（Selector、SelectionKey、ServerSocketChannel、SocketChannel）关系。
1、当客户端连接时，会通过ServerSocketChannel得到SocketChannel
2、将SocketChannel注册到Selector上
3、注册后返回一个SelectionKey，会和该Selector关联(集合)
4、Selector进行监听(用select方法)，返回有事件发生的通道的个数
5、进一步得到各个SelectionKey(有事件发生)
6、再通过SelectionKey反向获取SocketChannel
7、可以通过得到的Channel完成业务处理
下面一个NIO实现服务器和客户端之间的简单数据通讯，理解NIO非阻塞网络编程机制：
服务端：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;
public class NIOServer {
public static void main(String[] args) throws IOException {
// 创建ServerSocketChannel
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
// 创建Selector
Selector selector = Selector.open();
// 绑定一个端口6666，在服务端监听
serverSocketChannel.socket().bind(new InetSocketAddress(6666));
// 设置非阻塞
serverSocketChannel.configureBlocking(false);
// 把serverSocketChannel注册到selector 事件为OP_ACCEPT
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
// 循环等待客户端连接
while (true){
//等待一秒钟，如果还没有连接时间发生 就去干别的事 selectNow()
if(selector.select(1000) == 0){
System.out.println("服务端等待了1秒，无连接");
continue;
}
// 获取相关的SelectionKey集合，通过SelectionKey反向获取通道
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while (iterator.hasNext()){
SelectionKey selectionKey = iterator.next();
// 有新的客户端连接
if(selectionKey.isAcceptable()){
// 为该客户端生成一个socketChannel
SocketChannel socketChannel = serverSocketChannel.accept();
System.out.println("客户端连接成功，生成了一个SocketChannel：" + socketChannel.hashCode());
// 将socketChannel设为非阻塞
socketChannel.configureBlocking(false);
// socketChannel注册到selector，关注事件为OP_READ，同时关联一个buffer
socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
}
if(selectionKey.isReadable()){
// 获取到channel和buffer
SocketChannel channel = (SocketChannel)selectionKey.channel();
ByteBuffer buffer = (ByteBuffer)selectionKey.attachment();
channel.read(buffer);
System.out.println("from 客户端：" + new String(buffer.array()));
}
// 从当前集合中移除selectionKey，防止并发重复
iterator.remove();
}
}
}
}
客户端：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
public class NIOClient {
public static void main(String[] args) throws IOException {
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);
if(!socketChannel.connect(inetSocketAddress)){
while (!socketChannel.finishConnect()){
System.out.println("因为连接需要时间，客户端不会阻塞，可以在这里进行其它操作...");
}
}
String str = "Hello, guy";
ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
socketChannel.write(byteBuffer);
System.in.read();
}
}
先运行服务端，再运行客户端，结果为：
服务端等待了1秒，无连接
服务端等待了1秒，无连接
服务端等待了1秒，无连接
服务端等待了1秒，无连接
服务端等待了1秒，无连接
客户端连接成功，生成了一个SocketChannel：681842940
from 客户端：Hello, guy
服务端等待了1秒，无连接
服务端等待了1秒，无连接
服务端等待了1秒，无连接
服务端等待了1秒，无连接
总结
NIO的优点是效率高，原因是它是非阻塞的；使用零拷贝，不需要将数据读取到OS内核缓冲区，直接从内存中读写文件；一个线程处理多个请求（连接），管理多个输入和输出通道，请求都会注册到多路复用器上，多路复用器轮训到连接有IO请求就处理。
缺点是NIO底层由 epoll 实现，该实现饱受诟病的空轮询 bug 会导致 cpu 飙升 100%。项目庞大之后，自行实现的 NIO 很容易出现各类 bug，维护成本较高
由此，netty进行了很大程度的改善。
资料：
Jave Guide BIO,NIO,AIO 总结：https://snailclimb.gitee.io/javaguide/#/docs/java/BIO-NIO-AIO
彻底搞懂NIO效率高的原理：https://mp.weixin.qq.com/s/wVoHfhh28Vh5sgKQbPXk8w
NIO效率高的原理之零拷贝与直接内存映射：https://www.jianshu.com/p/a4325188f974
