一、NIO 的基本介绍
- 同步非阻塞的IO（non-blocking IO）
- 三大核心部分：Channel(通道)，Buffer(缓冲区), Selector(选择器)
- NIO面向缓冲区编程 ，增加了操作的灵活性。
- NIO读和写都是非阻塞的，当 读操作–>当前资源未就绪 或者 写操作–>当前未完全写入 时，当前线程都可以做其他处理。也就是说，多个请求发过来，不必分配相同线程数去处理请求（例如1000个请求，根据实际情况可以分配5-10个线程处理即可）。
- NIO 和 BIO 对比
- BIO 以流的方式处理数据,而 NIO 以缓冲区的方式处理数据,缓冲区 I/O 的效率比流 I/O 高很多
- BIO 是阻塞的，NIO则是非阻塞的
- BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel(通道)和 Buffer(缓冲区)进行操作，数据 总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道的 事件（比如：连接请求， 数据到达等），因此使用单个线程就可以监听多个客户端通道
二、NIO的核心原理
三大组件的原理图：
关系说明：
1. 每个 channel 都会对应一个 Buffer
2. Selector 对应一个线程， 一个线程对应多个 channel（连接 ）
3. 每个 channel 都注册到 Selector选择器上
4. . Selector不断轮询查看Channel上的事件, 事件是通道Channel非常重要的概念
5. Selector 会根据不同的事件，完成不同的处理操作
6. Buffer 是一个内存块 ， 底层有一个数组
7. 数据的读取写入是通过 Buffer, 这个和 BIO不同 , BIO 中是输入输出流, 不能双向，但是 NIO 的 Buffer 是可以读也可以写 , channel 是双向的.
三、NIO的三大件
1、缓冲区(Buffer)
-
基本介绍：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个数组，该对象提供了一组方法，可以更轻松地使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的 状态变化情况。Channel 提供从网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer.
-
常用API介绍
-
在 NIO 中，Buffer是一个顶层父类，它是一个抽象类, 类的层级关系图,常用的缓冲区分别对应 byte,short, int, long,float,double,char 7种.
-
Buffer对象创建
- 接口：
方法名 说明 static ByteBuffer allocate(长度) 创建byte类型的指定长度的缓冲区 static ByteBuffer wrap(byte[] array) 创建一个有内容的byte类型缓冲区 - 引入junit包测试，测试代码如下：
@Test public void testCreateBuffer(){ //创建一个指定长度的缓冲区, 以ByteBuffer为例 ByteBuffer byteBuffer = ByteBuffer.allocate(4); for (int i = 0; i < 4; i++) { System.out.println(byteBuffer.get()); } System.out.println("-------------创建一个有内容的缓冲区---------------"); ByteBuffer byteBuffer1 = ByteBuffer.wrap("abc".getBytes()); for (int i = 0; i < 3; i++) { System.out.println((char) byteBuffer1.get()); } }- 测试结果：
-
Buffer添加数据
- 接口：
方法名 说明 int position()/position(int newPosition) 获得当前要操作的索引/修改当前要操作的索引位置 int limit()/limit(int newLimit) 最多能操作到哪个索引/修改最多能操作的索引位置 int capacity() 返回缓冲区的总长度 int remaining()/boolean hasRemaining() 还有多少能操作索引个数/是否还有能操作 put(byte b)/put(byte[] src) 添加一个字节/添加字节数组 - 测试数据添加：
@Test public void test1(){ //创建一个指定长度的缓冲区 ByteBuffer allocate = ByteBuffer.allocate(10); allocate.put("0123".getBytes()); 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 }- 测试结果：
-
Buffer读取数据
-
接口
方法名 介绍 flip() 写切换读模式 limit设置为position位置, position设置为0 get() 读一个字节 get(byte[] dst) 读多个字节 get(int index) 读指定索引的字节 rewind() 将position设置为0，可以重复读 clear() 切换写模式，position设置为0，limit设置为capacity array() 将缓冲区转换为字节数组返回
-
测试读模式，在test1方法中添加代码
//切换读模式 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.print(（char）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方法，但是数据还未消失，等再次写入数据，被覆盖了才会消失。
-
-
2、通道(Channel)
-
基本介绍
-
常 用 的Channel实现类类 有 ：FileChannel , DatagramChannel ,ServerSocketChannel和 SocketChannel 。FileChannel 用于文件的数据读写， DatagramChannel 用于 UDP 的数据读写， ServerSocketChannel 和SocketChannel 用于 TCP 的数据读写。
-
SocketChannel 与ServerSocketChannel 类似 Socke和ServerSocket,可以完成客户端与服务端数据的通信工作。
-
-
使用实现
-
服务端实现：
-
步骤
- 打开一个服务端通道
- 绑定对应的端口号
- 通道默认是阻塞的，需要设置为非阻塞
- 检查是否有客户端连接，当有客户端连接时会返回对应的通道
- 获取客户端传递过来的数据,并把数据放在byteBuffer这个缓冲区中
- 给客户端回写数据
- 释放资源
-
代码实现：
public class Server { public static void main(String[] args) throws IOException, InterruptedException { //1. 打开一个服务端通道 ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); //2. 绑定对应的端口号 serverSocketChannel.bind(new InetSocketAddress(9988)); //3. 通道默认是阻塞的，需要设置为非阻塞 serverSocketChannel.configureBlocking(false); System.out.println("server start..."); while(true){ //4. 检查是否有客户端连接 有客户端连接会返回对应的通道 SocketChannel socketChannel = serverSocketChannel.accept(); if (socketChannel == null){ System.out.println("没有客户端连接...可以处理其他事情"); Thread.sleep(2 * 1000); continue; } //5. 获取客户端传递过来的数据,并把数据放在byteBuffer这个缓冲区中 ByteBuffer allocate = ByteBuffer.allocate(1024); /* 返回值： 正数: 表示本地读到有效字节数 0: 表示本次没有读到数据 -1: 表示读到末尾 */ int len = socketChannel.read(allocate); System.out.println("客户端消息:" + new String(allocate.array(), 0, len, StandardCharsets.UTF_8)); //6. 给客户端回写数据 socketChannel.write(ByteBuffer.wrap("hello,client...".getBytes(StandardCharsets.UTF_8))); //7. 释放资源 socketChannel.close(); } } }
-
-
客户端实现：
- 步骤
- 打开通道
- 设置连接IP和端口号
- 发送数据
- 读取服务器写回的数据
- 释放资源
-
代码实现：
public class Client { public static void main(String[] args) throws IOException { //1. 打开通道 SocketChannel socketChannel = SocketChannel.open(); //2. 设置连接IP和端口号 socketChannel.connect(new InetSocketAddress("127.0.0.1", 9988)); //3. 写出数据 socketChannel.write(ByteBuffer.wrap("hello,server...".getBytes(StandardCharsets.UTF_8))); //4. 读取服务器写回的数据 ByteBuffer allocate = ByteBuffer.allocate(1024); int len = socketChannel.read(allocate); System.out.println("服务端消息:" + new String(allocate.array(), 0, len, StandardCharsets.UTF_8)); //5. 释放资源 socketChannel.close(); } }
-
测试效果：
3、Selector (选择器)
-
思考：为什么要有Selector选择器？
-
每一个channel对应一个socket连接，当有客户端连接时，都会将对应的 channel注册到Selector上，当channel有事件发生时（连接、读/写），Selector会轮询到，然后在处理对应的事件。
-
Selector只需要一个线程去管理，也就是管理多个连接和请求。
-
-
Selector选择器处理流程
-
常用API介绍
- Selector 类是一个抽象类
- 常用接口：
方法名 介绍 open() 得到一个选择器对象 select() 阻塞监控所有注册的通道,当有对应的事件操作时, 会将SelectionKey放入 集合内部并返回事件数量 select(1000) 阻塞 1000 毫秒，监控所有注册的通道,当有对应的事件操作时, 会将 SelectionKey放入集合内部并返回 selectedKeys() 返回存有SelectionKey的集合 -
SelectionKey
- 常用方法
方法名 介绍 isAcceptable() 是否是连接继续事件 isConnectable() 是否是连接就绪事件 isReadable() 是否是读就绪事件 isWritable() 是否是写就绪事件 -
SelectionKey中定义的4种事件
| 事件 | 描述 |
|---|---|
| SelectionKey.OP_ACCEPT | 接收连接继续事件，表示服务器监听到了客户连接，服务器可以接收这个连接了 |
| SelectionKey.OP_CONNECT | 连接就绪事件，表示客户端与服务器的连接已经建立成功 |
| SelectionKey.OP_READ | 读就绪事件，表示通道中已经有了可读的数据，可以执行读操作了（通道目前有数据，可以进行读操作了） |
| SelectionKey.OP_WRITE | 写就绪事件，表示已经可以向通道写数据了（通道目前可以用于写操作） |
-
Selector编码
-
服务端：
-
实现步骤
-
打开一个服务端通道
-
绑定对应的端口号
-
通道默认是阻塞的，需要设置为非阻塞
-
创建选择器
-
将服务端通道注册到选择器上,并指定注册监听的事件为OP_ACCEPT
-
检查选择器是否有事件
-
获取事件集合
-
判断事件是否是客户端连接事件SelectionKey.isAcceptable()
-
得到客户端通道,并将通道注册到选择器上, 并指定监听事件为OP_READ
-
判断是否是客户端读就绪事件SelectionKey.isReadable()
-
得到客户端通道,读取数据到缓冲区
-
给客户端回写数据
-
从集合中删除对应的事件, 因为防止二次处理.
-
-
服务端代码
public class SelectorServer { public static void main(String[] args) throws IOException { //1. 打开一个服务端通道 ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); //2. 绑定对应的端口号 serverSocketChannel.bind(new InetSocketAddress(9988)); //3. 通道默认是阻塞的，需要设置为非阻塞 serverSocketChannel.configureBlocking(false); //4. 创建选择器 Selector selector = Selector.open(); //5. 将服务端通道注册到选择器上,并指定注册监听的事件为OP_ACCEPT serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); System.out.println("server start..."); while (true){ //6. 检查选择器是否有事件 int select = selector.select(2000); if (select == 0){ System.out.println("当前没有事件待处理..."); continue; } //7. 获取事件集合 Set<SelectionKey> selectionKeys = selector.selectedKeys(); Iterator<SelectionKey> iterator = selectionKeys.iterator(); while (iterator.hasNext()){ //8. 判断事件是否是客户端连接事件SelectionKey.isAcceptable() SelectionKey key = iterator.next(); if (key.isAcceptable()){ //9. 得到客户端通道,并将通道注册到选择器上, 并指定监听事件为OP_READ SocketChannel socketChannel = serverSocketChannel.accept(); System.out.println("有客户端连接..."); //将通道必须设置为非阻塞的状态，因为selector选择器需要轮询监听每个通道的事件 socketChannel.configureBlocking(false); //指定监听事件为OP_READ 读就绪事件 socketChannel.register(selector, SelectionKey.OP_READ); } //10. 判断是否是客户端读就绪事件SelectionKey.isReadable() if (key.isReadable()){ //11. 得到客户端通道,读取数据到缓冲区 SocketChannel socketChannel = (SocketChannel) key.channel(); ByteBuffer allocate = ByteBuffer.allocate(1024); int read = socketChannel.read(allocate); if (read > 0){ System.out.println("客户端消息:" + new String(allocate.array(), 0, read , StandardCharsets.UTF_8)); //12. 给客户端回写数据 socketChannel.write(ByteBuffer.wrap("hello,server...".getBytes())); socketChannel.close(); } } //13. 从集合中删除对应的事件, 因为防止二次处理. iterator.remove(); } } } }
-
-
客户端没有变化，仍然使用channel下的客户端编码
-
测试结果：
-
总结
- NIO，同步非阻塞的I/O模型，具备Buffer、Channel、Selector三大组件。
- 由于使用缓冲区，比BIO的流效率高，且双向处理数据更方便。
- 由于具有Selector组件，可以轮询各个客户端连接对应的SocketChannel注册的事件，因此单线程可以处理多个连接请求，比BIO一个请求占用一个线程要高效的多。
- 扩展：原生的NIO仍然具有问题，如：编程复杂，要求较高 且 还有JDK NIO的bug存在。目前主流使用Netty框架提供异步的、基于事件驱动的网络应用程序框架。关于Netty的具体介绍敬请查看Netty基本介绍 和 线程模型。
1566
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
