Java NIO 编程 - 技术栈

1. 简介

Java NIO 是 JDK 1.4 中引入的新的 IO 方式，它主要包含 Buffer、Channel、Selector 这三个核心的组件，它与传统 IO 的区别如下：

|-----------|--------|
| NIO | IO |
| 面向缓冲 | 面向流 |
| 同步非阻塞 | 同步阻塞 |
| 多路复用（选择器） | 无 |

1.1 面向缓冲

传统的 IO 是面向流的，传统 IO 每次从流中读取一个或者多个字节，直至读取完所有的字节。而 NIO 是面向缓冲区的，所有的读写操作都需要通过 Buffer 来完成，数据会被先写入 Buffer 中，然后再进行处理，Buffer 提供了多种方法用于操纵其中的数据，因此其在操作上更加灵活，读取速度也更加快。

1.2 同步非阻塞

传统 IO 的流都是单向的，因此它们需要分为 Input Stream 和 Output Stream。而 NIO 中的 Channel 则是双向的，数据可以从 Channel 读到 Buffer 中，也可以从 Buffer 写到 Channel：

注意：从 Channel 写入到 Buffer 执行的是 read 方法，而从 Buffer 写出到 Channel 执行的是 write 方法。

Channel 可以设置为非阻塞模式，此时当 Channel 从 Buffer 中读取数据时，如果有待读取的数据则返回该数据；如果没有待读取的数据，对应的方法也不会阻塞，而是直接返回。

1.3 多路复用

Java NIO 通过 Reactor 模型实现了 IO 的多路复用，可以在一个线程上通过一个选择（Selector）使用轮询的方式去监听多个通道 Channel 上注册的事件，从而在一个线程上就能实现对多个 Channel 的处理：

2. Buffer

2.1 缓冲区属性

所有缓冲区（ByteBuffer、FloatBuffer、IntBuffer、DoubleBuffer、ShortBuffer、LongBuffer、CharBuffer、MappedByteBuffer）都直接或间接继承自 Buffer 抽象类，Buffer 中定义了缓冲区的四个基本属性：

复制代码

public abstract class Buffer {`
 
`    private int capacity;`
`    private int limit;`
`    private int position = 0;`
`    private int mark = -1;`
`    ...`
`}`
`

容量 (Capacity) 缓冲区所能容纳元素的个数。

上界 (Limit)：缓冲区中现存元素的个数。

位置 (Position)：下一个待操作元素的索引。

标记 (Mark)：标记位置。通过 `mark()` 方法可以让 mark 等于当前 position；之后通过 `reset()` 方法可以让 position 恢复到标记位置。

2.2 创建缓冲区

通常可以通过以下两种方法来创建缓冲区：

allocate()：通过指定缓冲区的容量大小来创建：

复制代码

CharBuffer buffer = CharBuffer.allocate(100);

wrap()：通过为缓冲区指定初始化数组来创建：

复制代码

char[] chars = new char[100];`
`CharBuffer buffer = CharBuffer.wrap(chars);

实际上，在缓冲区内部就是通过数组来存储元素，以 CharBuffer 为例，它的内部维持有一个名为 `hb` 的数组，用来存放实际的元素：

复制代码

public abstract class CharBuffer extends Buffer implements Comparable<CharBuffer>, Appendable, CharSequence, Readable`
`{`
`    final char[] hb;`  
`    ...`
`}

缓冲区创建完成后，它处于以下初始状态：

2.3 操作缓冲区

2.3.1 put()

用于向缓冲区中填充数据。以 CharBuffer 为例，有以下四个常用的重载方法：

复制代码

