彻底搞懂 BIO、NIO、AIO 模型

1.BIO 同步阻塞模型

IO 模型

IO模型就是说用什么样的通道进行数据的发送和接收，Java共支持3种网络编程IO模式：BIO，NIO，AIO

1.1.BIO(Blocking IO)同步阻塞模型

一个客户端连接对应一个处理线程;

BIO代码示例：

//服务端
public class SocketServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9000);
        while (true) {
            System.out.println("等待连接。。");
            //阻塞方法(如果没有客户端请求过来,会一直阻塞在这)
            Socket clientSocket = serverSocket.accept();
            System.out.println("有客户端连接了。。");
            //每一个客户端的请求都用一个线程去处理(存在资源浪费的问题)
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        handler(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

    private static void handler(Socket clientSocket) throws IOException {
        byte[] bytes = new byte[1024];
        System.out.println("准备read。。");
        //接收客户端的数据，阻塞方法，没有数据可读时就阻塞
        int read = clientSocket.getInputStream().read(bytes);
        System.out.println("read完毕。。");
        if (read != -1) {
            System.out.println("接收到客户端的数据：" + new String(bytes, 0, read));
        }
        //clientSocket.getOutputStream().write("HelloClient".getBytes());
        //clientSocket.getOutputStream().flush();
    }
}

//客户端
public class SocketClient {

    public static void main(String[] args) throws Exception {
        Socket socket = new Socket("127.0.0.1", 9000);
        //向服务端发送数据
        socket.getOutputStream().write("HelloServer".getBytes());
        socket.getOutputStream().flush();
        System.out.println("向服务端发送数据结束");
        byte[] bytes = new byte[1024];
        //接收服务端回传的数据
        socket.getInputStream().read(bytes);
        System.out.println("接收到服务端的数据：" + new String(bytes));
        socket.close();
    }
}

缺点：

1、IO代码里read操作是阻塞操作，如果连接不做数据读写操作会导致线程阻塞，浪费资源，比如服务端在接收客户端的数据时，没有数据可读时会阻塞，那么在这种情况下如果一个客户端跟服务端建立起了连接，但是客户端如果长时间不给服务端发送数据的话，那么这个连接的线程资源会一直占用着，这是很浪费资源；

2、在服务端如果不开多线程去处理客户端的请求，那么所有客户端的请求会全部串行化，后一个请求都需要等前一个请求的连接断开，才能去跟服务端建立连接。如果开多线程去处理客户端的请求，会导致服务器线程太多，压力太大， 比如C10K问题(并发情况下,有1000个连接,就需要分配1000个线程去处理,这就是C10K问题) ,连接太多,会导致服务端撑爆掉; 我们如果会线程池去控制线程数量的话可以解决线程过多的问题,但是同时也会限制了并发量, 比如我们控制线程池最大线程数量为500,那么也就限制了同一时间处理的客户端请求数量最大也是500,这样的话就限制了连接的并发数;

所以像高并发的场景BIO是没办法搞定的，

应用场景：

BIO 方式适用于连接数目比较小且固定的架构， 这种方式对服务器资源要求比较高， 但程序简单易理解。

JDK在1.4版本就对BIO做了优化，开始引入NIO，用于解决BIO的问题；

2.NIO 同步非阻塞

同步非阻塞，服务器实现模式为一个线程可以处理多个请求(连接)，客户端发送的连接请求都会注册到多路复用器selector上，多路复用器轮询到连接有IO请求就进行处理，JDK1.4开始引入。

应用场景：

NIO方式适用于连接数目多且连接比较短（轻操作） 的架构， 比如聊天服务器， 弹幕系统， 服务器间通讯，编程比较复杂

NIO非阻塞代码最初版本示例:

  // 保存客户端连接
    static List<SocketChannel> channelList = new ArrayList<>();

    public static void main(String[] args) throws IOException {

        // 创建NIO ServerSocketChannel,与BIO的serverSocket类似
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(9000));
        // 设置ServerSocketChannel为非阻塞
        serverSocket.configureBlocking(false);
        System.out.println("服务启动成功");

        while (true) {
            // 非阻塞模式accept方法不会阻塞，否则会阻塞
            // NIO的非阻塞是由操作系统内部实现的，底层调用了linux内核的accept函数
            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 sc = iterator.next();
                ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                // 非阻塞模式read方法不会阻塞，否则会阻塞
                int len = sc.read(byteBuffer);
                // 如果有数据，把数据打印出来
                if (len > 0) {
                    System.out.println("接收到消息：" + new String(byteBuffer.array()));
                } else if (len == -1) { // 如果客户端断开，把socket从集合中去掉
                    iterator.remove();
                    System.out.println("客户端断开连接");
                }
            }
        }
    }

