1.4. Java NIO API 简单回顾
BIO 以流的方式处理数据，而 NIO 以缓冲区（也被叫做块）的方式处理数据，块 IO 效率比流 IO 效率高很多。BIO 基于字符流或者字节流进行操作，而 NIO 基于 Channel 和 Buffer 进行操作，数据总是从通道读取到缓冲区或者从缓冲区写入到通道。Selector 用于监听多个通道上的事件（比如收到连接请求、数据达到等等），因此使用单个线程就可以监听多个客户端通道。如下图所示：
关于上图，再进行几点说明：
- 一个 Selector 对应一个处理线程
- 一个 Selector 上可以注册多个 Channel
- 每个 Channel 都会对应一个 Buffer（有时候一个 Channel 可以使用多个 Buffer，这时候程序要进行多个 Buffer 的分散和聚集操作），Buffer 的本质是一个内存块，底层是一个数组
- Selector 会根据不同的事件在各个 Channel 上切换
- Buffer 是双向的，既可以读也可以写，切换读写方向要调用 Buffer 的 flip()方法
- 同样，Channel 也是双向的，数据既可以流入也可以流出
1.4.1. 缓冲区（Buffer）
缓冲区（Buffer）本质上是一个可读可写的内存块，可以理解成一个容器对象，Channel 读写文件或者网络都要经由 Buffer。在 Java NIO 中，Buffer 是一个顶层抽象类，它的常用子类有（前缀表示该 Buffer 可以存储哪种类型的数据）：
- ByteBuffer
- CharBuffer
- ShortBuffer
- IntBuffer
- LongBuffer
- DoubleBuffer
- FloatBuffer
涵盖了 Java 中除 boolean 之外的所有的基本数据类型。其中 ByteBuffer 支持类型化的数据存取，即可以往 ByteBuffer 中放 byte 类型数据、也可以放 char、int、long、double 等类型的数据，但读取的时候要做好类型匹配处理，否则会抛出 BufferUnderflowException。
另外，Buffer 体系中还有一个重要的 MappedByteBuffer（ByteBuffer 的子类），可以让文件内容直接在堆外内存中被修改，而如何同步到文件由 NIO 来完成。本文重点不在于此，有兴趣的可以去探究一下 MappedByteBuffer 的底层原理。
1.4.2. 通道（Channel）
通道（Channel）是双向的，可读可写。在 Java NIO 中，Buffer 是一个顶层接口，它的常用子类有：
- FileChannel：用于文件读写
- DatagramChannel：用于 UDP 数据包收发
- ServerSocketChannel：用于服务端 TCP 数据包收发
- SocketChannel：用于客户端 TCP 数据包收发
1.4.3. 选择器（Selector）
选择器（Selector）是实现 IO 多路复用的关键，多个 Channel 注册到某个 Selector 上，当 Channel 上有事件发生时，Selector 就会取得事件然后调用线程去处理事件。也就是说只有当连接上真正有读写等事件发生时，线程才会去进行读写等操作，这就不必为每个连接都创建一个线程，一个线程可以应对多个连接。这就是 IO 多路复用的要义。
Netty 的 IO 线程 NioEventLoop 聚合了 Selector，可以同时并发处理成百上千的客户端连接，后文会展开描述。
在 Java NIO 中，Selector 是一个抽象类，它的常用方法有：
public abstract class Selector implements Closeable { ...... /** * 得到一个选择器对象 */ public static Selector open() throws IOException { return SelectorProvider.provider().openSelector(); } ...... /** * 返回所有发生事件的 Channel 对应的 SelectionKey 的集合，通过 * SelectionKey 可以找到对应的 Channel */ public abstract Set<SelectionKey> selectedKeys(); ...... /** * 返回所有 Channel 对应的 SelectionKey 的集合，通过 SelectionKey * 可以找到对应的 Channel */ public abstract Set<SelectionKey> keys(); ...... /** * 监控所有注册的 Channel，当其中的 Channel 有 IO 操作可以进行时， * 将这些 Channel 对应的 SelectionKey 找到。参数用于设置超时时间 */ public abstract int select(long timeout) throws IOException; /** * 无超时时间的 select 过程，一直等待，直到发现有 Channel 可以进行 * IO 操作 */ public abstract int select() throws IOException; /** * 立即返回的 select 过程 */ public abstract int selectNow() throws IOException; ...... /** * 唤醒 Selector，对无超时时间的 select 过程起作用，终止其等待 */ public abstract Selector wakeup(); ...... }
在上文的使用 Java NIO 编写的服务端示例代码中，服务端的工作流程为：
1）当客户端发起连接时，会通过 ServerSocketChannel 创建对应的 SocketChannel。
2）调用 SocketChannel 的注册方法将 SocketChannel 注册到 Selector 上，注册方法返回一个 SelectionKey，该 SelectionKey 会被放入 Selector 内部的 SelectionKey 集合中。该 SelectionKey 和 Selector 关联（即通过 SelectionKey 可以找到对应的 Selector），也和 SocketChannel 关联（即通过 SelectionKey 可以找到对应的 SocketChannel）。
4）Selector 会调用 select()/select(timeout)/selectNow()方法对内部的 SelectionKey 集合关联的 SocketChannel 集合进行监听，找到有事件发生的 SocketChannel 对应的 SelectionKey。
5）通过 SelectionKey 找到有事件发生的 SocketChannel，完成数据处理。
以上过程的相关源码为：
/** * SocketChannel 继承 AbstractSelectableChannel */ public abstract class SocketChannel extends AbstractSelectableChannel implements ByteChannel, ScatteringByteChannel, GatheringByteChannel, NetworkChannel { ...... } public abstract class AbstractSelectableChannel extends SelectableChannel { ...... /** * AbstractSelectableChannel 中包含注册方法，SocketChannel 实例 * 借助该注册方法注册到 Selector 实例上去，该方法返回 SelectionKey */ public final SelectionKey register( // 指明注册到哪个 Selector 实例 Selector sel, // ops 是事件代码，告诉 Selector 应该关注该通道的什么事件 int ops, // 附加信息 attachment Object att) throws ClosedChannelException { ...... } ...... } public abstract class SelectionKey { ...... /** * 获取该 SelectionKey 对应的 Channel */ public abstract SelectableChannel channel(); /** * 获取该 SelectionKey 对应的 Selector */ public abstract Selector selector(); ...... /** * 事件代码，上面的 ops 参数取这里的值 */ public static final int OP_READ = 1 << 0; public static final int OP_WRITE = 1 << 2; public static final int OP_CONNECT = 1 << 3; public static final int OP_ACCEPT = 1 << 4; ...... /** * 检查该 SelectionKey 对应的 Channel 是否可读 */ public final boolean isReadable() { return (readyOps() & OP_READ) != 0; } /** * 检查该 SelectionKey 对应的 Channel 是否可写 */ public final boolean isWritable() { return (readyOps() & OP_WRITE) != 0; } /** * 检查该 SelectionKey 对应的 Channel 是否已经建立起 socket 连接 */ public final boolean isConnectable() { return (readyOps() & OP_CONNECT) != 0; } /** * 检查该 SelectionKey 对应的 Channel 是否准备好接受一个新的 socket 连接 */ public final boolean isAcceptable() { return (readyOps() & OP_ACCEPT) != 0; } /** * 添加附件（例如 Buffer） */ public final Object attach(Object ob) { return attachmentUpdater.getAndSet(this, ob); } /** * 获取附件 */ public final Object attachment() { return attachment; } ...... }
下图用于辅助读者理解上面的过程和源码：
首先说明，本文以 Linux 系统为对象来研究文件 IO 模型和网络 IO 模型。
1.5. 零拷贝技术
注：本节讨论的是 Linux 系统下的 IO 过程。并且对于零拷贝技术的讲解采用了一种浅显易懂但能触及其本质的方式，因为这个话题，展开来讲实在是有太多的细节要关注。
在“将本地磁盘中文件发送到网络中”这一场景中，零拷贝技术是提升 IO 效率的一个利器，为了对比出零拷贝技术的优越性，下面依次给出使用直接 IO 技术、内存映射文件技术、零拷贝技术实现将本地磁盘文件发送到网络中的过程。
1）直接 IO 技术
使用直接 IO 技术实现文件传输的过程如下图所示。
上图中，内核缓冲区是 Linux 系统的 Page Cahe。为了加快磁盘的 IO，Linux 系统会把磁盘上的数据以 Page 为单位缓存在操作系统的内存里，这里的 Page 是 Linux 系统定义的一个逻辑概念，一个 Page 一般为 4K。
可以看出，整个过程有四次数据拷贝，读进来两次，写回去又两次：磁盘-->内核缓冲区-->Socket 缓冲区-->网络。
直接 IO 过程使用的 Linux 系统 API 为：
ssize_t read(int filedes, void *buf, size_t nbytes); ssize_t write(int filedes, void *buf, size_t nbytes);
等函数。
2）内存映射文件技术
使用内存映射文件技术实现文件传输的过程如下图所示。
可以看出，整个过程有三次数据拷贝，不再经过应用程序内存，直接在内核空间中从内核缓冲区拷贝到 Socket 缓冲区。
内存映射文件过程使用的 Linux 系统 API 为：
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
3）零拷贝技术
使用零拷贝技术，连内核缓冲区到 Socket 缓冲区的拷贝也省略了，如下图所示：
内核缓冲区到 Socket 缓冲区之间并没有做数据的拷贝，只是一个地址的映射。底层的网卡驱动程序要读取数据并发送到网络上的时候，看似读取的是 Socket 的缓冲区中的数据，其实直接读的是内核缓冲区中的数据。
零拷贝中所谓的“零”指的是内存中数据拷贝的次数为 0。
零拷贝过程使用的 Linux 系统 API 为：
ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);
在 JDK 中，提供的：
FileChannel.transderTo(long position, long count, WritableByteChannel target);
方法实现了零拷贝过程，其中的第三个参数可以传入 SocketChannel 实例。例如客户端使用以上的零拷贝接口向服务器传输文件的代码为：
public static void main(String[] args) throws IOException { SocketChannel socketChannel = SocketChannel.open(); socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080)); String fileName = "test.zip"; // 得到一个文件 channel FileChannel fileChannel = new FileInputStream(fileName).getChannel(); // 使用零拷贝 IO 技术发送 long transferSize = fileChannel.transferTo(0, fileChannel.size(), socketChannel); System.out.println("file transfer done, size: " + transferSize); fileChannel.close(); }
以上部分为第一章，学习 Netty 需要的基础知识。