// 使用字符串填充数据`
`put(String src)`
`// 使用字符串填充数据，start为字符串的开始位置，end为字符串的结束位置（不包含）`
`put(String src, int start, int end)`
`// 使用数组填充数据`
`put(char[] src)`
`// 使用数组填充数据，offset为数组填充的开始位置，length为填充的长度,不允许越界  `
`put(char[] src, int offset, int length)

当我们向 Buffer 中添加数据后，position 属性也会随之变动：

2.3.2 get()

用于读取缓冲区中的数据。以 CharBuffer 为例，有以下四个常用的重载方法：

复制代码

// 获取当前位置（postion）的数据`
`char get();`
`// 获取指定位置的数据`
`char get(int index);`
`// 获取数据并填充到数组中`
`CharBuffer get(char[] dst)`
`// 获取数据并填充到数据中，offset为数组填充的开始位置，length为填充的长度,不允许越界  `
`CharBuffer get(char[] dst, int offset, int length)` `

2.3.3 flip()

该方法会将 position 的值赋给 limit，然后将 position 设置为 0，从而可以由写模式切换到读模式。无论任何情况，只要由写操作转换到读操作，都需要先执行该方法。示例如下：

复制代码

CharBuffer buffer = CharBuffer.allocate(100);`
`buffer.put("hello");`
`buffer.flip();` `//由写模式切换到读模式`
`while` `(buffer.hasRemaining()) {`
`    System.out.println(buffer.get());`
`}`
`buffer.clear();

当使用 `filp()` 将 Buffer 由写模式切换到读模式后：position 属性会恢复到初始位置，代表从此处开始读取数据；limit 属性也会随之变动，代表我们所能读取数据的上界：

当我们再通过 `get()` 方法进行读取时，position 属性会随之移动，position 和 limit 之间就是待处理的数据：

2.3.4 hasRemaining()

`hasRemaining()` 用于判断当前的 position 是否小于 limit：如果 position 小于 limit，则返回 true，代表仍有待处理的数据。

2.3.5 clear()

`clear()` 并不会真的清除缓冲区中的数据，它只是将 position 设置为 0，并将 limit 设置为 capacity 的大小，从而让缓冲区恢复到初始状态：

当有新的数据写入时，新的数据会覆盖原有位置上的数据。

2.3.6 compact()

用于压缩缓冲区，即将数组中待处理的数据复制到头部。如下所示，会将未读取的 `LL0` 复制到头部：

需要注意的是这里执行的是复制操作，而不是移动操作，底层调用的是 `System.arraycopy` 方法，因此原有位置上的数据依然存在。但由于 position 会移动到未处理数据的下一个位置上，所以不用担心原有位置上的数据会被读取到，原因是你切换到读模式时，原有的 `LO` 数据仍处于 limit 之后：

2.3.7 mark()

用于设置标志位，设置好后可以使用 `reset()` 将 position 恢复到该位置：

复制代码

buffer.position(2).mark().position(5).reset().position();` `//从位置2移动到位置5，之后又恢复到位置2`
`

2.4 复制缓冲区

如果想要对一个已有的缓冲区进行复制，可以有以下三种方法：

复制代码

public abstract CharBuffer duplicate();`
`public abstract CharBuffer asReadOnlyBuffer();`
`public abstract CharBuffer slice();`
`

使用 `duplicate()` 复制的缓冲区具有以下特性：

与原缓冲区共享相同的数据元素，这意味着对原缓冲区数据的修改也会影响复制缓冲区；
复制缓冲区的 mark、position、limit、capcaity 属性的初始值与复制时原缓冲区的 mark、position、limit、capcaity 的值相同，但这些属性与原缓冲区的属性相互独立，创建后就不再受原有缓冲区的影响；
如果原缓冲区是只读缓冲区或直接缓冲区，则复制缓冲区也将继承这些属性。

`asReadOnlyBuffer()` 与 `duplicate()` 类似，但创建的复制缓冲区为只读缓冲区。

`slice()` 也与 `duplicate()` 类似，但创建的复制缓冲区与原缓冲区只共享部分数据元素，并且所有标志位都处于原始状态：

使用示例如下：

复制代码

CharBuffer buffer = CharBuffer.allocate(100);`
`buffer.put("helloworld");`
`buffer.position(2).limit(5);`
`CharBuffer duplicate = buffer.duplicate();`
`buffer.position(3).limit(6);`
`CharBuffer slice = buffer.slice();`

