Java NIO：Buffer、Channel 和 Selector
本文将介绍 Java NIO 中三大组件 Buffer、Channel、Selector 的使用。java
原本要一块儿介绍非阻塞 IO 和 JDK7 的异步 IO 的，不过由于以前的文章真的太长了，有点影响读者阅读，因此这里将它们放到另外一篇文章中进行介绍。数组
Buffer
一个 Buffer 本质上是内存中的一块，咱们能够将数据写入这块内存，以后从这块内存获取数据。网络
java.nio 定义了如下几个 Buffer 的实现，这个图读者应该也在很多地方见过了吧。app
其实核心是最后的 ByteBuffer，前面的一大串类只是包装了一下它而已，咱们使用最多的一般也是 ByteBuffer。dom
咱们应该将 Buffer 理解为一个数组，IntBuffer、CharBuffer、DoubleBuffer 等分别对应 int[]、char[]、double[] 等。异步
MappedByteBuffer 用于实现内存映射文件，也不是本文关注的重点。socket
我以为操做 Buffer 和操做数组、类集差很少，只不过大部分时候咱们都把它放到了 NIO 的场景里面来使用而已。下面介绍 Buffer 中的几个重要属性和几个重要方法。ide
position、limit、capacity
就像数组有数组容量，每次访问元素要指定下标，Buffer 中也有几个重要属性：position、limit、capacity。oop
最好理解的固然是 capacity，它表明这个缓冲区的容量，一旦设定就不能够更改。好比 capacity 为 1024 的 IntBuffer，表明其一次能够存放 1024 个 int 类型的值。一旦 Buffer 的容量达到 capacity，须要清空 Buffer，才能从新写入值。this
position 和 limit 是变化的，咱们分别看下读和写操做下，它们是如何变化的。
position 的初始值是 0，每往 Buffer 中写入一个值，position 就自动加 1，表明下一次的写入位置。读操做的时候也是相似的，每读一个值，position 就自动加 1。
从写操做模式到读操做模式切换的时候（flip），position 都会归零，这样就能够从头开始读写了。
Limit：写操做模式下，limit 表明的是最大能写入的数据，这个时候 limit 等于 capacity。写结束后，切换到读模式，此时的 limit 等于 Buffer 中实际的数据大小，由于 Buffer 不必定被写满了。
初始化 Buffer
每一个 Buffer 实现类都提供了一个静态方法 allocate(int capacity) 帮助咱们快速实例化一个 Buffer。如：
ByteBuffer byteBuf = ByteBuffer.allocate(1024); IntBuffer intBuf = IntBuffer.allocate(1024); LongBuffer longBuf = LongBuffer.allocate(1024);// ...
另外，咱们常用 wrap 方法来初始化一个 Buffer。
public static ByteBuffer wrap(byte[] array) {
...
}
填充 Buffer
各个 Buffer 类都提供了一些 put 方法用于将数据填充到 Buffer 中，如 ByteBuffer 中的几个 put 方法：
// 填充一个 byte 值public abstract ByteBuffer put(byte b);// 在指定位置填充一个 int 值public abstract ByteBuffer put(int index, byte b);// 将一个数组中的值填充进去public final ByteBuffer put(byte[] src) {...}public ByteBuffer put(byte[] src, int offset, int length) {...}
上述这些方法须要本身控制 Buffer 大小，不能超过 capacity，超过会抛 java.nio.BufferOverflowException 异常。
对于 Buffer 来讲，另外一个常见的操做中就是，咱们要未来自 Channel 的数据填充到 Buffer 中，在系统层面上，这个操做咱们称为读操做，由于数据是从外部（文件或网络等）读到内存中。
int num = channel.read(buf);
上述方法会返回从 Channel 中读入到 Buffer 的数据大小。
提取 Buffer 中的值
前面介绍了写操做，每写入一个值，position 的值都须要加 1，因此 position 最后会指向最后一次写入的位置的后面一个，若是 Buffer 写满了，那么 position 等于 capacity（position 从 0 开始）。
若是要读 Buffer 中的值，须要切换模式，从写入模式切换到读出模式。注意，一般在说 NIO 的读操做的时候，咱们说的是从 Channel 中读数据到 Buffer 中，对应的是对 Buffer 的写入操做，初学者须要理清楚这个。
调用 Buffer 的 flip() 方法，能够从写入模式切换到读取模式。其实这个方法也就是设置了一下 position 和 limit 值罢了。
public final Buffer flip() {
limit = position; // 将 limit 设置为实际写入的数据数量
position = 0; // 重置 position 为 0
mark = -1; // mark 以后再说
return this;
}
对应写入操做的一系列 put 方法，读操做提供了一系列的 get 方法：
// 根据 position 来获取数据public abstract byte get();// 获取指定位置的数据public abstract byte get(int index);// 将 Buffer 中的数据写入到数组中public ByteBuffer get(byte[] dst)
附一个常用的方法：
new String(buffer.array()).trim();
固然了，除了将数据从 Buffer 取出来使用，更常见的操做是将咱们写入的数据传输到 Channel 中，如经过 FileChannel 将数据写入到文件中，经过 SocketChannel 将数据写入网络发送到远程机器等。对应的，这种操做，咱们称之为写操做。
int num = channel.write(buf);
mark() & reset()
除了 position、limit、capacity 这三个基本的属性外，还有一个经常使用的属性就是 mark。
mark 用于临时保存 position 的值，每次调用 mark() 方法都会将 mark 设值为当前的 position，便于后续须要的时候使用。
public final Buffer mark() {
mark = position; return this;
}
那到底何时用呢？考虑如下场景，咱们在 position 为 5 的时候，先 mark() 一下，而后继续往下读，读到第 10 的时候，我想从新回到 position 为 5 的地方从新来一遍，那只要调一下 reset() 方法，position 就回到 5 了。
public final Buffer reset() { int m = mark; if (m < 0) throw new InvalidMarkException();
position = m; return this;
}
rewind() & clear() & compact()
rewind()：会重置 position 为 0，一般用于从新从头读写 Buffer。
public final Buffer rewind() {
position = 0;
mark = -1; return this;
}
clear()：有点重置 Buffer 的意思，至关于从新实例化了同样。
一般，咱们会先填充 Buffer，而后从 Buffer 读取数据，以后咱们再从新往里填充新的数据，咱们通常在从新填充以前先调用 clear()。
public final Buffer clear() {
position = 0;
limit = capacity;
mark = -1; return this;
}
compact()：和 clear() 同样的是，它们都是在准备往 Buffer 填充新的数据以前调用。
前面说的 clear() 方法会重置几个属性，可是咱们要看到，clear() 方法并不会将 Buffer 中的数据清空，只不事后续的写入会覆盖掉原来的数据，也就至关于清空了数据了。
而 compact() 方法有点不同，调用这个方法之后，会先处理尚未读取的数据，也就是 position 到 limit 之间的数据（尚未读过的数据），先将这些数据移到左边，而后在这个基础上再开始写入。很明显，此时 limit 仍是等于 capacity，position 指向原来数据的右边。
Channel
全部的 NIO 操做始于通道，通道是数据来源或数据写入的目的地，主要地，咱们将关心 java.nio 包中实现的如下几个 Channel：
FileChannel：文件通道，用于文件的读和写
DatagramChannel：用于 UDP 链接的接收和发送
SocketChannel：把它理解为 TCP 链接通道，简单理解就是 TCP 客户端
ServerSocketChannel：TCP 对应的服务端，用于监听某个端口进来的请求
这里不是很理解这些也不要紧，后面介绍了代码以后就清晰了。还有，咱们最应该关注，也是后面将会重点介绍的是 SocketChannel 和 ServerSocketChannel。
Channel 常常翻译为通道，相似 IO 中的流，用于读取和写入。它与前面介绍的 Buffer 打交道，读操做的时候将 Channel 中的数据填充到 Buffer 中，而写操做时将 Buffer 中的数据写入到 Channel 中。
至少读者应该记住一点，这两个方法都是 channel 实例的方法。
FileChannel
我想文件操做对于你们来讲应该是最熟悉的，不过咱们在说 NIO 的时候，其实 FileChannel 并非关注的重点。并且后面咱们说非阻塞的时候会看到，FileChannel 是不支持非阻塞的。
这里算是简单介绍下经常使用的操做吧，感兴趣的读者瞄一眼就是了。
初始化：
FileInputStream inputStream = new FileInputStream(new File("/data.txt"));
FileChannel fileChannel = inputStream.getChannel();
固然了，咱们也能够从 RandomAccessFile#getChannel 来获得 FileChannel。
读取文件内容：
ByteBuffer buffer = ByteBuffer.allocate(1024);int num = fileChannel.read(buffer);
前面咱们也说了，全部的 Channel 都是和 Buffer 打交道的。
写入文件内容：
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put("随机写入一些内容到 Buffer 中".getBytes());// Buffer 切换为读模式buffer.flip();while(buffer.hasRemaining()) { // 将 Buffer 中的内容写入文件
fileChannel.write(buffer);
}
SocketChannel
咱们前面说了，咱们能够将 SocketChannel 理解成一个 TCP 客户端。虽然这么理解有点狭隘，由于咱们在介绍 ServerSocketChannel 的时候会看到另外一种使用方式。
打开一个 TCP 链接：
SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("https://www.javadoop.com", 80));
固然了，上面的这行代码等价于下面的两行：
// 打开一个通道SocketChannel socketChannel = SocketChannel.open();// 发起链接socketChannel.connect(new InetSocketAddress("https://www.javadoop.com", 80));
SocketChannel 的读写和 FileChannel 没什么区别，就是操做缓冲区。
// 读取数据socketChannel.read(buffer);// 写入数据到网络链接中while(buffer.hasRemaining()) {
socketChannel.write(buffer);
}
不要在这里停留过久，先继续往下走。
ServerSocketChannel
以前说 SocketChannel 是 TCP 客户端，这里说的 ServerSocketChannel 就是对应的服务端。
ServerSocketChannel 用于监听机器端口，管理从这个端口进来的 TCP 链接。
// 实例化ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();// 监听 8080 端口serverSocketChannel.socket().bind(new InetSocketAddress(8080));while (true) { // 一旦有一个 TCP 链接进来，就对应建立一个 SocketChannel 进行处理
SocketChannel socketChannel = serverSocketChannel.accept();
}
这里咱们能够看到 SocketChannel 的第二个实例化方式
到这里，咱们应该能理解 SocketChannel 了，它不只仅是 TCP 客户端，它表明的是一个网络通道，可读可写。
ServerSocketChannel 不和 Buffer 打交道了，由于它并不实际处理数据，它一旦接收到请求后，实例化 SocketChannel，以后在这个链接通道上的数据传递它就无论了，由于它须要继续监听端口，等待下一个链接。焦做国医胃肠医院正规吗：http://jz.lieju.com/zhuankeyiyuan/37325238.htm
DatagramChannel
UDP 和 TCP 不同，DatagramChannel 一个类处理了服务端和客户端。
科普一下，UDP 是面向无链接的，不须要和对方握手，不须要通知对方，就能够直接将数据包投出去，至于能不能送达，它是不知道的
监听端口：
DatagramChannel channel = DatagramChannel.open(); channel.socket().bind(new InetSocketAddress(9090));
ByteBuffer buf = ByteBuffer.allocate(48); channel.receive(buf);
发送数据：
String newData = "New String to write to file..."
+ System.currentTimeMillis();
ByteBuffer buf = ByteBuffer.allocate(48);
buf.put(newData.getBytes());
buf.flip();
int bytesSent = channel.send(buf, new InetSocketAddress("jenkov.com", 80));
Selector
NIO 三大组件就剩 Selector 了，Selector 创建在非阻塞的基础之上，你们常常听到的 多路复用 在 Java 世界中指的就是它，用于实现一个线程管理多个 Channel。
读者在这一节不能消化 Selector 也不要紧，由于后续在介绍非阻塞 IO 的时候还得说到这个，这里先介绍一些基本的接口操做。
首先，咱们开启一个 Selector。大家爱翻译成选择器也好，多路复用器也好。
Selector selector = Selector.open();
将 Channel 注册到 Selector 上。前面咱们说了，Selector 创建在非阻塞模式之上，因此注册到 Selector 的 Channel 必需要支持非阻塞模式，FileChannel 不支持非阻塞，咱们这里讨论最多见的 SocketChannel 和 ServerSocketChannel。https://www.jianshu.com/p/5e19f3a9f6dd
// 将通道设置为非阻塞模式，由于默认都是阻塞模式的channel.configureBlocking(false);// 注册SelectionKey key = channel.register(selector, SelectionKey.OP_READ);
register 方法的第二个 int 型参数（使用二进制的标记位）用于代表须要监听哪些感兴趣的事件，共如下四种事件：
咱们能够同时监听一个 Channel 中的发生的多个事件，好比咱们要监听 ACCEPT 和 READ 事件，那么指定参数为二进制的 00010001 即十进制数值 17 便可。
注册方法返回值是 SelectionKey 实例，它包含了 Channel 和 Selector 信息，也包括了一个叫作 Interest Set 的信息，即咱们设置的咱们感兴趣的正在监听的事件集合。
SelectionKey.OP_READ
对应 00000001，通道中有数据能够进行读取
SelectionKey.OP_WRITE
对应 00000100，能够往通道中写入数据
SelectionKey.OP_CONNECT
对应 00001000，成功创建 TCP 链接
SelectionKey.OP_ACCEPT
对应 00010000，接受 TCP 链接
调用 select() 方法获取通道信息。用于判断是否有咱们感兴趣的事件已经发生了。
Selector 的操做就是以上 3 步，这里来一个简单的示例，你们看一下就行了。以后在介绍非阻塞 IO 的时候，会演示一份可执行的示例代码。
Selector selector = Selector.open();
channel.configureBlocking(false);
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);while(true) { // 判断是否有事件准备好
int readyChannels = selector.select(); if(readyChannels == 0) continue; // 遍历
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = selectedKeys.iterator(); while(keyIterator.hasNext()) {
SelectionKey key = keyIterator.next(); if(key.isAcceptable()) { // a connection was accepted by a ServerSocketChannel.
} else if (key.isConnectable()) { // a connection was established with a remote server.
} else if (key.isReadable()) { // a channel is ready for reading
} else if (key.isWritable()) { // a channel is ready for writing
}
keyIterator.remove();
}
}
对于 Selector，咱们还须要很是熟悉如下几个方法：
select()
调用此方法，会将上次 select 以后的准备好的 channel 对应的 SelectionKey 复制到 selected set 中。若是没有任何通道准备好，这个方法会阻塞，直到至少有一个通道准备好。
selectNow()
功能和 select 同样，区别在于若是没有准备好的通道，那么此方法会当即返回 0。
select(long timeout)
看了前面两个，这个应该很好理解了，若是没有通道准备好，此方法会等待一会
wakeup()
这个方法是用来唤醒等待在 select() 和 select(timeout) 上的线程的。若是 wakeup() 先被调用，此时没有线程在 select 上阻塞，那么以后的一个 select() 或 select(timeout) 会当即返回，而不会阻塞，固然，它只会做用一次。
- 1. Java NIO：Buffer、Channel 和 Selector
- 2. Java NIO:Buffer、Channel 和 Selector详解
- 3. Java NIO - Channel与Selector
- 4. 全面讲解Java NIO（Channel、Buffer和Selector）
- 5. NIO系列 Channel、Buffer和Selector
- 6. NIO之Channel、Selector
- 7. NIO中SelectionKey和Channel、Selector的关系
- 8. NIO详细介绍（Selector，Channel）
- 9. Java NIO Selector
- 10. java NIO selector
- 更多相关文章...
- • RSS
元素 - RSS 教程 - • XML Schema selector 元素 - XML Schema 教程
- • Java 8 Stream 教程
- • IntelliJ IDEA 代码格式化配置和快捷键
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Java NIO：Buffer、Channel 和 Selector
- 2. Java NIO:Buffer、Channel 和 Selector详解
- 3. Java NIO - Channel与Selector
- 4. 全面讲解Java NIO（Channel、Buffer和Selector）
- 5. NIO系列 Channel、Buffer和Selector
- 6. NIO之Channel、Selector
- 7. NIO中SelectionKey和Channel、Selector的关系
- 8. NIO详细介绍（Selector，Channel）
- 9. Java NIO Selector
- 10. java NIO selector