启动以上NIO程序可以发现，当设置设置ServerSocketChannel为非阻塞的时候，accept()方法不会阻塞，如果有客户端连接请求则直接获取到socketChannel对象，如果没有客户端连接请求则获取到的socketChannel为空, 但是肯定不会像BIO那样出现阻塞的现象；

用cmd开启一个9000端口的客户端，并测试

cmd窗口下执行：telnet localhost 9000

用命令去开启一个客户端连接后，可以发现在服务端这里已经可以拿到连接了；

继续往下执行，当我们设置SocketChannel为非阻塞的时候，read方法则不会阻塞，我们测试从客户端发送数据，可以看到在服务端是可以接收的到的；

ctrl+] 回到telnet命令界面

命令 send [内容]

回到服务端，可以发现接收到了我们发送的信息

我们可以测试多个客户端一起去开启跟服务端的连接，可以发现服务端是支持跟多个客户端同时连接的，不会存在阻塞的问题，也就是NIO一个线程就可以处理多个客户端的连接，这里就解决了BIO里的阻塞问题；

像Redis单线程可以处理高并发，其实底层原理大概就是这么去实现的；

以上是一个最基本的NIO程序，但这还是有问题，目前这个程序是一直循环的去执行的，假如现在有十万个连接一起建立，但是其中只有100个连接是有数据的，那么我们为了拿这100个连接的数据每次都要去遍历这十万个连接，那这是很浪费资源的，优化：IO多路复用器==>Selector

NIO非阻塞代码加入IO多路复用器Selector版本示例:

public class NioSelectorServer {

    public static void main(String[] args) throws IOException {

        // 同样是创建NIO ServerSocketChannel
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(9000));
        // 设置ServerSocketChannel为非阻塞
        serverSocket.configureBlocking(false);
        // 打开Selector处理Channel，即创建epoll
        Selector selector = Selector.open();
        // 把ServerSocketChannel注册到selector上，并且selector对客户端accept连接操作
        SelectionKey selectionKey = 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();
                // 如果是OP_ACCEPT事件，则进行连接获取和事件注册
                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel socketChannel = server.accept();
                    socketChannel.configureBlocking(false);
                    // 这里只注册了读事件，如果需要给客户端发送数据可以注册写事件
                    SelectionKey selKey = socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("客户端连接成功");
                } else if (key.isReadable()) {  // 如果是OP_READ事件，则进行读取和打印
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocateDirect(128);
                    int len = socketChannel.read(byteBuffer);
                    // 如果有数据，把数据打印出来
                    if (len > 0) {
                        System.out.println("接收到消息：" + byteBuffer.get(0));
                    } else if (len == -1) { // 如果客户端断开连接，关闭Socket
                        System.out.println("客户端断开连接");
                        socketChannel.close();
                    }
                }
                //从事件集合里删除本次处理的key，防止下次select重复处理
                iterator.remove();
            }
        }
    }
}

以上的代码也就是在执行下图的步骤：

每个在selector注册的客户端和服务端都会有一个key, selector多路复用器里会有一个集合，里面存着所有客户端和服务端的key,调用key.channel()方法获取到对应的客户端或服务端；获取到后就可以对其进行读写数据的操作；

selector.select()：阻塞等待需要处理的事件发生，如果是OP_ACCEPT事件，则进行连接获取和事件注册，如果是OP_READ事件，则进行读取和打印；

selector.select()只会监听新的请求连接的事件和已经建立连接了并且有收发数据的事件，而已经建立了连接但是没有收发数据的连接他是不会去监听的，这就解决了上面提到十万个连接要全部遍历所产生的资源浪费问题，如果这时候有十万个连接并且只有100个连接有收发数据，那么selector只会处理这100个，在selector里是会有一个集合去存放这100个有收发数据的连接；