`System.out.println("buffer:"` `+ buffer.position()` `+` `","` `+ buffer.limit());`     `// buffer:3,6`
`System.out.println("duplicate:"` `+ duplicate.position()` `+` `","` `+ duplicate.limit());` `// duplicate:2,5`
`System.out.println("slice:"` `+ slice.position()` `+` `","` `+ slice.limit());`        `//slice:0,3`
`

2.5 直接缓冲区

ByteBuffer 支持使用 `allocateDirect()` 方法来创建直接缓冲区，示例如下：

复制代码

ByteBuffer byteBuffer = ByteBuffer.allocate(100);`
`

3. Channel

3.1 通道基础

Channel 接口的定义如下，其中定义了两个基础方法：

isOpen()：判断当前 Channel 是否处于打开状态；

close()：关闭当前 Channel 。Channel 关闭后，就不能在其上再进行任何 IO 操作，否则将抛出 ClosedChannelException 异常。

复制代码

public` `interface Channel extends Closeable {`

    `public boolean isOpen();`

    `public void close() throws IOException;`
`}

对于常见的文件操作和网络操作都可以直接获取到其对应的 Channel：

复制代码

// 获取serverSocketChannel`
`ServerSocket serverSocket = new ServerSocket(8888);`
`ServerSocketChannel serverSocketChannel = serverSocket.getChannel();`

`// 获取SocketChannel`
`Socket socket = new Socket("127.0.0.1",` `8888);`
`SocketChannel socketChannel = socket.getChannel();`

`// 获取FileChannel`
`FileInputStream fileInputStream = new FileInputStream(new File("path"));`
`FileChannel fileChannel = fileInputStream.getChannel();`
`

3.2 文件通道

FileChannel 是一个连接到文件的通道，通过该通道可以完成文件的读写。另外 FileChannel 无法设置为非阻塞模式，因为对文件读写操作设置非阻塞并没有什么意义。FileChannel 的使用示例如下：

复制代码

// 示例：文件拷贝`
`try {`
`    FileInputStream inputStream = new FileInputStream(new File("D:\\a.png"));`
`    FileOutputStream outputStream = new FileOutputStream(new File("D:\\b.png"));`
`    FileChannel inChannel = inputStream.getChannel();`
`    FileChannel outChannel = outputStream.getChannel();`
`    ByteBuffer buffer = ByteBuffer.allocate(256);`
    `// 从输入channel中读取数据到buffer中`
    `while` `(inChannel.read(buffer)` `>` `0) {`
        `// 由写模式切换到读模式`
`        buffer.flip();`
        `while` `(buffer.hasRemaining()) {`
            `//将buffer中的数据写出到输出channel`
`            outChannel.write(buffer);`
`        }`
`        buffer.clear();`
`    }`
`    inputStream.close();`
`    outputStream.close();`
`} catch (IOException e) {`
`    e.printStackTrace();`
`}

这里的最后我们只需要关闭 Stream 即可，其上的 Channel 也会被关闭，源码如下：

复制代码

public void close() throws IOException {`
`    synchronized (closeLock) {`
        `if` `(closed) {`
            `return;`
`        }`
`        closed = true;`
`    }`
    `// 如果channel不为空，则关闭`
    `if` `(channel != null) {`
`       channel.close();`
`    }`

`    fd.closeAll(new Closeable() {`
        `public void close() throws IOException {`
`           close0();`
`       }`
`    });`
`}

3.3 Channel To Channel

在 Java NIO 中，如果两个 Channel 中有一个是 FileChannel，那么可以直接将数据从一个 Channel 传输到另外一个 Channel：

复制代码

// 将该通道上的数据直接传送到目标通道`
`transferTo(long position, long count, WritableByteChannel target)` `;`
`// 将原通道上的数据直接传送到该通道`
`transferFrom(ReadableByteChannel src, long position, long count)

还是以文件拷贝为例，使用示例如下：

复制代码

try {`
`    FileInputStream inputStream = new FileInputStream(new File("D:\\a.png"));`
`    FileOutputStream outputStream = new FileOutputStream(new File("D:\\b.png"));`
`    FileChannel inChannel = inputStream.getChannel();`
`    FileChannel outChannel = outputStream.getChannel();`
`    inChannel.transferTo(0,inChannel.size(),outChannel);`        `//使用transferTo实现`
    `// outChannel.transferFrom(inChannel,` `0, inChannel.size());` `//使用transferFrom实现`
