IO , NIO ,AIO

Myth丶恋晨 2024-04-17 21:38 73阅读 0赞

> # **1、JAVA NIO 概念** #

NIO与原来的IO有同样的作用和目的，但是使用 的方式完全不同，NIO支持面向缓冲区的、基于 通道的IO操作。NIO将以更加高效的方式进行文 件的读写操作

> # **2、Java NIO 与 IO 的主要区别** #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1eXVucWlhbmcxMTE_size_16_color_FFFFFF_t_70][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1eXVucWlhbmcxMTE_size_16_color_FFFFFF_t_70 1][]

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td> <p>IO</p> </td> 
   <td>NIO</td> 
  </tr> 
  <tr> 
   <td>面向流(Stream Oriented)</td> 
   <td>面向缓冲区(Buffer Oriented)</td> 
  </tr> 
  <tr> 
   <td>阻塞IO(Blocking IO)</td> 
   <td>非阻塞IO(Non Blocking IO)</td> 
  </tr> 
  <tr> 
   <td>(无)</td> 
   <td>选择器(Selectors)</td> 
  </tr> 
 </tbody> 
</table>

> # 3、通道和缓冲区 #

通道(Channel)和缓冲区 (Buffer)。通道表示打开到 IO 设备(例如：文件、 套接字)的连接。若需要使用 NIO 系统，需要获取 用于连接 IO 设备的通道以及用于容纳数据的缓冲 区。然后操作缓冲区，对数据进行处理。

**简而言之，Channel 负责传输， Buffer 负责存储**

/*
     * 一、缓冲区（Buffer）：在 Java NIO 中负责数据的存取。缓冲区就是数组。用于存储不同数据类型的数据
     * 
     * 根据数据类型不同（boolean 除外），提供了相应类型的缓冲区：
     * ByteBuffer
     * CharBuffer
     * ShortBuffer
     * IntBuffer
     * LongBuffer
     * FloatBuffer
     * DoubleBuffer
     * 
     * 上述缓冲区的管理方式几乎一致，通过 allocate() 获取缓冲区
     * 
     * 二、缓冲区存取数据的两个核心方法：
     * put() : 存入数据到缓冲区中
     * get() : 获取缓冲区中的数据
     * 
     * 三、缓冲区中的四个核心属性：
     * capacity : 容量，表示缓冲区中最大存储数据的容量。一旦声明不能改变。
     * limit : 界限，表示缓冲区中可以操作数据的大小。（limit 后数据不能进行读写）
     * position : 位置，表示缓冲区中正在操作数据的位置。
     * 
     * mark : 标记，表示记录当前 position 的位置。可以通过 reset() 恢复到 mark 的位置
     * 
     * 0 <= mark <= position <= limit <= capacity
     * 
     * 四、直接缓冲区与非直接缓冲区：
     * 非直接缓冲区：通过 allocate() 方法分配缓冲区，将缓冲区建立在 JVM 的内存中
     * 直接缓冲区：通过 allocateDirect() 方法分配直接缓冲区，将缓冲区建立在物理内存中。可以提高效率
     */

> # **4、**NIO 的非阻塞式网络通信 #

**传统的 IO 流都是阻塞式的**

也就是说，当一个线程调用 read() 或 write() 时，该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不 能执行其他任务。因此，在完成网络通信进行 IO 操作时，由于线程会 阻塞，所以服务器端必须为每个客户端都提供一个独立的线程进行处理， 当服务器端需要处理大量客户端时，性能急剧下降。

**Java NIO 是非阻塞模式的。**

当线程从某通道进行读写数据时，若没有数 据可用时，该线程可以进行其他任务。线程通常将非阻塞 IO 的空闲时 间用于在其他通道上执行 IO 操作，所以单独的线程可以管理多个输入 和输出通道。因此，NIO 可以让服务器端使用一个或有限几个线程来同 时处理连接到服务器端的所有客户端。

**选择器（Selector）**

SelectableChannle 对象的多路复用器，Selector 可 以同时监控多个 SelectableChannel 的 IO 状况，也就是说，利用 Selector 可使一个单独的线程管理多个 Channel。Selector 是非阻塞 IO 的核心。

SelectionKey 的四个常量表示）：

1.   读 : SelectionKey.OP\_READ （1） 
2.  写 : SelectionKey.OP\_WRITE （4）
3.   连接 : SelectionKey.OP\_CONNECT （8） 
4.  接收 : SelectionKey.OP\_ACCEPT （16）

