netty（六）NIO、BIO与AIO 一、BIO与NIO 二、IO模型 三、零拷贝 四、AIO

一、BIO与NIO

本小节将BIO与NIO放到一起进行分析，主要为了突出其差别。

1.1 对比stream和channel

以前我们写代码，涉及到IO操作，首先想到的必然是一系列的stream，如InputStream等。如今随着java中nio的引入，我们多了一个选择，channel。那么两者相比有哪些不同，channel又有哪些优势呢？

1）stream 不会自动缓冲数据，channel 会利用系统提供的发送缓冲区、接收缓冲区（更为底层）。
2）stream 仅支持阻塞 API，channel 同时支持阻塞、非阻塞 API，网络 channel 可配合 selector 实现多路复用。
3）二者均为全双工，即读写可以同时进行。

二、IO模型

当调用一次 channel.read 或 stream.read 后，会切换至操作系统内核态来完成真正数据读取，而读取又分为两个阶段，分别为：

1）等待数据准备好

2）从内核向用户进程复制数据

阻塞IO模型

非阻塞IO模型

应用进程不停的轮询内核空间，会造成CPU浪费。

多路IO复用模型

用户进程首先阻塞于select方法，当内核返回可读状态后，根据事件类型去做调用，将数据复制到用户空间缓冲区，处理区间状态阻塞。

异步IO模型

AIO是java中IO模型的一种，作为NIO的改进和增强随JDK1.7版本更新被集成在JDK的nio包中，因此AIO也被称作是NIO2.0。AIO提供了从建立连接到读、写的全异步操作。AIO可用于异步的文件读写和网络通信。

三、零拷贝

3.1 原始IO分析

如下伪代码，读取本地文件，通过socket写出：

File f = new File("helloword/data.txt");
RandomAccessFile file = new RandomAccessFile(file, "r");

byte[] buf = new byte[(int)f.length()];
// 包括2次拷贝（DMA（硬件到内核缓冲区），内核缓冲到用户缓冲）
file.read(buf);

Socket socket = ...;
//包括两次拷贝（用户缓冲区到socket缓冲区，DMA（socket缓冲区到网卡））
socket.getOutputStream().write(buf);

其内部实际的工作构成如下所示：

我们根据代码的过程，结合图上的步骤逐步分析：
1）创建文件类file，定义byte数组，当真正开始执行read方法时，才开始获取数据。

java 本身并不具备 IO 读写能力，因此 read 方法调用后，要从 java 程序的用户态切换至内核态，去调用操作系统（内核）的读能力，将数据读入内核缓冲区。这期间用户线程阻塞，操作系统使用 DMA（Direct Memory Access，可以理解为硬件单元，解放CPU的同时，完成文件IO）来实现文件读，其间也不会使用 cpu。

此处可以算作第一次数据拷贝，但是通过DMA技术解决了IO问题。

2） 从内核态切换回用户态，将数据从内核缓冲区读入用户缓冲区（即 byte[] buf），这期间 cpu 会参与拷贝，无法利用 DMA。

此处是第二次数据拷贝。

3）调用 write 方法，这时将数据从用户缓冲区（byte[] buf）写入 socket 缓冲区，cpu 会参与拷贝。

此处是第三次拷贝。

4）接下来要向网卡写数据，这项能力 java 又不具备，因此又得从用户态切换至内核态，调用操作系统的写能力，使用 DMA 将 socket 缓冲区的数据写入网卡，不会使用 cpu。

此处算作第四次拷贝，DMA技术解决IO问题。

总结：
通过上面的分析，我们得到java本身不具备物理设备级别的IO读写，而是缓存级别的读写，通过调用操作系统来完成硬件级别的读写。

上述步骤总共经历3次状态切换，4次的数据拷贝。

3.2 NIO优化

3.2.1 使用直接内存

在前面我们学习ByteBuffer时，介绍到了其可以使用直接内存DirectByteBuffer。

ByteBuffer buffer = ByteBuffer.allocateDirect(16);

那么通过这个直接内存，能使我们前面的过程做到哪些优化呢？

如上图所示，由于直接内存的引入，java 可以使用 DirectByteBuf 将堆外内存（内核缓冲区）映射到 jvm 内存（用户缓冲区）中来直接访问使用。而其他的步骤没有变化。

• 这块内存不受 jvm 垃圾回收的影响，因此内存地址固定，有助于 IO 读写。

• java 中的 DirectByteBuf 对象仅维护了此内存的虚引用，内存回收分成以下两步：
  1）DirectByteBuf 对象被垃圾回收，将虚引用加入引用队列
  2）通过专门线程访问引用队列，根据虚引用释放堆外内存

• 减少了一次数据拷贝，用户态与内核态的切换次数没有减少

3.2.1 channel的transferTo/transferFrom

底层采用了 linux 2.1：
进一步优化（底层采用了 linux 2.1 后提供的 sendFile 方法），java 中对应着两个 channel 调用transferTo/transferFrom 方法拷贝数据。

其过程如下图所示：

1）java 调用 transferTo 方法后，要从 java 程序的用户态切换至内核态，使用 DMA将数据读入内核缓冲区，不会使用 cpu
2）数据从内核缓冲区传输到 socket 缓冲区，cpu 会参与拷贝
3）最后使用 DMA 将 socket 缓冲区的数据写入网卡，不会使用 cpu

如上图和过程所示，其中只经历了一次状态切换，数据拷贝仍然是3次。

底层采用了 linux 2.4：
linux底层对于整体的效率又有了优化，如下图所示：

