Java架构直通车——BIO、NIO、AIO

同/异、阻/非堵塞

虽然我在之前的文章中提到过同步异步、阻塞与非阻塞，但是我认为当时的解释不是很到位，对此，我再次补充解释。

同步就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠的任务序列。要么成功都成功，失败都失败，两个任务的状态可以保持一致。

异步是不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了整个任务就算完成了。至于被依赖的任务最终是否真正完成，依赖它的任务无法确定，所以它是不可靠的任务序列。

我们可以用打电话和发短信来很好的比喻同步与异步操作。

阻塞与非阻塞主要是从 CPU 的消耗上来说的。

阻塞就是 CPU 停下来等待一个慢的操作完成 CPU 才接着完成其它的事。

非阻塞就是在这个慢的操作在执行时 CPU 去干其它别的事，等这个慢的操作完成时，CPU 再接着完成后续的操作。
虽然表面上看非阻塞的方式可以明显的提高 CPU 的利用率，但是也带了另外一种后果就是系统的线程切换增加。增加的 CPU 使用时间能不能补偿系统的切换成本需要好好评估。

同/异、阻/非堵塞 组合

同/异、阻/非堵塞的组合，有四种类型，如下表：

组合方式	性能分析
同步阻塞	最常用的一种用法，使用也是最简单的，但是 I/O 性能一般很差，CPU 大部分在空闲状态。
同步非阻塞	提升 I/O 性能的常用手段，就是将 I/O 的阻塞改成非阻塞方式，尤其在网络 I/O 是长连接，同时传输数据也不是很多的情况下，提升性能非常有效。 这种方式通常能提升 I/O 性能，但是会增加CPU 消耗，要考虑增加的 I/O 性能能不能补偿 CPU 的消耗，也就是系统的瓶颈是在 I/O 还是在 CPU 上。
异步阻塞	这种方式在分布式数据库中经常用到，例如在网一个分布式数据库中写一条记录，通常会有一份是同步阻塞的记录，而还有两至三份是备份记录会写到其它机器上，这些备份记录通常都是采用异步阻塞的方式写 I/O。异步阻塞对网络 I/O 能够提升效率，尤其像上面这种同时写多份相同数据的情况。
异步非阻塞	这种组合方式用起来比较复杂，只有在一些非常复杂的分布式情况下使用，像集群之间的消息同步机制一般用这种 I/O 组合方式。如 Cassandra 的 Gossip 通信机制就是采用异步非阻塞的方式。它适合同时要传多份相同的数据到集群中不同的机器，同时数据的传输量虽然不大，但是却非常频繁。这种网络 I/O 用这个方式性能能达到最高。

IO的理解

IO操作的两个阶段：

第一个阶段:　　查看数据是否就绪；

第二个阶段:　　进行数据拷贝（内核将数据拷贝到用户线程）。

同步IO和异步IO是针对用户线程和内核的交互来说的：

同步会不断的去轮询，异步会有回调通知。

• 同步IO：当用户线程发出IO请求操作之后，如果数据没有就绪，需要通过用户线程或者内核不断地去轮询数据是否就绪，当数据就绪时，再将数据从内核拷贝到用户线程。
• 异步IO：只有IO请求操作的发出是由用户线程来进行的，IO操作的两个阶段都是由内核自动完成，然后发送通知告知用户线程IO操作已经完成。

阻塞（blocking IO）和非阻塞（non-blocking IO）的区别就在于第一个阶段，如果数据没有就绪，在查看数据是否就绪的过程中是一直等待，还是直接返回一个标志信息。

阻塞和非阻塞时看用户线程是否一直在做等待。

• 阻塞IO：当用户线程发起一个IO请求操作，内核会去查看要读取的数据是否就绪，如果数据没有就绪，则会一直在那等待，直到数据就绪，当数据就绪之后，便将数据拷贝到用户线程。
• 非阻塞IO：当用户线程发起一个IO请求操作，内核会去查看要读取的数据是否就绪，如果数据没有就绪，如果数据没有就绪，则会返回一个标志信息告知用户线程当前要读的数据没有就绪。

举例：

1 老张把水壶放到火上，立等水开。（同步阻塞）
2 老张把水壶放到火上，去客厅看电视，时不时去厨房看看水开没有。（同步非阻塞）
3 老张把响水壶放到火上，立等水开。（异步阻塞）
4 老张把响水壶放到火上，去客厅看电视，水壶响之前不再去看它了，响了再去拿壶。（异步非阻塞）

BIO/NIO/AIO

BIO

同步阻塞式IO
BIO 通信模型 的服务端，通常由一个独立的 Acceptor 线程负责监听客户端的连接。我们一般通过在 while(true) 循环中服务端会调用 accept() 方法等待接收客户端的连接的方式监听请求，请求一旦接收到一个连接请求，就可以建立通信套接字在这个通信套接字上进行读写操作，此时不能再接收其他客户端连接请求，只能等待同当前连接的客户端的操作执行完成， 不过可以通过多线程或者线程池来支持多个客户端的连接。

线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。

int port = 4343; //端口号
// Socket 服务器端（简单的发送信息）
Thread sThread = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            ServerSocket serverSocket = new ServerSocket(port);
            while (true) {
                // 等待连接
                Socket socket = serverSocket.accept();
                Thread sHandlerThread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try (PrintWriter printWriter = new PrintWriter(socket.getOutputStream())) {
                            printWriter.println("hello world！");
                            printWriter.flush();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                });
                sHandlerThread.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
});
sThread.start();