## BIO 是什么？ ##

? **概念**

*  BIO ，全称 Block-IO ，是一种**阻塞** + **同步**的通信模式。
 *  是一个比较传统的通信方式，模式简单，使用方便。但并发处理能力低，通信耗时，依赖网速。

? **原理**

*  服务器通过一个 Acceptor 线程，负责监听客户端请求和为每个客户端创建一个新的线程进行链路处理。典型的**一请求一应答模式**。
 *  若客户端数量增多，频繁地创建和销毁线程会给服务器打开很大的压力。后改良为用线程池的方式代替新增线程，被称为伪异步 IO 。

? **示例**

*  代码参见 [bio][] 。

? **小结**

BIO 模型中，通过 Socket 和 ServerSocket 实现套接字通道的通信。阻塞，同步，建立连接耗时。

## NIO 是什么？ ##

? **概念**

*  NIO ，全称 New IO ，也叫 Non-Block IO ，是一种**非阻塞** + 同步的通信模式。
 *  [《精尽 Netty 源码分析 —— NIO 基础（一）之简介》][Netty _ _ NIO]

? **原理**

*  NIO 相对于 BIO 来说一大进步。客户端和服务器之间通过 Channel 通信。NIO 可以在 Channel 进行读写操作。这些 Channel 都会被注册在 Selector 多路复用器上。Selector 通过一个线程不停的轮询这些 Channel 。找出已经准备就绪的 Channel 执行 IO 操作。
 *  NIO 通过一个线程轮询，实现千万个客户端的请求，这就是非阻塞 NIO 的特点。
    
     *  缓冲区 Buffer ：它是 NIO 与 BIO 的一个重要区别。
        
         *  BIO 是将数据直接写入或读取到流 Stream 对象中。
         *  NIO 的数据操作都是在 Buffer 中进行的。Buffer 实际上是一个数组。Buffer 最常见的类型是ByteBuffer，另外还有 CharBuffer，ShortBuffer，IntBuffer，LongBuffer，FloatBuffer，DoubleBuffer。
         *  [《精尽 Netty 源码分析 —— NIO 基础（三）之 Buffer》][Netty _ _ NIO _ Buffer]
     *  通道 Channel ：和流 Stream 不同，通道是双向的。NIO可以通过 Channel 进行数据的读、写和同时读写操作。
        
         *  通道分为两大类：一类是网络读写（SelectableChannel），一类是用于文件操作（FileChannel）。我们使用的是前者 SocketChannel 和 ServerSocketChannel ，都是SelectableChannel 的子类。
         *  [《精尽 Netty 源码分析 —— NIO 基础（二）之 Channel》][Netty _ _ NIO _ Channel]
     *  多路复用器 Selector ：NIO 编程的基础。多路复用器提供选择已经就绪的任务的能力：就是 Selector 会不断地轮询注册在其上的通道（Channel），如果某个通道处于就绪状态，会被 Selector 轮询出来，然后通过 SelectionKey 可以取得就绪的Channel集合，从而进行后续的 IO 操作。
        
         *  服务器端只要提供一个线程负责 Selector 的轮询，就可以接入成千上万个客户端，这就是 JDK NIO 库的巨大进步。
         *  [《精尽 Netty 源码分析 —— NIO 基础（四）之 Selector》][Netty _ _ NIO _ Selector]

? **示例**

*  代码参见 [nio][]
 *  [《精尽 Netty 源码分析 —— NIO 基础（五）之示例》][Netty _ _ NIO 1]

? **小结**

NIO 模型中通过 SocketChannel 和 ServerSocketChannel 实现套接字通道的通信。非阻塞，同步，避免为每个 TCP 连接创建一个线程。

? **继续挖掘**

可能有胖友对非阻塞和阻塞，同步和异步的定义有点懵逼，我们再来看下 [《精尽 Netty 源码分析 —— NIO 基础（一）之简介》][Netty _ _ NIO] 提到的一段话：