那么selector多路复用器具体底层是怎么实现的呢？

我们需要深入Hotspot源码和深入Linux内核理解Epoll事件轮询模型;

NioSelectorServer 代码里如下几个方法非常重要:

1 Selector.open() //创建多路复用器 

2 socketChannel.register() //将channel注册到多路复用器上 

3 selector.select() //阻塞等待需要处理的事件发

1.NIO的Selector.open()创建一个IO多路复用器,其底层最终是去调了Linux内核函数epoll_create()来创建Selector对象,在这个对象里还会有一个EPollArrayWrapper的集合,用去存放socketChannel对象,

2.而NIO的socketChannel.register(selector, SelectionKey.OP_READ)方法调用EPollArrayWrapper集合的add(fd)函数, fd就是socketChannel或者ServerSocketChannel

3.1. Selector.select()方法阻塞等待的实现是调用了linux内核函数epoll_wait, 而select()去监听对应的事件是通过内核函数epoll_ctl实现的, 如果Socketchannel或SeverSocketchannel有连接事件或读写事件, 就会调用epoll_ctl去监听这些事件(下图的函数epollCtl());

3.2. 以下前面三个方法是最主要的, Selector.select() 方法调用的native(c语言实现)的epoll_wait()方法

linux对epoll_wait函数的解释是,这个函数他会阻塞并等待事件发生,如果没有事件发生他就会一直阻塞, 如果有事件发生,他就会跳出阻塞,去处理事件(比如连接事件,读写事件); Selector对象里面实际上是有两个集合的,一个是channel的集合(EPollArrayWrapper), 一个是就绪事件的集合rdlist, 当执行epoll_wait()的时候, 这个函数会去查询rdlist集合里有没有就绪的连接事件或连接完成后的读写收发数据的事件, 如果有则会去处理相应事件, 如果没有则一直阻塞着;

那rdlist集合的事件又是哪里来的? 他其实是channel的集合(EPollArrayWrapper)给到rdlist集合的, 通过操作系统底层去实现的, 当客户端给服务端发起建立连接或发送数据的请求时,服务端的操作系统里的网口是可以感知得的到的, 这时候会由操作系统的中断程序去获取连接事件或连接的读写收发数据的事件, 然后放到rdlist集合中;

linux的这些内核函数在linux里用man命令都可以查的到详细的解释;

看到最后,我们可以发现, NIO里最核心的东西就是Selector对象, 由他去做了一系列的操作;

NIO在早期JDK1.4版本的时候,他是通过linux内核函数select去实现的, select函数会对会有的channel连接都去遍历一次(假如有十万个客户端连接,则遍历十万次), 查看所有channel有没有数据收发, 而不是通过事件响应实现的, 所以在JDK1.4的时候就存在性能问题的,

poll跟select唯一的区别就是poll的最大连接没有上限,select是有上限的(1024个), 超了1024那么就不遍历了;

JDK1.5之后才用epoll，epoll是基于事件响应式模型实现的;

3.AIO(NIO 2.0) 异步非阻塞(了解)

异步非阻塞， 由操作系统完成后回调通知服务端程序启动线程去处理， 一般适用于连接数较多且连接时间较长的应用，JDK7开始支持；

BIO、 NIO、 AIO 对比：

4.为什么Netty使用NIO而不是AIO？

在Linux系统上，AIO的底层实现仍使用Epoll，没有很好实现AIO，因此在性能上没有明显的优势，而且被JDK封装了一层不容易深度优化，Linux上AIO还不够成熟。Netty是异步非阻塞框架，Netty在NIO上做了很多异步的封装。

5.Redis线程模型

Redis高并发线程模型就是通过epoll的事件应响去实现的,跟我们上面讲的一样; linux内核中的epoll_create、epoll_ctl、epoll_wait函数；

Redis就是典型的基于epoll的NIO线程模型(nginx也是)，epoll实例收集所有事件(连接与读写事件)，由一个服务端线程连续处理所有事件命令。

当我们发一条set命令的时候，服务端的epoll_wait就会跳出阻塞去处理set命令这个事件；

Redis底层关于epoll的源码实现在redis的src源码目录的ae_epoll.c文件里，感兴趣可以自行研究。