1）java 调用 transferTo 方法后，要从 java 程序的用户态切换至内核态，使用 DMA将数据读入内核缓冲区，不会使用 cpu
2）只会将一些 offset 和 length 信息拷入 socket 缓冲区，几乎无消耗
3）使用 DMA 将 内核缓冲区的数据写入网卡，不会使用 cpu

整个过程只发生了一次状态切换，实际只通过DMA经过两次数据拷贝。

实际所谓的零拷贝并不是真正的没有拷贝过程，而是不会有数据拷贝到用户态，即jvm内存中的过程。

四、AIO

4.1 简单介绍及使用

AIO 用来解决数据复制阶段的阻塞问题

• 同步意味着，在进行读写操作时，线程需要等待结果，还是相当于闲置
• 异步意味着，在进行读写操作时，线程不必等待结果，而是将来由操作系统来通过回调方式由另外的线程来获得结果

异步模型需要底层操作系统（Kernel）提供支持

• Windows 系统通过 IOCP 实现了真正的异步 IO
• Linux 系统异步 IO 在 2.6 版本引入，但其底层实现还是用多路复用模拟了异步 IO，性能没有优势

示例代码：

public class TestAio {

    public static void main(String[] args) throws IOException {
        try {
            AsynchronousFileChannel s = AsynchronousFileChannel.open(
                            Paths.get("C:\\Users\\P50\\Desktop\\text.txt"), StandardOpenOption.READ);
            ByteBuffer buffer = ByteBuffer.allocate(10);
            System.out.println("begin...");
            s.read(buffer, 0, null, new CompletionHandler<Integer, ByteBuffer>() {
                @Override
                public void completed(Integer result, ByteBuffer attachment) {
                    System.out.println("read completed..." + result);
                    buffer.flip();
                    System.out.println(Thread.currentThread().getName() + "，内容是：" + print(buffer));
                }

                @Override
                public void failed(Throwable exc, ByteBuffer attachment) {
                    System.out.println("ead failed...");
                }
            });

        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("do other things...");
        System.in.read();
    }

    static String print(ByteBuffer b) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < b.limit(); i++) {
            stringBuilder.append((char) b.get(i));
        }
        return stringBuilder.toString();
    }
}

结果，打印内容的并不是主线程，多次尝试，每次都是不同的，并且主线程并没有阻塞：

begin...
do other things...
read completed...10
Thread-7，内容是：helloworld

默认文件 AIO 使用的线程都是守护线程，所以最后要执行 System.in.read() 以避免守护线程意外结束。

4.2 网络编程

服务端示例代码：

public class AioServer {

    public static void main(String[] args) throws IOException {
        AsynchronousServerSocketChannel ssc = AsynchronousServerSocketChannel.open();
        ssc.bind(new InetSocketAddress(8080));
        ssc.accept(null, new AcceptHandler(ssc));
        System.in.read();
    }

    private static void closeChannel(AsynchronousSocketChannel sc) {
        try {
            System.out.printf("[%s] %s close\n", Thread.currentThread().getName(), sc.getRemoteAddress());
            sc.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static class ReadHandler implements CompletionHandler<Integer, ByteBuffer> {
        private final AsynchronousSocketChannel sc;

        public ReadHandler(AsynchronousSocketChannel sc) {
            this.sc = sc;
        }

        @Override
        public void completed(Integer result, ByteBuffer attachment) {
            try {
                if (result == -1) {
                    closeChannel(sc);
                    return;
                }
                System.out.printf("[%s] %s read\n", Thread.currentThread().getName(), sc.getRemoteAddress());
                attachment.flip();
                System.out.println(Charset.defaultCharset().decode(attachment));
                attachment.clear();
                // 处理完第一个 read 时，需要再次调用 read 方法来处理下一个 read 事件
                sc.read(attachment, attachment, this);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void failed(Throwable exc, ByteBuffer attachment) {
            closeChannel(sc);
            exc.printStackTrace();
        }
    }

    private static class WriteHandler implements CompletionHandler<Integer, ByteBuffer> {
        private final AsynchronousSocketChannel sc;

        private WriteHandler(AsynchronousSocketChannel sc) {
            this.sc = sc;
        }

        @Override
        public void completed(Integer result, ByteBuffer attachment) {
            // 如果作为附件的 buffer 还有内容，需要再次 write 写出剩余内容
            if (attachment.hasRemaining()) {
                sc.write(attachment);
            }
        }

        @Override
        public void failed(Throwable exc, ByteBuffer attachment) {
            exc.printStackTrace();
            closeChannel(sc);
        }
    }

    private static class AcceptHandler implements CompletionHandler<AsynchronousSocketChannel, Object> {
        private final AsynchronousServerSocketChannel ssc;

        public AcceptHandler(AsynchronousServerSocketChannel ssc) {
            this.ssc = ssc;
        }

        @Override
        public void completed(AsynchronousSocketChannel sc, Object attachment) {
            try {
                System.out.printf("[%s] %s connected\n", Thread.currentThread().getName(), sc.getRemoteAddress());
            } catch (IOException e) {
                e.printStackTrace();
            }
            ByteBuffer buffer = ByteBuffer.allocate(16);
            // 读事件由 ReadHandler 处理
            sc.read(buffer, buffer, new ReadHandler(sc));
            // 写事件由 WriteHandler 处理
            sc.write(Charset.defaultCharset().encode("server hello!"), ByteBuffer.allocate(16), new WriteHandler(sc));
            // 处理完第一个 accpet 时，需要再次调用 accept 方法来处理下一个 accept 事件
            ssc.accept(null, this);
        }

        @Override
        public void failed(Throwable exc, Object attachment) {
            exc.printStackTrace();
        }
    }
}