> 老艿艿：在一些文章中，会将 Java NIO 描述成**异步** IO ，实际是不太正确的： Java NIO 是**同步** IO ，Java AIO ( 也称为 NIO 2 )是**异步** IO。具体原因，推荐阅读文章：
> 
>  *  [《异步和非阻塞一样吗? (内容涉及 BIO, NIO, AIO, Netty)》][_ BIO_ NIO_ AIO_ Netty] 。
>  *  [《BIO与NIO、AIO的区别(这个容易理解)》][BIO_NIO_AIO]
> 
> 总结来说，在 **Unix IO 模型**的语境下：
> 
>  *  同步和异步的区别：数据拷贝阶段是否需要完全由操作系统处理。
>  *  阻塞和非阻塞操作：是针对发起 IO 请求操作后，是否有立刻返回一个标志信息而不让请求线程等待。
> 
> 因此，Java NIO 是**同步**且非阻塞的 IO 。

*  另外，胖友在瞅瞅下面这个图来理解下：![Unix 的 5 种 IO 模型][Unix _ 5 _ IO]

## AIO 是什么？ ##

> 艿艿：这个面试题，重点在于陈述我们对 BIO、NIO 的理解，对于 AIO 来说，基本理解即可。

? **概念**

*  AIO ，全称 Asynchronous IO ，也叫 NIO**2** ，是一种**非阻塞** + **异步**的通信模式。在 NIO 的基础上，引入了新的异步通道的概念，并提供了异步文件通道和异步套接字通道的实现。
 *  原理：
 *  AIO 并没有采用 NIO 的多路复用器，而是使用异步通道的概念。其 read，write 方法的返回类型，都是 Future 对象。而 Future 模型是异步的，其核心思想是：**去主函数等待时间**。

? **示例**

*  代码参见 [aio][]

? **小结**

AIO 模型中通过 AsynchronousSocketChannel 和 AsynchronousServerSocketChannel 实现套接字通道的通信。非阻塞，异步。

## BIO、NIO 有什么区别？ ##

*  线程模型不同
    
     *  BIO：一个连接一个线程，客户端有连接请求时服务器端就需要启动一个线程进行处理。所以，线程开销大。可改良为用线程池的方式代替新创建线程，被称为伪异步 IO 。
     *  NIO：一个请求一个线程，但客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有新的 I/O 请求时，才启动一个线程进行处理。可改良为一个线程处理多个请求，基于 [多 Reactor 模型][Reactor]。
 *  BIO 是面向流( Stream )的，而 NIO 是面向缓冲区( Buffer )的。
 *  BIO 的各种操作是阻塞的，而 NIO 的各种操作是非阻塞的。
 *  BIO 的 Socket 是单向的，而 NIO 的 Channel 是双向的。

可能文字比较难记，整理出来就是下图：![BIO 对比 NIO 对比 AIO][BIO _ NIO _ AIO]

*  有一点要注意，虽然图中说 NIO 的性能一般，但是在绝大多数我们日常业务场景，NIO 和 AIO 的性能差距实际没这么大。在 Netty5 中，基于 AIO 改造和支持，最后发现，性能并没有想象中这么强悍，所以 Netty5 被废弃，而是继续保持 Netty4 为主版本，使用 NIO 为主。

为了胖友能更好的记住和理解 BIO、NIO、AIO 的流程，胖友可以在理解下图：![BIO、NIO、AIO 的流程图][BIO_NIO_AIO 1]

> # **NIO完成非阻塞通信** #