`    inputStream.close();`
`    outputStream.close();`
`} catch (IOException e) {`
`    e.printStackTrace();`
`}

3.4 Scatter/Gather

Java NIO 支持 scatter 和 gather 操作：

分散 (scatter)：把 Channel 中的数据依次写入到多个 Buffer 上。示例如下：

复制代码

ByteBuffer buffer01 = ByteBuffer.allocate(32);`
`ByteBuffer buffer02 = ByteBuffer.allocate(64);`
`ByteBuffer buffer03 = ByteBuffer.allocate(128);`

`ByteBuffer[] buffers = new ByteBuffer[]{buffer01, buffer02, buffer03};`
`fileInputStream.getChannel().read(buffers);

此时 Channel 中的数据会依次写入到 Buffer01， Buffer02， Buffer03 上。Scatter 通常用于固定长度数据的处理，假设一个数据单元由 header，body，footer 三部分组成，并且每部分的长度都是固定的，此时通过 Scatter 操作，每一组数据的 header，body，footer 都会分别固定地写到 Buffer01， Buffer02， Buffer03 上，此时就可以对每个 Buffer 应用不同的处理逻辑：

聚集 (gather)：将多个 Buffer 中的数据依次写入到同一个 Channel 上。示例如下：

复制代码

ByteBuffer buffer01 = ByteBuffer.allocate(32);`
`ByteBuffer buffer02 = ByteBuffer.allocate(64);`
`ByteBuffer buffer03 = ByteBuffer.allocate(128);`

`ByteBuffer[] buffers = new ByteBuffer[]{buffer01, buffer02, buffer03};`
`fileInputStream.getChannel().read(buffers);`
`

3.5 Pipe

Java NIO 还提供了 Pipe 管道用于在不同线程之间传递数据：

Pipe 管道可以通过 Pipe 类的静态方法 `open()` 来创建：

复制代码

Pipe pipe = Pipe.open();

创建完成后可以通过其 `sink()` 和 `source()` 方法来创建对应的 SinkChannel 和 SourceChannel：

复制代码

Pipe.SinkChannel sinkChannel = pipe.sink();`
`Pipe.SourceChannel sourceChannel = pipe.source();

SinkChannel 和 SourceChannel 的使用与基本的 Channel 类似，示例如下：

复制代码

Pipe pipe = Pipe.open();`
`new Thread(()` `-> {`
`    try {`
`        Pipe.SinkChannel sink = pipe.sink();`
`        ByteBuffer buffer = ByteBuffer.allocate(1024);`
`        buffer.put("HelloWorld".getBytes());`
`        buffer.flip();`
        `while` `(buffer.hasRemaining()) {`
            `// 将数据写入SinkChannel`
`            sink.write(buffer);`
`        }`
`        sink.close();`
`    } catch (IOException e) {`
`        e.printStackTrace();`
`    }`
`}).start();`
`new Thread(()` `-> {`
`    try {`
`        Pipe.SourceChannel source = pipe.source();`
`        ByteBuffer buffer = ByteBuffer.allocate(1024);`
        `// 读取SourceChannel中的数据`
        `while` `(source.read(buffer)` `>` `0) {`
`            buffer.flip();`
            `while` `(buffer.hasRemaining()) {`
