重新认识BIO、NIO、IO多路复用、Select、Poll、Epollo它们之间的关系

一、背景

二、名词理解

（1）BIO

（2）NIO

（3）IO多路复用

Select%E3%80%81Poll%E3%80%81Epollo-toc" style="margin-left:80px;">（4）Select、Poll、Epollo

三、他们之间的关系总结

一、背景

最近又在学习网络IO相关知识，对我们常说的BIO、NIO、IO多路复用、Select、Poll、Epollo之间到底是什么关系，进行重新学习以及总结，特此记录一下。希望对一样迷惑的朋友也有一定的帮助

二、名词理解

（1）BIO

BIO它是Blocking IO的缩写，它的关键的特点就是阻塞IO，什么叫阻塞IO呢，就是你可以理解为它处理连接、读写事件是阻塞的，它采用阻塞方式进行数据读写操作。即当一个线程在执行IO操作时，若没有数据可读，则该线程会一直阻塞等待，直到有数据可读或者超时。如果还不理解我们不妨看看具体的BIO服务端实现的代码，加深自己的理解。

BIO服务端代码

package bio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * bio - server 类
 *
 * @author chen
 * @date 2024年03月10日 10:43
 */
public class BioServer {
    public static void main(String[] args) {
        try {
            System.out.println("*****服务端启动******");
            //定义一个ServerSocket对象进行一个服务端的接口注册
            ServerSocket serverSocket = new ServerSocket(8888);
            //监听客户端的Socket链接请求
            Socket socket = serverSocket.accept();
            //从socket对象中得到一个字节输入流对象
            InputStream is = socket.getInputStream();
            //将字节输入流包装成一个缓冲字符输入流（不能直接将字节输入流包装成缓冲字符输入流，先将字节输入流转成字符输入流，再转成缓冲字符输入流）
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println("服务端收到信息:"+msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

这里我们看到BIO的accept和read方法都是阻塞方法，也就是说线程一旦调用就会进行阻塞

看到这里我们不妨可以思考一下，那我如果想实现多连接处理应该怎么实现？

既然我们一个连接一个线程，那是否我们可以看更多的线程去处理连接，没错，早期的BIO是这样都是这样去处理的，如下代码，加入线程池后的处理

package bio;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * TODO 类功能描述
 *
 * @author chen
 * @date 2024年03月10日 10:43
 */
public class BioMoreThreadServer {
    public static ExecutorService executorService = Executors.newFixedThreadPool(2);
    public static void main(String[] args) {
        try {
            System.out.println("*******服务端启动*********");
            //注册端口
            ServerSocket ss = new ServerSocket(8888);
            //定义一个死循环，负责不断的接收客户端的Socket的连接请求
            while (true){
                Socket socket = ss.accept();
                //创建一个独立的线程来处理这个客户端socket的通信需求
//                new ServerThreadReader(socket).start();
                //用线程池替代，线程池只是解决了防止频繁创建和销毁线程，并没有解决可以更多的支持连接这个问题（连接数还是有限）
                executorService.submit(new ServerThreadReader(socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

这里需注意一个细节，加入线程池后，并没有解决能够支持更多的连接的问题，仅仅只是防止线程频繁创建以及销毁，降低系统压力。

看完了BIO我们会提出一个疑问，那如果能够支持更大的连接数呢？

（2）NIO

NIO是Java 1.4引入的新的IO模型，它采用了多路复用器（Selector）机制，通过少量线程同时管理多个通道，实现了单线程同时处理多个请求的效果。NIO具有高并发性、高吞吐量和更高的可靠性，适合处理连接数多且连接时间较短的场景。NIO的核心组件包括通道(Channel)、缓冲区(Buffer)和选择器(Selector)。选择器允许程序同时等待多个通道上的事件，如连接、数据到达等。

从我个人理解的角度，就是新的网络IO模型，增加了在网络IO读取过程中的一些特性，例如非阻塞、高吞吐、高并发性。那么他跟IO多路复用有什么关系呢？

（3）IO多路复用

IO多路复用（IO Multiplexing）一种同步IO模型，单个进程/线程就可以同时处理多个IO请求。一个进程/线程可以监视多个文件句柄；一旦某个文件句柄就绪，就能够通知应用程序进行相应的读写操作；没有文件句柄就绪时会阻塞应用程序，交出cpu。多路是指网络连接，复用指的是同一个进程/线程。

这里从我个人的角度理解，以盖房子为例，NIO是一个基础，提供了大量的基础工具（通道[Channel]、缓冲区[Buffer]和选择器[Selector]等等），就像一个我们要盖房子的各种工具已经给你备好了，接下来我们要盖一个怎样的房子(IO多路复用)，相当于我们用NIO的技术实现了IO多路复用，如果没有NIO本身这项技术的支持，就不可能实现IO多路复用。

IO多路复用的代码实现

package 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;
import java.util.Set;

/**
 * TODO 类功能描述
 *
 * @author chen
 * @date 2024年03月10日 13:01
 */
public class NioServer {
    public static void main(String[] args) {
        try {
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.bind(new InetSocketAddress(8888));
            Selector selector = Selector.open();
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            // 无限判断当前线程状态，如果没有中断，就一直执行while内容。
            while(!Thread.currentThread().isInterrupted()){
                // 获取准备就绪的channel
                if (selector.select() == 0) {
                    continue;
                }
                // 获取到对应的 SelectionKey 对象
                Set<SelectionKey> keys = selector.selectedKeys();
                Iterator<SelectionKey> keyIterator = keys.iterator();
                // 遍历所有的 SelectionKey 对象
                while (keyIterator.hasNext()){
                    // 根据不同的SelectionKey事件类型进行相应的处理
                    SelectionKey key = keyIterator.next();
                    if (!key.isValid()){
                        continue;
                    }
                    if (key.isAcceptable()){
                        accept(serverSocketChannel,selector,key);
                    }
                    if(key.isReadable()){
                        read(key);
                    }
                    // 移除当前的key
                    keyIterator.remove();
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void read(SelectionKey key) {
        try {
            SocketChannel socketChannel = (SocketChannel) key.channel();
            //清除缓冲区，准备接受新数据
            ByteBuffer readBuffer = ByteBuffer.allocate(1024);//调整缓冲区大小为1024字节
            int numRead = socketChannel.read(readBuffer);;
            String str = new String(readBuffer.array(),0,numRead);
            System.out.println("read String is: " + str);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    private static void accept(ServerSocketChannel serverSocketChannel, Selector selector, SelectionKey key) {
        try {
            SocketChannel socketChannel = serverSocketChannel.accept();
            socketChannel.configureBlocking(false);
            // 注册客户端读取事件到selector
            socketChannel.register(selector, SelectionKey.OP_READ);
            System.out.println("client connected " + socketChannel.getRemoteAddress());
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}

那这个时候IO多路复用算是明白了 ~~

那此时有提出一个疑问：那么IO多路复用跟我们常说的Select、Poll、Epollo又有什么关系？

Select%E3%80%81Poll%E3%80%81Epollo">（4）Select、Poll、Epollo

Select、Poll、Epollo的概念我这里就不一一叙说

总结起来他们就是操作系统函数，不同的操作系统(window、linux)有不同的实现，而且这项技术是不断演化，从早期的Select、演化到Poll、再到Epollo。上面讲到IO多路复用能够使用一个线程监听连接、读写事件，它们在操作系统底层是如何实现的呢？（任何的Java逻辑都是会回归操作系统，例如Java的创建线程，底层也是调用操作系统函数进行线程的创建）其实我们可以追到Select方法的源码，最终会调用本地方法，这里答案也就揭晓了，这三个操作系统函数，是操作系统帮我实现能够使用一个线程监听多个事件的功能，它们是实现IO多路复用的在操作系统层面的基石。

protected int doSelect(long var1) throws IOException {
        if (this.channelArray == null) {
            throw new ClosedSelectorException();
        } else {
            this.timeout = var1;
            this.processDeregisterQueue();
            if (this.interruptTriggered) {
                this.resetWakeupSocket();
                return 0;
            } else {
                this.adjustThreadsCount();
                this.finishLock.reset();
                this.startLock.startThreads();

                try {
                    this.begin();

                    try {
                        this.subSelector.poll();
                    } catch (IOException var7) {
                        this.finishLock.setException(var7);
                    }

                    if (this.threads.size() > 0) {
                        this.finishLock.waitForHelperThreads();
                    }
                } finally {
                    this.end();
                }

                this.finishLock.checkForException();
                this.processDeregisterQueue();
                int var3 = this.updateSelectedKeys();
                this.resetWakeupSocket();
                return var3;
            }
        }
    }

三、他们之间的关系总结

最后我画一张图来总结它们的关系

NIO本身这项技术本身是一个大的基石，我们利用了这个基石实现了IO多路复用，而Select、Poll、Epollo这些操作系统函数，是我们操作系统层面的基石，借助这种机制能够帮我们实现事件监听，实现单个线程处理多个事件。从而实现IO多路复用机制，这样就解决了BIO连接数的限制，能够支持处理更多的连接。