/*
     * 一、使用 NIO 完成网络通信的三个核心：
     * 
     * 1. 通道（Channel）：负责连接
     * 		
     * 	   java.nio.channels.Channel 接口：
     * 			|--SelectableChannel
     * 				|--SocketChannel
     * 				|--ServerSocketChannel
     * 				|--DatagramChannel
     * 
     * 				|--Pipe.SinkChannel
     * 				|--Pipe.SourceChannel
     * 
     * 2. 缓冲区（Buffer）：负责数据的存取
     * 
     * 3. 选择器（Selector）：是 SelectableChannel 的多路复用器。用于监控 SelectableChannel 的 IO 状况
     * 
     */
    public class TestNonBlockingNIO {
    	
    	//客户端
    	@Test
    	public void client() throws IOException{
    		//1. 获取通道
    		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
    		
    		//2. 切换非阻塞模式
    		sChannel.configureBlocking(false);
    		
    		//3. 分配指定大小的缓冲区
    		ByteBuffer buf = ByteBuffer.allocate(1024);
    		
    		//4. 发送数据给服务端
    		Scanner scan = new Scanner(System.in);
    		
    		while(scan.hasNext()){
    			String str = scan.next();
    			buf.put((new Date().toString() + "\n" + str).getBytes());
    			buf.flip();
    			sChannel.write(buf);
    			buf.clear();
    		}
    		
    		//5. 关闭通道
    		sChannel.close();
    	}
    
    	//服务端
    	@Test
    	public void server() throws IOException{
    		//1. 获取通道
    		ServerSocketChannel ssChannel = ServerSocketChannel.open();
    		
    		//2. 切换非阻塞模式
    		ssChannel.configureBlocking(false);
    		
    		//3. 绑定连接
    		ssChannel.bind(new InetSocketAddress(9898));
    		
    		//4. 获取选择器
    		Selector selector = Selector.open();
    		
    		//5. 将通道注册到选择器上, 并且指定“监听接收事件”
    		// 选择器监控 通过是什么状态 写，读
    		ssChannel.register(selector, SelectionKey.OP_ACCEPT);
    		
    		//6. 轮询式的获取选择器上已经“准备就绪”的事件
    		while(selector.select() > 0){
    			
    			//7. 获取当前选择器中所有注册的“选择键(已就绪的监听事件)”
    			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
    			
    			while(it.hasNext()){
    				//8. 获取准备“就绪”的是事件
    				SelectionKey sk = it.next();
    				
    				//9. 判断具体是什么事件准备就绪
    				if(sk.isAcceptable()){
    					//10. 若“接收就绪”，获取客户端连接
    					SocketChannel sChannel = ssChannel.accept();
    					
    					//11. 切换非阻塞模式
    					sChannel.configureBlocking(false);
    					
    					//12. 将该通道注册到选择器上
    					sChannel.register(selector, SelectionKey.OP_READ);
    				}else if(sk.isReadable()){
    					//13. 获取当前选择器上“读就绪”状态的通道
    					SocketChannel sChannel = (SocketChannel) sk.channel();
    					
    					//14. 读取数据
    					ByteBuffer buf = ByteBuffer.allocate(1024);
    					
    					int len = 0;
    					while((len = sChannel.read(buf)) > 0 ){
    						buf.flip();
    						System.out.println(new String(buf.array(), 0, len));
    						buf.clear();
    					}
    				}
    				
    				//15. 取消选择键 SelectionKey
    				it.remove();
    			}
    		}
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1eXVucWlhbmcxMTE_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190901172347831.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1eXVucWlhbmcxMTE=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1eXVucWlhbmcxMTE_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/4e9731e77cc340eb95f39b502b82bebe.png
[bio]: https://github.com/ITDragonBlog/daydayup/tree/master/Netty/socket-io/src/com/itdragon/bio
[Netty _ _ NIO]: http://svip.iocoder.cn/Netty/nio-1-intro/
[Netty _ _ NIO _ Buffer]: http://svip.iocoder.cn/Netty/nio-3-buffer/
[Netty _ _ NIO _ Channel]: http://svip.iocoder.cn/Netty/nio-2-channel/
[Netty _ _ NIO _ Selector]: http://svip.iocoder.cn/Netty/nio-4-selector/
[nio]: https://github.com/ITDragonBlog/daydayup/tree/master/Netty/socket-io/src/com/itdragon/nio
[Netty _ _ NIO 1]: http://svip.iocoder.cn/Netty/nio-5-demo/
[_ BIO_ NIO_ AIO_ Netty]: https://blog.csdn.net/matthew_zhang/article/details/71328697
[BIO_NIO_AIO]: https://blog.csdn.net/skiof007/article/details/52873421
[Unix _ 5 _ IO]: https://imgconvert.csdnimg.cn/aHR0cDovL3N0YXRpYzIuaW9jb2Rlci5jbi9pbWFnZXMvTmV0dHkvMjAxN18xMF8yNC8wMS5wbmc?x-oss-process=image/format,png
[aio]: https://github.com/ITDragonBlog/daydayup/tree/master/Netty/socket-io/src/com/itdragon/aio
[Reactor]: http://svip.iocoder.cn/Netty/EventLoop-1-Reactor-Model/
[BIO _ NIO _ AIO]: https://imgconvert.csdnimg.cn/aHR0cDovL3N0YXRpYzIuaW9jb2Rlci5jbi9pbWFnZXMvTmV0dHkvMjAxN18xMF8yNC8wMi5wbmc?x-oss-process=image/format,png
[BIO_NIO_AIO 1]: https://imgconvert.csdnimg.cn/aHR0cDovL3N0YXRpYzIuaW9jb2Rlci5jbi9pbWFnZXMvTmV0dHkvMjAxN18xMF8yNC8wMy5wbmc?x-oss-process=image/format,png