线程的启动或者销毁是很消耗服务器的资源的，即使使用线程池来实现，使用上述传统的 Socket 方式，当连接数极具上升也会带来性能瓶颈，原因是线程的上线文切换开销会在高并发的时候体现的很明显，并且以上操作方式还是同步阻塞式的编程，性能问题在高并发的时候就会体现的尤为明显。

NIO 多路复用

同步非阻塞式IO
NIO 通常是用Selector来监听多个Channel，Channel以事件的方式注册到Selector上面，这样就可以用一个Selector线程通过IO多路复用的方式（比如epoll()、poll()、select()）来处理多个IO请求，避免了频繁的切换线程带来的问题。
另外，Channel是对原 I/O 包中的流的模拟，到任何目的地(或来自任何地方)的所有数据都必须通过一个 Channel 对象（通道）。Channel和流很多方面都是类似的，最大的不同在于流是单向的而Channel是双向的，NIO以块的方式处理数据，所有数据不回直接的写入Channel或者从Channle取出，而是通过 Buffer 缓冲区来处理，可以认为Buffer是一个缓冲容器，所有需要写入到通道中去或需要从通道中读取的数据都需要放置在buffer中，通过这种缓冲的方式来提高字节的读取效率。
在这整个过程中，仅仅Selector的select()方法是阻塞的，因为需要等待就绪的channel。

// NIO 多路复用
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(4, 4,
        60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
threadPool.execute(new Runnable() {
    @Override
    public void run() {
        try (Selector selector = Selector.open();
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();) {
            serverSocketChannel.bind(new InetSocketAddress(InetAddress.getLocalHost(), port));
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            while (true) {
                selector.select(); // 阻塞等待就绪的Channel
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    try (SocketChannel channel = ((ServerSocketChannel) key.channel()).accept()) {
                        channel.write(Charset.defaultCharset().encode("你好，世界"));
                    }
                    iterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
});

NIO三个核心对象：通道(Channel)、缓冲区(Buffer)和选择器(Selector)

• Buffer
  缓冲区是一个用于特定基本数据类型的容器。有java.nio包定义的，所有缓冲区都是抽象类Buffer的子类。Java NIO中的Buffer 主要用于与NIO通道进行交互，数据是从通道读入到缓冲区，从缓冲区写入通道中的。
  Buffer就像一个数组，可以保存多个相同类型的数据。根据类型不同（boolean除外），有以下Buffer常用子类：ByteBuffer、CharBuffer、ShortBuffer、IntBuffer、LongBuffer、FloatBuffer、DoubleBuffer

• Channel
  通道表示打开到 IO 设备(例如：文件、套接字)的连接。若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。Channel 负责传输， Buffer 负责存储。 通道是由 java.nio.channels 包定义的。 Channel 表示 IO 源与目标打开的连接。Channel 类似于传统的“流”。只不过 Channel本身不能直接访问数据， Channel 只能与Buffer 进行交互。

• Selector
  一个NIO的选择器，可以检测（监视）多个NIO channel，看看读或者写事件是否就绪。
  多个Channel以事件的方式可以注册到同一个Selector，从而达到用一个线程处理多个请求成为可能。

另外，Java的NIO模式的Selector网络通讯，其实就是一个简单的Reactor模型。可以说是Reactor模型的朴素原型。
单线程Reactor：Reactor线程是个多面手，负责多路分离套接字，Accept新连接，并分派请求到Handler处理器中。

多线程的Reactor：在线程Reactor模式基础上，做如下改进。

（1）将Handler处理器的执行放入线程池，多线程进行业务处理。
（2）而对于Reactor而言，可以仍为单个线程。如果服务器为多核的CPU，为充分利用系统资源，可以将Reactor拆分为两个线程。

AIO

异步非阻塞IO
异步 IO 是基于事件和回调机制实现的，客户端I/O请求会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。

AsynchronousSocketChannel asynchronousSocketChannel = getAsynchronousSocketChannel();
asynchronousSocketChannel.read(ByteBuffer.allocate(4), null, new CompletionHandler<Integer, Object>() {
    @Override
    public void completed(Integer result, Object attachment) {
        //读不到数据不会触发该回调来烦你，只有确实读取到数据，且把数据已经存在ByteBuffer中了，API才会通过此回调接口主动通知您
    }
    @Override
    public void failed(Throwable exc, Object attachment) {
    }
});

IO多路复用：select、poll、epoll之间的区别

(1)select==>时间复杂度O(n)

它仅仅知道了，有I/O事件发生了，却并不知道是哪那几个流（可能有一个，多个，甚至全部），我们只能无差别轮询所有流，找出能读出数据，或者写入数据的流，对他们进行操作。所以select具有O(n)的无差别轮询复杂度，同时处理的流越多，无差别轮询时间就越长。

(2)poll==>时间复杂度O(n)

poll本质上和select没有区别，它将用户传入的数组拷贝到内核空间，然后查询每个fd对应的设备状态， 但是它没有最大连接数的限制，原因是它是基于链表来存储的.

(3)epoll==>时间复杂度O(1)

epoll可以理解为event poll，不同于忙轮询和无差别轮询，epoll会把哪个流发生了怎样的I/O事件通知我们。所以我们说epoll实际上是事件驱动（每个事件关联上fd）的，此时我们对这些流的操作都是有意义的。（复杂度降低到了O(1)）

总结：三种IO方式的区别

BIO：Blocking IO 同步阻塞式 IO，数据的读取写入必须阻塞在一个线程内等待其完成。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。它的特点是模式简单使用方便，并发处理能力低。

NIO：Non-blocking IO 同步非阻塞 IO，它支持面向缓冲的，基于通道的I/O操作方法。客户端和服务器端通过 Channel（通道）通讯，实现了多路复用。

AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操作基于事件和回调机制。