什么是NIO
NIO又叫New/Non-blocking IO，这个概念基本人人都听过，但是不一定每个人都懂他它的运行的原理。
这里我们来探讨这个问题，先用一个例子解释一下BIO到底阻塞了哪里。
/**
* 这是一个单线程BIOServer
* @author endless
* @create 2020-03-23
*/
public class BioServerDemo {
public static void main(String[] args) throws IOException {
// 创建ServerSocket，并绑定端口
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务启动成功");
while (true) {
Socket socket = serverSocket.accept();
System.out.println("连接成功");
System.out.println("准备接收数据");
byte[] bytes = new byte[1024];
socket.getInputStream().read(bytes);
System.out.println("接收到了数据：" + new String(bytes));
}
}
}
/**
* BIO client
*
* @author endless
* @create 2020-03-23
*/
public class BioClientDemo {
public static void main(String[] args) throws IOException {
// 连接Server
Socket socket = new Socket("127.0.0.1", 9999);
System.out.println("连接成功");
Scanner scanner = new Scanner(System.in);
// 循环等待输入消息
while (true) {
String str = scanner.next();
// 约定退出口令
if ("exit".equalsIgnoreCase(str)) {
socket.close();
System.exit(0);
}
socket.getOutputStream().write(str.getBytes());
socket.getOutputStream().flush();
}
}
}
先运行Server
命令行打印服务启动成功，此时并无客户端连接，所以连接成功并未打印，说明程序被阻塞在了serverSocket.accept()方法
此时运行Client，Server打印日志连接成功和准备接收数据，此时Client尚未发送数据，Server被阻塞在
socket.getInputStream().read(bytes)上，因此其他客户端无法进行连接。
在Client输入Hello回车，此时Server打印接收到了数据：Hello，说明客户端的连接发送过来数据了，此时服务端线程才解阻塞，在这
个情况下，这个Server没有办法处理并发，同时期只能处理一个连接。
那么BIO是如何实现并发呢？答案也很明显，就是使用多线程，我们对Server进行一些小改动。
/**
* 这是一个BIOServer
* @author endless
* @create 2020-03-23
*/
public class BioServerDemo {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务启动成功");
while (true) {
Socket socket = serverSocket.accept();
new Thread(()->{
System.out.println("连接成功");
System.out.println("准备接收数据");
byte[] bytes = new byte[1024];
try {
socket.getInputStream().read(bytes);
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("接收到了数据：" + new String(bytes));
}).start();
}
}
}
使用子线程来对接收到的Socket进行处理，这样每个连接都被阻塞在单独的线程上，就可以实现并发访问Server。
总结：BIO的阻塞有两个地方：accept()和read()，并且BIO的并发只能通过多线程。
但是这里会有一个问题，就是如果绝大部分的连接都没有进行数据传输，只是建立了连接，这样就会产生很多无效的线程，而线程又
是非常宝贵的稀缺资源，这样就会白白损失很多的性能，这也是BIO最大的性能瓶颈。
那能不能只用一个线程就能实现并发并且处理全部的连接呢？是否能设计一个Api，让accept和read不再阻塞，使用一个线程就能处
理并发连接呢？答案是肯定的，这里就要用到我们的今天的主角NIO了。
NIO在JDK中被封装在了一个新的类中，我们先来写一个例子，这个例子实现了使用单线程来处理多连接。
/**
* NIO Server Demo
*
* @author endless
* @create 2020-03-23
*/
public class NioServerDemo {
// 保存客户端连接
static List<SocketChannel> channelList = new ArrayList<>();
public static void main(String[] args) throws IOException, InterruptedException {
// 创建NIO ServerSocketChannel
ServerSocketChannel serverSocket = ServerSocketChannel.open();
serverSocket.bind(new InetSocketAddress(9998));
// 设置ServerSocketChannel为非阻塞
serverSocket.configureBlocking(false);
System.out.println("服务启动成功");
while (true) {
SocketChannel socketChannel = serverSocket.accept();
if (socketChannel != null) { // 如果有客户端进行连接
System.out.println("连接成功");
// 设置SocketChannel为非阻塞
socketChannel.configureBlocking(false);
// 保存客户端连接在List中
channelList.add(socketChannel);
}
// 遍历连接进行数据读取
Iterator<SocketChannel> iterator = channelList.iterator();
while (iterator.hasNext()) {
SocketChannel o = iterator.next();
ByteBuffer byteBuffer = ByteBuffer.allocate(128);
int read = o.read(byteBuffer);
// 如果有数据，把数据打印出来
if (read > 0) {
System.out.println("接收到消息：" + new String(byteBuffer.array()));
} else if (read == -1) { // 如果客户端断开，把socket从集合中去掉
iterator.remove();
System.out.println("客户端断开连接");
}
}
}
}
}
客户端可以复用之前的BIO客户端
运行NIOServer，Server启动完毕后运行两个Client，各发送一条消息进行测试
控制台显示两个连接成功，并且接收到了来自两个客户端的消息，表明Server可以使用单线程处理并发连接，这个Api的原理是什么呢？我们来进一步探究一下。
我们沿着源码一路往下找，会找到一个无法下载源码的文件
这里可以看得出，在Windows系统中，编译后的代码显示直接返回了WindowsSelectorProvider对象，很显然，这个对象是在和windows系统核心中的select方法交互，但是Linux中是不是也是这样呢，我们需要下载一个Linux版本的OpenJDK源码来探究一下。下载
OpenJDK源码
下载后解压，Linux源码分布在\openjdk\jdk\src\share和\openjdk\jdk\src\solaris目录中。
在上图中可以看出，JDK在不同的系统中采用了不同的实现方案，这里使用的是EPollSelectorProvider，说明在Linux中，使用的是EPoll来实现的。
我们先来看看serverSocket.configureBlocking(false);到底是如何工作的，沿着源码往下找，发现一个本地方法。
这个本地方法的源码可以在OpenJDK中找到，如下图
上图红框中的函数就是这个本地方法调用的底层C语言的方法，前面的前缀是根据JNI调用规则添加的，我们知道，在C当中是可以直接调用操作系统的Api的，这个方法调用了fcntl这个命令，把传进来的blocking参数设置到了文件描述符上（文件描述符可以看作是一个对象，Linux中一切皆文件，类似于高级语言中的一切皆对象，任何的数据流转都要通过一个文件描述符来操作）。
接着看看serverSocket.accept()是如何实现
上图可以看到，accept方法调用了一个native方法accept0
这个accept0方法的描述简单翻译一下，就是接受一个新的连接，把给定的文件描述符引用设置为新的Socket，并将isaa[0]设置为套接字的远程地址，成功返回1，不成功返回IOStatus.UNAVAILABLE or IOStatus.INTERRUPTED。
继续探究一下本地方法的源码
这里调用了操作系统的accept方法，想知道这个方法文档的同学可以在Linux环境中使用man命令来查看
man命令可以查看Linux详尽的文档，2表示第二章：系统调用指令，最后加上你想查的指令方法即可
这里主要看一下返回值，accept返回一个非负数作为socket的描述符，如果失败返回-1。通过这个文件描述符，Java就可以通过native方法调用操作系统的API来在Socket中进行数据的传输。我们的代码用一个List保存了接收到的Socket，相当于保存了Socket的文件描述符，通过一个线程轮询这些文件描述符即可实现数据通信和处理新连接，这样就节约了大量的线程资源，但是大家想一想这种模型还有什么缺陷。
……
是的，如果连接数太多的话，还是会有大量的无效遍历，例如10000个连接中只有1000个连接时有数据的，但是由于其他9000个连接并没有断开，我们还是要每次轮询都遍历一万次，相当于有十分之九的遍历都是无效的，这显然不是一个让人很满意的状态。
总结：NIO的非阻塞是由操作系统来完成的，SocketChannel与文件描述符一一对应，通过遍历文件描述符来读取数据。
什么是多路复用器
上面的例子还不是Java NIO的完全体，仅仅是将原来的同步阻塞IO优化成了同步非阻塞IO，既然还是同步的，就意味着我们每次遍
历，还是需要对每个Socket进行一次read操作来检查是不是有数据过来，都会调用系统内核的read指令，只不过是把阻塞变成了非阻
塞，如果无用连接很多的话，那么绝大部分的read指令都是无意义的，这就会占用很多的CPU时间。
Linux有select、poll和epoll三个解决方案来实现多路复用，其中的select和poll，有点类似于上面的NIOServerDemo程序，他会把
所有的文件描述符记录在一个数组中，通过在系统内核中遍历来筛选出有数据过来的Socket，只不过是从应用程序中遍历改成了在内核中
遍历，本质还是一样的。
Epoll则使用了事件机制，在复用器中注册了一个回调事件，当Socket中有数据过来的时候调用，通知用户处理信息，这样就不需要对
全部的文件描述符进行轮训了，这就是Epoll对NIO进行的改进。
我们来探究一下在Java中是如何用Epoll实现NIO事件机制的，先对上面的NIOServerDemo再进行改进。
/**
* NIO Selector Server Demo
*
* @author endless
* @create 2020-03-23
*/
public class NioSelectorServerDemo {
public static void main(String[] args) throws IOException, InterruptedException {
// 创建NIO ServerSocketChannel
ServerSocketChannel serverSocket = ServerSocketChannel.open();
serverSocket.socket().bind(new InetSocketAddress(9998));
// 设置ServerSocketChannel为非阻塞
serverSocket.configureBlocking(false);
// 打开Selector处理Channel，即创建epoll
Selector selector = Selector.open();
// 将ServerSocket注册到selector用来接收连接
serverSocket.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("服务启动成功");
while (true) {
// 阻塞等待需要处理的事件发生
selector.select();
// 获取selector中注册的全部事件的 SelectionKey 实例
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
// 遍历SelectionKey对事件进行处理
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
iterator.remove();
// 如果是OP_ACCEPT事件，则进行连接获取和事件注册
if (key.isAcceptable()) {
ServerSocketChannel server = (ServerSocketChannel) key.channel();
SocketChannel socketChannel = server.accept();
socketChannel.configureBlocking(false);
// 这里只注册了读事件，如果需要给客户端发送数据可以注册写事件
socketChannel.register(selector, SelectionKey.OP_READ);
System.out.println("客户端连接成功");
}
// 如果是OP_READ事件，则进行读取和打印
if (key.isReadable()) {
SocketChannel socketChannel = (SocketChannel) key.channel();
ByteBuffer byteBuffer = ByteBuffer.allocate(128);
int read = socketChannel.read(byteBuffer);
// 如果有数据，把数据打印出来
if (read > 0) {
System.out.println("接收到消息：" + new String(byteBuffer.array()));
} else if (read == -1) { // 如果客户端断开连接，关闭Socket
System.out.println("客户端断开连接");
socketChannel.close();
}
}
}
}
}
}
这段代码需要关注的点有以下几个方法：
- Selector.open()
- socketChannel.register()
- selector.select()
接下来就来看看这三个方法究竟做了什么。
Select.open()
首先调用了SelectorProvider的openSelector()方法，这个方法返回一个EPollSelectorImpl实例
EPollSelectorProvider.java
public AbstractSelector openSelector() throws IOException {
return new EPollSelectorImpl(this);
}
EPollSelectorImpl的构造方法中new了一个EPollArrayWrapper实例
EPollSelectorImpl.java
EPollSelectorImpl(SelectorProvider sp) throws IOException {
super(sp);
// 创建管道，用long类型返回管道的两个文件描述符。读端以高32位的形式返回，写端以低32位的形式返回。
long pipeFds = IOUtil.makePipe(false);
fd0 = (int) (pipeFds >>> 32);
fd1 = (int) pipeFds;
// 创建Epoll文件描述符，并且创建映射数组记录事件
pollWrapper = new EPollArrayWrapper();
// 初始化中断文件描述符，把新创建的Epoll注册到管道的读文件描述符上
pollWrapper.initInterrupt(fd0, fd1);
fdToKey = new HashMap<>();
}
EPollArrayWrapper的构造方法中创建了Epoll实例
EPollArrayWrapper.java
EPollArrayWrapper() throws IOException {
// 创建了Epoll实例，并将它的事件数组地址记录下来方便操作
epfd = epollCreate();
// the epoll_event array passed to epoll_wait
int allocationSize = NUM_EPOLLEVENTS * SIZE_EPOLLEVENT;
pollArray = new AllocatedNativeObject(allocationSize, true);
pollArrayAddress = pollArray.address();
// eventHigh needed when using file descriptors > 64k
if (OPEN_MAX > MAX_UPDATE_ARRAY_SIZE)
eventsHigh = new HashMap<>();
}
...
private native int epollCreate();
Native方法epollCreate()的源码，调用了内核的epoll_create指令，创建并获取了一个文件描述符。
epoll有三个指令，epoll_create、epoll_ctl、epoll_wait，都可以在Linux环境中使用man命令来查看详细文档。
EPollArrayWrapper.c
JNIEXPORT jint JNICALL
Java_sun_nio_ch_EPollArrayWrapper_epollCreate(JNIEnv *env, jobject this)
{
/*
* epoll_create expects a size as a hint to the kernel about how to
* dimension internal structures. We can't predict the size in advance.
*/
int epfd = epoll_create(256);
if (epfd < 0) {
JNU_ThrowIOExceptionWithLastError(env, "epoll_create failed");
}
return epfd;
}
socketChannel.register()
注册事件时其实并没有对Epoll进行事件添加，而是在只是把它加入了待添加的容器。
public final SelectionKey register(Selector sel, int ops,
Object att)
throws ClosedChannelException
{
synchronized (regLock) {
if (!isOpen())
throw new ClosedChannelException();
if ((ops & ~validOps()) != 0)
throw new IllegalArgumentException();
if (blocking)
throw new IllegalBlockingModeException();
// 判断是否存在事件的key，存在的话就更新，不存在就新建
// 最终都会走到 EPollArrayWrapper#setUpdateEvents方法
SelectionKey k = findKey(sel);
if (k != null) {
k.interestOps(ops);
k.attach(att);
}
if (k == null) {
// New registration
synchronized (keyLock) {
if (!isOpen())
throw new ClosedChannelException();
k = ((AbstractSelector)sel).register(this, ops, att);
addKey(k);
}
}
return k;
}
}
AbstractSelector.register调用实现的子类方法implRegister
EPollSelectorImpl.java
protected void implRegister(SelectionKeyImpl ski) {
if (closed)
throw new ClosedSelectorException();
SelChImpl ch = ski.channel;
int fd = Integer.valueOf(ch.getFDVal());
fdToKey.put(fd, ski);
pollWrapper.add(fd);
keys.add(ski);
}
调用setUpdateEvents写入待更新事件容器
EPollArrayWrapper.java
/**
* Add a file descriptor
*/
void add(int fd) {
// 强制初始update events为0，因为他可能会被之前注册kill掉
synchronized (updateLock) {
assert !registered.get(fd);
setUpdateEvents(fd, (byte)0, true);
}
}
/**
* 设置文件描述符的待更新事件到 eventsHigh 中。
*/
private void setUpdateEvents(int fd, byte events, boolean force) {
if (fd < MAX_UPDATE_ARRAY_SIZE) {
if ((eventsLow[fd] != KILLED) || force) {
eventsLow[fd] = events;
}
} else {
Integer key = Integer.valueOf(fd);
if (!isEventsHighKilled(key) || force) {
eventsHigh.put(key, Byte.valueOf(events));
}
}
}
selector.select()
调用selector.select()时，会将刚才注册的待更新事件绑定到文件描述符上，然后进入阻塞状态等待事件回调。
EPollSelectorImpl.java
protected int doSelect(long timeout) throws IOException {
if (closed)
throw new ClosedSelectorException();
processDeregisterQueue();
try {
begin();
pollWrapper.poll(timeout);
} finally {
end();
}
processDeregisterQueue();
int numKeysUpdated = updateSelectedKeys();
if (pollWrapper.interrupted()) {
// Clear the wakeup pipe
pollWrapper.putEventOps(pollWrapper.interruptedIndex(), 0);
synchronized (interruptLock) {
pollWrapper.clearInterrupted();
IOUtil.drain(fd0);
interruptTriggered = false;
}
}
return numKeysUpdated;
}
EPollArrayWrapper.java
int poll(long timeout) throws IOException {
// 将上一步待更新的时间进行注册
updateRegistrations();
// 进入阻塞状态，等待事件发生
updated = epollWait(pollArrayAddress, NUM_EPOLLEVENTS, timeout, epfd);
for (int i=0; i<updated; i++) {
if (getDescriptor(i) == incomingInterruptFD) {
interruptedIndex = i;
interrupted = true;
break;
}
}
return updated;
}
/**
* Update the pending registrations.
*/
private void updateRegistrations() {
synchronized (updateLock) {
int j = 0;
while (j < updateCount) {
int fd = updateDescriptors[j];
short events = getUpdateEvents(fd);
boolean isRegistered = registered.get(fd);
int opcode = 0;
if (events != KILLED) {
if (isRegistered) {
opcode = (events != 0) ? EPOLL_CTL_MOD : EPOLL_CTL_DEL;
} else {
opcode = (events != 0) ? EPOLL_CTL_ADD : 0;
}
if (opcode != 0) {
// 调用native方法进行事件绑定
epollCtl(epfd, opcode, fd, events);
if (opcode == EPOLL_CTL_ADD) {
registered.set(fd);
} else if (opcode == EPOLL_CTL_DEL) {
registered.clear(fd);
}
}
}
j++;
}
updateCount = 0;
}
}
总结：到此为止，我们已经粗略的把整个NIO调用流程都梳理了一遍，Java调用了操作系统的Api来创建Socket，获取到Socket的文件描述符，再创建一个Selector对象，对应操作系统的EPoll描述符，将获取到的Socket连接的文件描述符的事件绑定到Selector对应的EPoll文件描述符上，进行事件的异步通知，这样就实现了使用一条线程，并且不需要太多的无效的遍历，将事件处理交给了操作系统内核，大大提高了效率。
EPoll指令详解
epoll_create
int epoll_create(int size);
创建一个epoll实例，并返回一个非负数作为文件描述符，用于对epoll接口的所有后续调用。参数size代表可能会容纳size个描述符，但size不是一个最大值，只是提示操作系统它的数量级，现在这个参数基本上已经弃用了。
epoll_ctl
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
使用文件描述符epfd引用的epoll实例，对目标文件描述符fd执行op操作。
参数epfd表示epoll对应的文件描述符，参数fd表示socket对应的文件描述符。
参数op有以下几个值：EPOLL_CTL_ADD：注册新的fd到epfd中，并关联时间eventEPOLL_CTL_MOD：修改已经注册的fd的监听事件；EPOLL_CTL_DEL：从epfd中移除fd，并且忽略掉绑定的event，这时event可以为null；
参数event是一个结构体。
struct epoll_event {
__uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};
typedef union epoll_data {
void *ptr;
int fd;
__uint32_t u32;
__uint64_t u64;
} epoll_data_t;
events有很多可选值，这里只举例最常见的几个：
EPOLLIN ：表示对应的文件描述符是可读的（close也会发送消息）；EPOLLOUT：表示对应的文件描述符是可写的；EPOLLERR：表示对应的文件描述符发生了错误；
成功则返回0，失败返回-1
epoll_wait
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
等待文件描述符epfd上的事件。
epfd是Epoll对应的文件描述符，events表示调用者所有可用事件的集合，maxevents表示最多等到多少个事件就返回，timeout是超时时间。
完
操作系统的IO还涉及到零拷贝和直接内存两部分的知识，也是操作系统提高性能的利器，将在以后的文章中进行探讨。