`                System.out.print((char) buffer.get());` `//输出：HelloWorld`
`            }`
`            buffer.clear();`
`        }`
`        source.close();`
`    } catch (IOException e) {`
`        e.printStackTrace();`
`    }`
`}).start();`
`

4.Selector

4.1 创建选择器

想要创建一个选择器，可以通过 Selector 类的静态方法 `open()` 来实现：

复制代码

Selector selector = Selector.open();

4.2 注册通道

之后须要通过 `register()` 方法将 Channel 注册到 Selector 上，示例如下：

复制代码

// 创建ServerSocketChannel`
`ServerSocketChannel serverChannel = ServerSocketChannel.open();`
`// 与 Selector一起使用的Channel必须处于非阻塞模式下`
`serverChannel.configureBlocking(false);`
`serverChannel.bind(new InetSocketAddress(hostname, port));`

`// 注册监听CONNECT事件`
`serverChannel.register(selector, SelectionKey.OP_ACCEPT);`
`

`register()` 方法的第二个参数表示需要监听的事件，它有以下四个可选值：

复制代码

//读取事件`
`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;

如果你需要监听多个事件，可以使用位操作符进行连接：

复制代码

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

除此之外，你还可以在注册时通过调用 register 的另外一个重载方法来指定附加信息：

复制代码

register(Selector sel, int ops, Object att)

这个附加信息可以在事件触发时通过 SelectionKey 对象再次得到。

4.3 select

当你在 Selector 上注册好通道后，就可以使用 `select()` 方法来获取处于就绪状态的事件的集合。示例如下：

复制代码

int select` `= selector.select();

select 有以下三个重载方法：

select()：持续阻塞，直到至少有一个通道在其注册的事件上处于就绪状态；

select(long timeout)：与 `select()` 类似，但最长只阻塞 timout 毫秒；

selectNow()：不会阻塞，如果不存在就绪事件，则直接返回 0。

需要注意的是如果是 Ready 操作集发生了变化，select 操作的返回值也可能是 0。这意味着如果某个通道注册的是 `OP_READ` 事件，那么该通道在第一次收到消息时，select 操作返回的值是 1；但是之后收到消息时，select 的返回值却可能是 0。因此在循环获取消息时，对于 select 返回值的判断应该加上为 0 的情况：

复制代码

// 如果选择器上存在就绪事件，则进行处理`
`while` `(selector.select()` `>=` `0) {`
`  ....`
`}`
`

4.4 SelectionKey

当注册的事件处于就绪状态时，可以通过 Selector 的 `selectedKeys()` 方法来获取处于就绪状态的事件信息：

复制代码

Set<SelectionKey> selectionKeys = selector.selectedKeys();

其返回的是 SelectionKey 的集合，SelectionKey 是对多个属性的综合封装：

复制代码

public abstract class SelectionKey {`

    `// SelectionKey对应的channel`
    `public abstract SelectableChannel channel();`

    `// SelectionKey对应的选择器`
    `public abstract Selector selector();`
 
    `// 当前SelectionKey是否有效`
    `public abstract boolean isValid();`
   
    `// 取消channel在selector上注册的事件`
    `public abstract void cancel();`

    `// 当前channel注册的事件的合集`
    `public abstract int interestOps();`

    `// 当前channel是否对指定的事件感兴趣`
    `public abstract SelectionKey interestOps(int ops);`

    `// 处于就绪状态的事件的合集`
    `public abstract int readyOps();`

    `//` `Read事件是否就绪`
    `public final boolean isReadable() {return` `(readyOps()` `& OP_READ)` `!= 0;}`

    `//` `Write事件是否就绪`
    `public final boolean isWritable() {return` `(readyOps()` `& OP_WRITE)` `!= 0;}`
    
    `// Connect事件是否就绪`
    `public final boolean isConnectable() {return` `(readyOps()` `& OP_CONNECT)` `!= 0;}`
    
    `// Accept事件是否就绪`
    `public final boolean isAcceptable() {return` `(readyOps()` `& OP_ACCEPT)` `!= 0;}`

    `// 为SelectionKey指定附加属性，也可以在注册时通过register方法指定`
    `public final Object attach(Object ob) {return attachmentUpdater.getAndSet(this, ob);}`

    `// 获取附加属性`
    `public final Object attachment() { return attachment;}`

`}`
`