IO流（二）Java的NIO
1 NIO介绍
Java NIO 全称java non-blocking IO ，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO(即 New IO)，是同步非阻塞的。
- NIO有三大核心部分：Channel（通道），Buffer（缓冲区），Selector（选择器）
- NIO是面向缓冲区编程的。数据读取到一个缓冲区中，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络。
- Java NIO 的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入， 这个线程同时可以去做别的事情。通俗理解：NIO 是可以做到用一个线程来处理多个操作的。假设有 10000 个请求过来,根据实际情况，可以分配50 或者 100 个线程来处理。不像之前的阻塞 IO 那样，非得分配 10000 个。
1.1 NIO和 BIO的比较
- BIO 以流的方式处理数据,而 NIO 以缓冲区的方式处理数据,缓冲区 I/O 的效率比流 I/O 高很多
- BIO 是阻塞的，NIO则是非阻塞的
- BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel(通道)和 Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道的事件（比如：连接请求， 数据到等），因此使用单个线程就可以监听多个客户端通道。
1.2 NIO三大核心原理示例图
一张图描述 NIO 的 Selector 、 Channel 和 Buffer 的关系
- 每个 channel 都会对应一个 Buffer
- Selector 对应一个线程， 一个线程对应多个 channel(连接)
- 每个 channel 都注册到 Selector选择器上
- Selector不断轮询查看Channel上的事件, 事件是通道Channel非常重要的概念
- Selector 会根据不同的事件，完成不同的处理操作
- Buffer 就是一个内存块 ， 底层是有一个数组
- 数据的读取写入是通过 Buffer, 这个和 BIO , BIO 中要么是输入流，或者是输出流, 不能双向，但是NIO 的 Buffer 是可以读也可以写 , channel 是双向的。
2. NIO Buffer类详解
Buffer类是一个抽象类，对应于Java的主要数据类型，在NIO中有8种缓冲区类，分别如下：ByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer、ShortBuffer、MappedByteBuffer。 前7种Buffer类型，覆盖了能在IO中传输的所有的Java基本数据类型。第8种类型MappedByteBuffer是专门用于内存映射的一种ByteBuffer类型。不同的Buffer子类，其能操作的数据类型能够通过名称进行判断，比如IntBuffer只能操作Integer类型的对象。
2.1 Buffer类的重要属性
Buffer的子类会拥有一块内存，作为数据的读写缓冲区，但是读写缓冲区并没有定义在Buffer基类，而是定义在具体的子类中。如ByteBuf子类就拥有一个byte[]类型的数组成员final byte[] hb，作为自己的读写缓冲区，数组的元素类型与Buffer子类的操作类型相互对应。
为了记录读写的状态和位置，Buffer类额外提供了一些重要的属性，其中有以下三个重要的成员属性：
- capacity（容量）
- position（读写位置）
- limit（读写的限制）
2.1.1 capacity属性
Buffer类的capacity属性，表示内部容量的大小。一旦写入的对象数量超过了capacity容量，缓冲区就满了，不能再写入了。
Buffer类的capacity属性一旦初始化，就不能再改变。原因是什么呢？Buffer类的对象在初始化时，会按照capacity分配内部数组的内存，在数组内存分配好之后，它的大小当然就不能改变了。
Buffer类是一个抽象类，Java不能直接用来新建对象。在具体使用的时候，必须使用Buffer的某个子类，例如DoubleBuffer子类，该子类能写入的数据类型是double类型，如果在创建实例时其capacity是100，那么我们最多可以写入100个double类型的数据。
capacity 容量并不是指内部的内存块 byte[]数组的字节数量，而是指能写入的数据对象的最大限制数量。
2.1.2 position属性
Buffer类的position属性，表示当前的位置。position属性的值与缓冲区的读写模式有关。在不同的模式下，position属性值的含义是不同的，在缓冲区进行读写的模式改变时，position值会进行相应的调整。
在写入模式下，position的值变化规则如下：
（1）在刚进入到写入模式时，position值为0，表示当前的写入位置为从头开始。
（2）每当一个数据写到缓冲区之后，position会向后移动到下一个可写的位置。
（3）初始的position值为0，最大可写值为limit–1。当position值达到limit时，缓冲区就已经无空间可写了。
在读模式下，position的值变化规则如下：
（1）当缓冲区刚开始进入到读取模式时，position会被重置为0。
（2）当从缓冲区读取时，也是从position位置开始读。读取数据后，position向前移动到下一个可读的位置。
（3）在读模式下，limit表示可以读上限。position的最大值，为最大可读上限limit，当position达到limit时，表明缓冲区已经无数据可读。
Buffer的读写模式具体如何切换呢？
当新建了一个缓冲区实例时，缓冲区处于写入模式，这时是可以写数据的。在数据写入完成后，如果要从缓冲区读取数据，这就要进行模式的切换，可以使用（即调用）flip翻转方法，将缓冲区变成读取模式。
在从写入模式到读取模式的flip翻转过程中，position和limit属性值会进行调整，具体的规则是：
（1）limit属性被设置成写入模式时的position值，表示可以读取的最大数据位置；
（2）position由原来的写入位置，变成新的可读位置，也就是0，表示可以从头开始读。
2.1.3 limit属性
Buffer类的limit属性，表示可以写入或者读取的最大上限，其属性值的具体含义，也与缓冲区的读写模式有关，在不同的模式下，limit的值的含义是不同的，具体分为以下两种情况：
（1）在写入模式下，limit属性值的含义为可以写入的数据最大上限。在刚进入到写入模式时，limit的值会被设置成缓冲区的capacity容量值，表示可以一直将缓冲区的容量写满。
（2）在读取模式下，limit的值含义为最多能从缓冲区中读取到多少数据。
一般来说，在进行缓冲区操作时，是先写入然后再读取的。当缓冲区写入完成后，就可以开始从Buffer读取数据，可以使用flip翻转方法，这时，limit的值也会进行调整。具体如何调整呢？将写入模式下的position值，设置成读取模式下的limit值，也就是说，将之前写入的最大数量，作为可以读取的上限值。
除了以上capacity（容量）、position（读写位置）、limit（读写的限制）三个重要属性之外，Buffer还有一个比较重要的标记属性：mark（标记）属性。该属性的大致作用为：在缓冲区操作过程当中，可以将当前的position的值临时存入mark属性中；需要的时候，可以再从mark中取出暂存的标记值，恢复到position属性中，重新从position位置开始处理。
2.1.4 属性小结
| 属性 |
说明 |
| capacity |
容量，即可以容纳的最大数据量；在缓冲区创建时设置并且不能改变 |
| limit |
上限，缓冲区中当前的数据量 |
| position |
位置，缓冲区中下一个要被读或写的元素的索引 |
| mark |
调用 mark()方法来设置 mark=position，再调用 reset()可以让 position 恢复到 mark标记的位置，即 position=mark |
2.2 Buffer的重要方法
2.2.1 allocate()创建缓冲区
| 方法名 |
说明 |
| static ByteBuffer allocate(长度) |
创建byte类型的指定长度的缓冲区 |
| static ByteBuffer wrap(byte[] array) |
创建一个有内容的byte类型缓冲区 |
代码如下：
public class CreateBufferDemo {
public static void main(String[] args) {
//1.创建一个指定长度的缓冲区, 以ByteBuffer为例
ByteBuffer byteBuffer = ByteBuffer.allocate(5);
for (int i = 0; i < 5; i++) {
System.out.println(byteBuffer.get());
}
// 在此调用会报错--后续再读缓冲区时着重讲解
// System.out.println(byteBuffer.get());
// 2.创建一个有内容的缓冲区
ByteBuffer wrap = ByteBuffer.wrap("hello".getBytes(StandardCharsets.UTF_8));
for (int i = 0; i < 5; i++) {
System.out.println(wrap.get());
}
}
}2.2.2 缓冲区对象添加数据
| 方法名 |
说明 |
| int position()/position(intnewPosition) |
获得当前要操作的索引/修改当前要操作的索引位置 |
| int limit()/limit(int newLimit) |
最多能操作到哪个索引/修改最多能操作的索引位置 |
| int capacity() |
返回缓冲区的总长度 |
| int remaining()/booleanhasRemaining() |
还有多少能操作索引个数/是否还有能操作 |
| put(byte b)/put(byte[] src) |
添加一个字节/添加字节数组 |
图解：
image.png
示例代码:
public class PutBufferDemo {
public static void main(String[] args) {
//1.创建一个指定长度的缓冲区, 以ByteBuffer为例
ByteBuffer byteBuffer = ByteBuffer.allocate(10);
System.out.println(byteBuffer.position());//0 获取当前索引所在位置
System.out.println(byteBuffer.limit());//10 最多能操作到哪个索引
System.out.println(byteBuffer.capacity());//10 返回缓冲区总长度
System.out.println(byteBuffer.remaining());//10 还有多少个能操作
// 修改当前索引位置
// byteBuffer.position(1);
// 修改最多能操作到哪个索引位置
// byteBuffer.limit(9);
// System.out.println(byteBuffer.position());// 1 获取当前索引所在位置
// System.out.println(byteBuffer.limit());//9 最多能操作到哪个索引
// System.out.println(byteBuffer.capacity());//10 返回缓冲区总长度
//System.out.println(byteBuffer.remaining());//8 还有多少个能操作
//添加一个字节
byteBuffer.put((byte) 97);
System.out.println(byteBuffer.position());//1 获取当前索引所在位置
System.out.println(byteBuffer.limit());//10 最多能操作到哪个索引
System.out.println(byteBuffer.capacity());//10 返回缓冲区总长度
System.out.println(byteBuffer.remaining());//9 还有多少个能操作
//添加一个字节数组
byteBuffer.put("abc".getBytes());
System.out.println(byteBuffer.position());//4 获取当前索引所在位置
System.out.println(byteBuffer.limit());//10 最多能操作到哪个索引
System.out.println(byteBuffer.capacity());//10 返回缓冲区总长度
System.out.println(byteBuffer.remaining());//6 还有多少个能操作
//当添加超过缓冲区的长度时会报错
byteBuffer.put("012345".getBytes());
System.out.println(byteBuffer.position());//10 获取当前索引所在位置
System.out.println(byteBuffer.limit());//10 最多能操作到哪个索引
System.out.println(byteBuffer.capacity());//10 返回缓冲区总长度
System.out.println(byteBuffer.remaining());//0 还有多少个能操作
System.out.println(byteBuffer.hasRemaining());// false 是否还能有操作的 数组
// 如果缓存区存满后, 可以调整position位置可以重复写,这样会覆盖之前存入索引的对 应的值
byteBuffer.position(0);
byteBuffer.put("012345".getBytes());
}
}
2.2.3 缓冲区对象读取数据
| 方法名 |
说明 |
| flip() |
写切换读模式 limit设置position位置, position设置0 |
| get() |
读一个字节 |
| get(byte[] dst) |
读多个字节 |
| get(int index) |
读指定索引的字节 |
| rewind() |
将position设置为0，可以重复读 |
| clear() |
切换写模式 position设置为0 , limit 设置为 capacity |
| array() |
将缓冲区转换成字节数组返回 |
图解:flip()方法:
图解:clear()方法:
clear()
实例代码：
public class GetBufferDemo {
public static void main(String[] args) {
//1.创建一个指定长度的缓冲区
ByteBuffer allocate = ByteBuffer.allocate(10);
allocate.put("0123".getBytes(StandardCharsets.UTF_8));
System.out.println("position:" + allocate.position());//4
System.out.println("limit:" + allocate.limit());//10
System.out.println("capacity:" + allocate.capacity());//10
System.out.println("remaining:" + allocate.remaining());//6
//切换读模式
System.out.println("读取数据-------------->");
allocate.flip();
System.out.println("position:" + allocate.position());//4
System.out.println("limit:" + allocate.limit());//10
System.out.println("capacity:" + allocate.capacity());//10
System.out.println("remaining:" + allocate.remaining());//6
for (int i = 0; i < allocate.limit(); i++) {
System.out.println(allocate.get());
}
//读取完毕后.继续读取会报错,超过limit值
// System.out.println(allocate.get());
// 读取指定索引字节
System.out.println("读取指定索引字节-------------->");
System.out.println(allocate.get(1));
System.out.println("读取多个字节-------------->");
// 重复读取
allocate.rewind();
byte[] bytes = new byte[4];
allocate.get(bytes);
System.out.println(new String(bytes));
// 将缓冲区转化字节数组返回
System.out.println("将缓冲区转化字节数组返回-------------->");
byte[] array = allocate.array();
System.out.println(new String(array));
// 切换写模式,覆盖之前索引所在位置的值
System.out.println("写模式-------------->");
allocate.clear();
allocate.put("abc".getBytes());
System.out.println(new String(allocate.array()));
}
}注意事项:
capacity：容量（长度）limit： 界限（最多能读/写到哪里）posotion：位置（读/写哪个索引） 获取缓冲区里面数据之前，需要调用flip方法 再次写数据之前，需要调用clear方法，但是数据还未消失，等再次写入数据，被覆盖了才会消失。
3. NIO Channel（通道）类详解
3.1 基本介绍
通常来说NIO中的所有IO都是从 Channel（通道） 开始的。NIO 的通道类似于流，但有些区别如下：
- 通道可以读也可以写，流一般来说是单向的（只能读或者写，所以之前我们用流进行IO操作的时候需要分别创建一个输入流和一个输出流）
- 通道可以异步读写
- 通道总是基于缓冲区Buffer来读写
3.2 Channel（通道）的主要类型
最为重要的四种Channel（通道），如下：
（1）FileChannel文件通道，用于文件的数据读写；
（2）SocketChannel套接字通道，用于Socket套接字TCP连接的数据读写；
（3）ServerSocketChannel服务器套接字通道（或服务器监听通道），允许我们监听TCP连接请求，为每个监听到的请求，创建一个SocketChannel套接字通道；
（4）DatagramChannel数据报通道，用于UDP协议的数据读写。
3.2.1 ServerSocketChannel
服务端实现步骤:
- 打开一个服务端通道
- 绑定对应的端口号
- 通道默认是阻塞的，需要设置为非阻塞
- 检查是否有客户端连接 有客户端连接会返回对应的通道
- 获取客户端传递过来的数据,并把数据放在byteBuffer这个缓冲区中
- 给客户端回写数据
- 释放资源
public class NIOServer {
public static void main(String[] args) throws IOException, InterruptedException {
// 1.打开一个服务端通道
ServerSocketChannel server = ServerSocketChannel.open();
// 2.绑定对应的端口
server.bind(new InetSocketAddress(9999));
// 3.端口默认是阻塞的，设置为非阻塞
// true为阻塞，false为非阻塞
server.configureBlocking(false);
System.out.println("服务器端启动成功.............");
while (true) {
// 4. 检查是否有客户端连接 有客户端连接会返回对应的通道 , 否则返回null
SocketChannel socketChannel = server.accept();
if (socketChannel == null) {
System.out.println("没有客户端连接...我去做别的事情");
Thread.sleep(2000);
continue;
}
// 5. 获取客户端传递过来的数据,并把数据放在byteBuffer这个缓冲区中
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
//返回值:
// 正数: 表示本次读到的有效字节个数.
// 0 : 表示本次没有读到有效字节.
// -1 : 表示读到了末尾
int read = socketChannel.read(byteBuffer);
System.out.println("客户端消息:" + new String(byteBuffer.array(), 0, read, StandardCharsets.UTF_8));
// 6. 给客户端回写数据
socketChannel.write(ByteBuffer.wrap("你好".getBytes(StandardCharsets.UTF_8)));
// 7. 释放资源
socketChannel.close();
}
}
}
3.2.2 SocketChannel
实现步骤：
- 打开通道
- 设置连接IP和端口号
- 写出数据
- 读取服务器写回的数据
- 释放资源
代码实现：
public class NIOClient {
public static void main(String[] args) throws IOException {
// 1. 打开通道
SocketChannel socketChannel = SocketChannel.open();
// 2.设置连接IP和端口号
socketChannel.connect(new InetSocketAddress("127.0.0.1", 9999));
//3.写出数据
socketChannel.write(ByteBuffer.wrap("hello".getBytes(StandardCharsets.UTF_8)));
//4.读取服务器写回的数据
ByteBuffer readBuffer = ByteBuffer.allocate(1024);
int read = socketChannel.read(readBuffer);
System.out.println("服务端消息:" + new String(readBuffer.array(), 0, read, StandardCharsets.UTF_8));
//5.释放资源
socketChannel.close();
}
}
4. NIO Selector (选择器)
4.1 基本介绍
可以用一个线程，处理多个的客户端连接，就会使用到NIO的Selector(选择器). Selector 能够检测多个注册的服务端通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。
在这种没有选择器的情况下,对应每个连接对应一个处理线程. 但是连接并不能马上就会发送信息,所以还会产生资源浪费
只有在通道真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程, 避免了多线程之间的上下文切换导致的开销
4.2 常用API介绍
4.2.1 Selector 类是一个抽象类
image.png
常用方法:
Selector.open() : //得到一个选择器对象
selector.select() : //阻塞 监控所有注册的通道,当有对应的事件操作时, 会将SelectionKey放入集合内部并返回事件数量
selector.select(1000): //阻塞 1000 毫秒，监控所有注册的通道,当有对应的事件操作时, 会将SelectionKey放入集合内部并返回
selector.selectedKeys() : // 返回存有SelectionKey的集合
4.2.2 SelectionKey
image.png
常用方法
- SelectionKey.isAcceptable(): 是否是连接继续事件
- SelectionKey.isConnectable(): 是否是连接就绪事件
- SelectionKey.isReadable(): 是否是读就绪事件
- SelectionKey.isWritable(): 是否是写就绪事件
SelectionKey中定义的4种事件: - SelectionKey.OP_ACCEPT —— 接收连接继续事件，表示服务器监听到了客户连接，服务器可以接收这个连接了
- SelectionKey.OP_CONNECT —— 连接就绪事件，表示客户端与服务器的连接已经建立成功
- SelectionKey.OP_READ —— 读就绪事件，表示通道中已经有了可读的数据，可以执行读操作了（通道目前有数据，可以进行读操作了）
- SelectionKey.OP_WRITE —— 写就绪事件，表示已经可以向通道写数据了（通道目前可以用于写操作）
4.2.3 Selector编码
服务端实现步骤：
- 打开一个服务端通道
- 绑定对应的端口号
- 通道默认是阻塞的，需要设置为非阻塞
- 创建选择器
- 将服务端通道注册到选择器上，并指定注册监听的事件为OP_ACCEPT
- 检查选择器是否有事件
- 获取事件集合
- 判断事件是否是客户端连接事件SelectionKey.isAcceptable()
- 得到客户端通道，并将通道注册到选择器上，并指定监听事件为OP_READ
- 判断是否是客户端读就绪事件SelectionKey.isReadable()
- 得到客户端通道，读取数据到缓冲区
- 给客户端回写数据
- 从集合中删除对应的事件，防止二次处理
代码实现：
public class NIOSelectorServer {
public static void main(String[] args) throws IOException, InterruptedException{
//1. 打开一个服务端通道
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
//2. 绑定对应的端口号
serverSocketChannel.bind(new InetSocketAddress(9999));
//3. 通道默认是阻塞的，需要设置为非阻塞
serverSocketChannel.configureBlocking(false);
//4. 创建选择器
Selector selector = Selector.open();
//5. 将服务端通道注册到选择器上,并指定注册监听的事件为OP_ACCEPT
serverSocketChannel.register(selector, SelectionKey.OP_READ);
System.out.println("服务端启动成功...");
while (true) {
//6. 检查选择器是否有事件
int select = selector.select(2000);
if (select == 0) {
continue;
}
//7. 获取事件集合
Set selectionKeys = selector.selectedKeys();
Iterator iterator = selectionKeys.iterator();
while (iterator.hasNext()) {
//8. 判断事件是否是客户端连接事件SelectionKey.isAcceptable()
SelectionKey key = iterator.next();
//9. 得到客户端通道,并将通道注册到选择器上, 并指定监听事件为OP_READ
if (key.isAcceptable()) {
SocketChannel socketChannel = serverSocketChannel.accept();
System.out.println("客户端已连接......" + socketChannel);
// 必须设置通道为非阻塞，因为selector需要轮询监听每个通道的事件
socketChannel.configureBlocking(false);
//并指定监听事件为OP_READ
socketChannel.register(selector, SelectionKey.OP_READ);
}
//10. 判断是否是客户端读就绪事件SelectionKey.isReadable()
if (key.isAcceptable()) {
//11.得到客户端通道,读取数据到缓冲区
SocketChannel socketChannel = (SocketChannel) key.channel();
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
int read = socketChannel.read(byteBuffer);
if (read > 0) {
System.out.println("客户端消息:" +
new String(byteBuffer.array(), 0, read, StandardCharsets.UTF_8));
//12.给客户端回写数据
socketChannel.write(ByteBuffer.wrap("hello".getBytes(StandardCharsets.UTF_8)));
socketChannel.close();
}
}
//13.从集合中删除对应的事件, 因为防止二次处理.
iterator.remove();
}
}
}
}
感谢阅读，这些知识点的导图和问题的答案详解的PDF文档都可以免费分享给大家，点赞收藏文章后，私信【资料】免费领取！
