【Java基础】从网络层面理解BIO，NIO，AIO(一)

àì夳堔傛蜴生んèń 2023-07-08 08:00 1阅读 0赞

### 文章目录 ###

*  前言
 *  一.相关概念
 *   *  1.用户空间 / 内核空间
     *  2.系统调用
     *  3.库函数
     *  4.shell
     *  5.进程切换
     *  6.用户线程与用户进程的关系
     *  7.理解线程的睡眠，挂起，和阻塞
     *  8.文件描述符
     *  9.Linux的recv、send、read、write函数区别
 *  二.网络请求的本质
 *  三.Linux网络编程5种I/O模型
 *   *  1.什么是I/O?
     *  2.阻塞和非阻塞
     *  3.同步和异步
     *  4.以银行取款为例说明同步/异步/阻塞 /非阻塞
     *  5.I/O模型种类
     *   *  5.1. 同步阻塞式I/O模型
         *  5.2. 同步非阻塞式I/O模型
         *  5.3. I/O多路复用（事件驱动）模型
         *   *  5.3.1.主体
             *  5.3.2.Java的IO多路复用机制
             *  5.3.3.两种I/O多路复用模式：Reactor和Proactor模式
         *  5.4. 信号驱动式I/O(SIGIO)
         *  5.5. 异步I/O模型
         *  5.6.I/O模型的比较
     *  6.总结
     *  四.从Java语言层面理解BIO，NIO，AIO

# 前言 #

# 一.相关概念 #

**下面仅是从宏观的角度去理解Linux用户态和内核态的设计，并没有去深究它们的具体实现方式。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70]

## 1.用户空间 / 内核空间 ##

**(也可以说是`用户态、内核态`)**

*  **Linux 操作系统和 驱动程序** 运行在`内核空间`，**应用程序**运行在`用户空间`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center]

**如图所示，从宏观上看，Linux操作系统的体系架构分为`用户态和内核态（或者用户空间和内核空间）`。**

*  **内核态**从本质上看是一种`软件`——`控制计算机的硬件资源，例如协调CPU资源，分配内存资源，并提供上层应用程序运行的环境`。
 *  **用户态**即`提供上层应用程序运行的空间`，`应用程序的运行必须依托于内核态提供的资源`，包括`CPU资源、存储资源、I/O资源等`。为了`使上层应用程序能够访问到这些资源`，内核必须为上层应用程序提供访问的接口：这些接口就叫**系统调用**。

[用户态和内核态的区别][Link 1]

## 2.系统调用 ##

Linux 内核提供的一组 **用户进程(开发者)与内核态进行交互的`特殊功能函数` ，称为 “`系统调用`”** 。**用户可以通过系统调用命令在自己的应用程序中调用它们，从而获得某些操作系统的服务**。从某种角度来看，系统调用和普通的函数调用非常相似。

区别仅仅在于

*  **系统调用（system call）** 由`操作系统核心`提供，运行于`内核态`;
 *  **普通的函数调用（Library functions,库函数调用）** 由`函数库`或`用户自己提供`，运行于`用户态`。
 *  Linux内核还提供了一些`C语言函数库`，这些库对`系统调用`进行了一些`封装和扩展`，因为这些库函数与系统调用的关系非常紧密，所以习惯上把这些函数也称为系统调用。
 *  实际上，**系统调用是用户空间访问内核空间的唯一手段（除异常和陷入外，它们是内核唯一的合法入口）**
 *  [Linux常用系统调用][Linux]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 2]

## 3.库函数 ##

*  `用于屏蔽复杂的底层实现细节，减轻程序员的负担，从而更加关注上层应用程序的逻辑实现`。它`对系统调用进行封装，提供简单的基本接口给用户`，这样增强了程序的灵活性
 *  **对于简单的接口，也可以直接使用`系统调用`访问资源**，例如：`open()，write()，read()`等等。
 *  **库函数根据不同的标准也有不同的实现版本**，例如：`glibc库`，`posix库`等。

## 4.shell ##

*  Shell是一个`特殊的应用程序`，俗称命令行，**本质上是一个命令解释器**，`它下通系统调用，上通各种应用`，通常充当着一种`“胶水”`的角色，来连接各个小功能程序，让不同程序能够以一个清晰的接口协同工作，从而增强各个程序的功能。
 *  可以通过符合Shell语法的 **Shell脚本**进行编程，通常短短的几行Shell脚本就可以实现一个非常大的功能，**原因就是这些`Shell语句通常都对系统调用做了一层封装。`**
 *  为了`方便用户和系统交互`，一般，`一个Shell对应一个终端，终端是一个硬件设备，呈现给用户的是一个图形化窗口`。我们可以通过这个窗口输入或者输出文本(`shell命令`)。这个文本直接传递给shell进行分析解释，然后执行。

## 5.进程切换 ##

*  进程切换指`从正在运行的进程中收回CPU时间片，让等待运行进程来占有CPU时间片运行(也可以理解为 "上下文切换")`。
    
     *  实质上就是被中断运行进程与待运行进程的上下文切换。
     *  我们日常用的操作系统的都是分时的操作系统。`CPU一个时间只能执行一条指令`，那么是怎么实现多任务同时执行的呢？
        
         *  举个例子，就好比早上吃早饭，一边吃面包，一边喝牛奶。可是只有一张嘴，怎么同时吃呢。那就吃一口面包，喝一口牛奶。如果轮换的快了，看起来好像就是同时吃。这种`“轮换”`就是所谓的`“切换”`。
         *  系统中的每个进程只运行一个很短的`时间片`，然后就被切走，换另个运行。这样就好象所有进程同时都运行一样。进程切换时要保存一些必要的信息，比如进程当时所使用的寄存器的状态等等

## 6.用户线程与用户进程的关系 ##

*  **由于用户线程`不依赖`于操作系统内核，因此操作系统内核是不知道用户线程的存在的，用户线程是由`开发者`来管理和调度的，`开发者`利用线程库提供的API来创建、同步、调度和管理线程**。所以，用户线程的调度在用户程序内部进行，通常采用 非抢占式 和更简单的规则，也无须用户态和核心态切换，所以速度很快。
 *  **由于操作系统不知道用户线程的存在，所以`操作系统把CPU的时间片分配给用户进程`，再由`用户进程的管理器将时间分配给用户线程`。那么，用户进程能得到的时间片即为`所有用户线程共享`。**

## 7.理解线程的睡眠，挂起，和阻塞 ##

观看我写的文章【Java多线程】高并发的概念之线程的睡眠，挂起，和阻塞可以了解此概念

## 8.文件描述符 ##

文件描述符（File descriptor）,简称`fd`，当应用程序请求内核`打开/新建一个文件`时，内核会返回一个**文件描述符**用于`对应这个打开/新建的文件`，其fd本质上就是一个`非负整数`。实际上，它是一个`索引值`，指向内核为每一个进程所维护的该进程打开文件的记录表。程序设计中，一些涉及`底层`的程序编写往往会围绕着文件描述符展开。但是文件描述符这一概念往往只适用于UNIX、Linux这样的操作系统。

*  每个文件描述符会与一个打开的文件相对应
 *  不同的文件描述符也可能指向同一个文件
 *  相同的文件可以被不同的进程打开，也可以在同一个进程被多次打开

## 9.Linux的recv、send、read、write函数区别 ##

Linux的recv、send函数和read、write函数都可以用于`套接字编程`。

**区别：**

1.  recv、send只用于`套接字通信`；
2.  read、write是 **`底层系统调用`**，只要是`文件操作`就都可以用， 比如`套接字操作`，套接字描述符属于是`文件描述符`的一种，套接字本身在Linux上就叫做`套接字文件`。所以read、write函数**不光可以用于套接字编程，也可以用于读取其他各种文件**，比如用于读写普通文件。

# 二.网络请求的本质 #

一个程序的运行，需要3个重要的资源，分别是`CPU，内存，IO`

*  CPU提供了`逻辑能力`或`计算能力`
 *  内存提供了`数据暂存能力`
 *  IO则提供了`与其它数据存储介质(磁盘/数据库/网络/内存)交换数据的能力`。

一个程序它的本质 : 就是**利用CPU和内存，通过IO和其它`存储介质（如硬盘）`进行数据交换（`数据交换指的是读或者写`）**。再延伸一点，**网络请求，它的本质其实就是`网络IO`。** `和我们通过IO读取硬盘或写硬盘是差不多的`，只不过，读或者写的目标`不再是本地机器上的硬盘`，而变成了**某个远程服务器上的某个存储介质（如硬盘）。**

假设在Chrome输入地址，打开了百度的首页，我们想象一下这个过程里，发生什么？

*  Chrome，是一个浏览器软件，通过输入链接的方式打开百度
 *  事实上，做的是`通过本机CPU和内存，调起IO服务`，通过**IO服务去拿到远程服务器上的相应数据**，再通过`本机CPU和内存的处理`，`把拿到的数据放到展示区，展示给用户`。
 *  我们把Chrome称为`客户端`，把远程服务器端称之为`服务器`，把中间的`IO服务`称之为`通道`，就形成了一个**客户端到服务器通过通道连接起来**的体系结构。

# 三.Linux网络编程5种I/O模型 #

## 1.什么是I/O? ##

在操作系统中I/O就是`输入（Input）`和`输出(Output)`的意思， *这个概念和开发语言没有关系，是一个通用的概念*

**操作系统分为2种I/O**

*  网络IO：本质是socket读取
 *  磁盘IO：DMA 操作读取

**一次IO操作的处理过程(`1.发起IO请求 2.IO的实际操作`)**

1.  一次**写操作**分为`2步`：**操作系统将数据从用户空间拷贝到内核空间；从内核空间往网卡写。**
2.  一次**读操作**分为`2步`：**操作系统将数据从网卡拷贝到内核空间；将数据从内核空间拷贝到用户空间**。

当操作系统在把`外部数据`放到`进程缓冲区`的这段时间（`即上述的第2，3步`），如果应用进程是`挂起等待`的就是`同步IO`，反之，就是`异步IO`，也就是`AIO` 。

## 2.阻塞和非阻塞 ##

**阻塞(blocking)和非阻塞(Non-blocking)** 是针对 **`进程在访问数据`** 时，根据 **`IO操作(读写)的就绪状态`来采取的不同方式**，说白了是`一种读取或者写入操作的实现方式`

*  **阻塞** 指用户进程触发IO操作时，需等待操作系统准备数据完成后，才能进行IO操作。在此期间，`读取read或者写入函数write`将一直等待（BIO）`(会被挂起)`
 *  **非阻塞** 指用户进程触发IO操作时，不需等待操作系统准备完数据，`读取或者写入函数会立即返回一个状态值（`NIO），然后用户进程就可以去进行其他的操作，一直等到数据准备完成后，在进行处理`(不会被挂起)`

**————结论:**

> **阻塞/非阻塞：关注`调用者在等待结果返回之前所处的状态`**
> 
>  *  阻塞：指IO操作需要彻底完成后才返回到用户空间，调用结果返回之前，调用者被挂起
>  *  非阻塞(nonblocking)：，指IO操作被调用后立即返回给用户一个`状态值`，无需等到IO操作彻底完成，最终的调用结果返回之前，调用者不会被挂起

## 3.同步和异步 ##

**同步(synchronous)和异步(asynchronous)** 是针对 **`应用程序和内核的交互`** 而言的

*  **同步** 指的是*用户进程触发IO操作*并`等待（BIO）或者主动轮询（NIO）`的去`查看IO操作(读写操作)是否就绪`，`用户进程`必须`等待IO操作处理完成`才能继续往下走
 *  **异步** 是指*用户进程触发IO操作*以后便`开始做自己的事情`，而`当IO操作完成的时候会得到来自操作系统通知 (由操作系统帮你做完IO操作再将结果返回给你)。`
    
    > 任务不需要等待当前调用是否返回，依靠`事件，回调机制`来实现任务调用。

**————结论:**

> **同步/异步：关注的是`消息通信机制`**
> 
>  *  同步(synchronous)：，调用者等待被调用者返回消息，才能继续执行
>  *  异步(asynchronous)：，被调用者通过状态、通知或回调机制主动通知调用者被调用者的运行状态

## 4.以银行取款为例说明同步/异步/阻塞 /非阻塞 ##

*以银行取款为例：*

**同步/异步**

*  **同步 ：** 自己亲自出马持银行卡到银行取钱（使用同步IO时，Java自己处理IO读写）。
 *  **异步 ：** 委托一小弟拿银行卡到银行取钱，然后给你（使用异步IO时，`Java将IO读写委托给OS处理`，需要将`数据缓冲区地址`和`大小`传给OS(银行卡和密码)，然后自己去做别的事情，当 IO 操作结束后会得到通知
 *  **总结: 自己干就是同步，别人干就是异步。**

**阻塞 /非阻塞**

*  **阻塞 ：** 去银行 ATM 取钱，前面有人在排队，那么就要一直等待，直到你取完钱（使用阻塞IO时，Java调用会一直阻塞到读写完成才返回）。
 *  **非阻塞 ：** 柜台取款，取个号，然后坐在椅子上做其它事，等号广播会通知你办理，没到号你就不能去，你可以不断问大堂经理排到了没有，大堂经理如果说还没到你就不能去（使用非阻塞IO时，如果不能读写Java调用会马上返回，当`IO事件分发器会通知可读写时再继续进行读写`，`不断循环`直到读写完成）。
 *  **总结: 我要等着不能做其他事就是阻塞，我不用等可以做其他事就是非阻塞。。**

## 5.I/O模型种类 ##

故事情节为：老李去买火车票，三天后买到一张退票。参演人员（老李，黄牛，售票员，快递员），`往返车站耗费1小时。`

### 5.1. 同步阻塞式I/O模型 ###

>  *  老李去火车站买票，排队三天买到一张退票。
>  *  `耗费`：在车站吃喝拉撒睡 3天，其他事一件没干。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 3]

*  同步阻塞IO模型是最简单的IO模型，用户线程在内核进行IO操作时被阻塞
 *  用户线程通过`系统调用read`发起IO读操作，由`用户空间`转到`内核空间`。**内核**等到数据包到达后，然后 **将接收的数据拷贝到`用户空间`，完成read操作**
 *  用户需要`等待read`将数据读取到`buffer`后，才继续处理接收的数据。**整个IO请求的过程中，用户线程是被阻塞的，这导致用户在发起IO请求时，不能做任何事情，对CPU的资源利用率不够**

> 相关概念
> 
>  *  select系统调用: 对多路同步I/O进行轮询
>  *  recv系统调用: 是从指定地址接收TCP数据流
>  *  recvfrom系统调用：是从指定地址接收UDP数据包
>  *  send系统调用: 是把TCP数据流发给指定地址
>  *  sendto系统调用: 是把UDP数据包发给指定地址
>  *  数据报: `是UDP协议进行网络数据传输的的基本单元`，包含一个报头`（header）和数据本身`，其中报头描述了数据的目的地以及和其它数据之间的关系。数据报不能保证数据传输的可靠性，对于有可能出现的数据丢失情况，需要在程序中做相应的处理

### 5.2. 同步非阻塞式I/O模型 ###

>  *  老李去火车站买票，每隔12小时去火车站问有没有退票，三天后买到一张票。
>  *  `耗费`：往返车站6次，路上6小时，其他时间做了好多事。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 4]

*  用户线程发起IO请求时`立即返回`。但并未读取到任何数据，用户线程需要**不断地发起IO请求，直到数据到达后**，才真正读取到数据，继续执行。即`“轮询”机制`
 *  整个IO请求的过程中，虽然**用户线程每次发起IO请求后可以立即返回**，**但是为了等到数据，仍需要不断地`轮询（polling）`、重复请求，消耗了大量的CPU的资源**。是比较`浪费CPU`的方式，一般`很少直接使用这种模型`，而是在其他IO模型中使用非阻塞IO这一特性

> 相关概念
> 
>  *  Linux - 非阻塞socket编程处理EAGAIN错误
>     
>      *  在linux进行非阻塞的socket接收数据时经常出现`Resource temporarily unavailable，errno代码为11(EAGAIN)`：这表明`在非阻塞模式下调用了阻塞操作，在该操作没有完成`就返回这个错误，这个错误不会破坏socket的同步，不用管它，下次循环接着`recv系统调用`就可以。`对非阻塞socket而言，EAGAIN不是一种错误`。**在Windows上，EAGAIN的名字叫做`EWOULDBLOCK`。**
>  *  recv函数: 用于客户端或服务端从TCP连接的另一端接收数据

### 5.3. I/O多路复用（事件驱动）模型 ###

#### 5.3.1.主体 ####

> 1.**select/poll**
> 
>  *  老李去火车站买票(1次往返)，委托黄牛，然后每隔6小时电话黄牛询问，黄牛三天内买到票，然后老李去火车站交钱领票(2次往返)。
>  *  `耗费`：往返车站2次，路上2小时，黄牛手续费100元，打电话12次
> 
> 2.**epoll**
> 
>  *  老李去火车站买票(1次往返)，委托黄牛，黄牛买到后即通知老李去领，然后老李去火车站交钱领票(2次往返)。
>  *  `耗费`：往返车站2次，路上2小时，黄牛手续费100元，无需打电话

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 5]

**IO多路复用机制**：是指内核一旦发现进程指定的一个或者多个IO操作就绪(`一般是读就绪或者写就绪`），就通知程序进行相应的读写操作。

> `select, poll, epoll 这些系统调用就是是I/O多路复用的具体的实现`，这些调用都是`内核级别`的。本质上都是`同步I/O`，先是阻塞住等待就绪的socket，再是阻塞住将数据从内核态拷贝到用户态。

*  `多个连接共用一个等待机制`，本IO模型会阻塞进程，但是进程是阻塞在`select或者poll`这2个**系统调用**上，而**不是阻塞在`真正的IO操作`上**
 *  用户首先将需要进行IO操作添加到`select`中，然后继续做其他的工作（异步），同时`等待select系统调用返回`。当数据到达时，IO被激活，select函数返回。用户线程正式发起`read`请求，读取数据并继续执行
    
     *  从流程上来看，使用`select函数`进行IO请求**和同步阻塞模型没有太大的区别**，甚至还多了添加`监视IO`，以及`调用select函数`的额外操作，效率更差。并且`阻塞了2次`，但是`第1次阻塞在select`上时，**select可以监控多个IO上是否已有IO操作准备就绪，即可达到在同一个线程内同时处理多个IO请求的目的**。而不像阻塞IO那种，一次只能监控一个IO
        
         *  虽然上述方式`允许单线程内处理多个IO请求`，但是**每个IO请求的过程还是阻塞的（`在select函数上阻塞`），`平均时间`甚至比同步阻塞IO模型还要长**。*如果用户线程`只是注册自己需要的IO请求，然后去做自己的事情，等到数据到来时再进行处理`，* 则可以**提高CPU的利用率**
         *  **`IO多路复用是最常使用的IO模型`**，但是`其异步程度还不够“彻底”`，**因它使用了`会阻塞线程的select系统调用`。因此IO多路复用只能称为异步阻塞IO模型，而非真正的异步IO**

#### 5.3.2.Java的IO多路复用机制 ####

IO多路复用方式 **`允许单线程内处理多个IO请求`，但是`每个IO请求的过程还是阻塞的（在select函数上阻塞）`，平均处理时间甚至比同步阻塞IO模型还要**长。

![展示了非阻塞IO如何让你使用一个selector区处理多个连接.][IO_selector_.]

#### 5.3.3.两种I/O多路复用模式：Reactor和Proactor模式 ####

在高性能的I/O设计中，有两个比较著名的模式`Reactor`和`Proactor`模式，其中 **`Reactor模式`用于同步I/O，而`Proactor模式`运用于异步I/O**。

在这2种模式下的 `事件多路分离器(Event Demultiplexer)`反馈给`程序`的信息是不一样的：

1.  Reactor模式下说明你可以进行读写操作了。
2.  Proactor模式下说明已经完成读写操作了，具体内容在给定缓冲区中，可以对这些内容进行其他操作了。

**Reactor关注的是I/O操作的`就绪事件`，而Proactor关注的是I/O操作的`完成事件`**

一般地,I/O多路复用机制都依赖于一个 `事件多路分离器(Event Demultiplexer)`。分离器对象可将来自事件源的I/O事件分离出来，并分发到对应的`read/write事件处理器(Event Handler)`。

*  **Reactor模式**中：**事件多路分离器负责`等待文件描述符 或 socket`读写操作准备就绪**，然后将`就绪事件`传递给对应的`处理器`，最后**由处理器负责完成实际的读写工作**。
 *  **Proactor模式**中：**事件处理器或者兼任处理器的事件分离器，只负责发起异步读写操作。`IO操作本身由操作系统来完成`**。
    
    > 传递给操作系统的参数需要包括`用户定义的数据缓冲区地址 和 数据大小`，操作系统才能从中得到`写出操作`所需数据，或写入`从socket读到的数据`。**事件分离器捕获`IO操作完成事件`，然后将事件传递给对应`处理器`。**
    
     *  比如，在windows上，处理器发起一个异步IO操作，再由事件分离器`等待IO完成事件`。典**型的异步模式实现，都`建立在操作系统支持异步API的基础之上`，我们将这种实现称为“系统级”异步或“真”异步，因为应用程序完全依赖操作系统执行真正的IO工作。**

**Reactor和Proactor模式的主要区别**

*  **就是`真正的读取和写入操作是由谁来完成的`**
    
     *  **Reactor模式：应用程序需要`自己`读取或者写入数据**
     *  **Proactor模式：应用程序`不需要`进行实际的读写过程，它只需要从缓存区读取或者写入即可，操作系统会读取缓存区或者写入缓存区到真正的IO设备.**

### 5.4. 信号驱动式I/O(SIGIO) ###

>  *  老李去火车站买票(1次往返)，给售票员留下电话，有票后，售票员电话通知老李，然后老李去火车站交钱领票(2次往返)。
>  *  耗费：往返车站2次，路上2小时，免黄牛费100元，无需打电话

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 6]

*  信号驱动IO：**signal-driven I/O**
 *  用户进程可以通过`sigaction系统调用`注册一个`信号处理程序`，然后**主程序可以继续向下执行**，**当有IO操作准备就绪时，由`内核通知`触发一个`SIGIO信号处理程序`执行，然后将用户进程所需要的数据从`内核空间`拷贝到`用户空间`**
    
     *  此模型的优势在于 **`等待数据报到达期间进程不被阻塞`。用户主程序可以继续执行，只要等待来自`信号处理函数的通知`**
 *  `该模型并不常用`

> 相关概念
> 
>  *  sigaction系统调用：设置对指定信号的处理方法 (用于是`检查或修改`与指定`信号`相关联的处理动作（可同时两种操作）。
>  *  内核处理信号:SIGIO 表示一个`异步IO事件`

### 5.5. 异步I/O模型 ###

>  *  老李去火车站买票，给售票员留下电话，有票后，售票员电话通知老李并快递送票上门。
>  *  `耗费`：往返车站1次，路上1小时，免黄牛费100元，无需打电话

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 7]  
异步IO与信号驱动IO最主要的区别是

*  **信号驱动IO** 是由`内核通知何时可以进行IO操作`，而**异步IO**则是由`内核告诉用户线程IO操作何时完成`。
 *  **信号驱动IO** 当内核通知触发信号处理程序时，`信号处理程序还需要阻塞在从内核空间缓冲区 复制数据到 用户空间缓冲区 这个阶段`，而**异步IO** 直接是在第二个阶段完成后，`内核直接通知用户线程可以进行后续操作`了

相比于`IO多路复用模型`，**异步IO并不十分常用**，不少高性能并发服务程序使用 **“`IO多路复用模型+多线程任务处理`”** 的架构基本可以满足需求。*目前操作系统对异步IO的支持不是特别完善*，更多的是**采用`IO多路复用模型模拟异步IO的方式`(IO事件触发时不直接通知用户线程，而是将数据读写完毕后放到用户指定的缓冲区中)**

> 相关概念
> 
>  *  aio\_read、和aio\_write `异步aio系统函数`表示异步读操作、异步写操作

### 5.6.I/O模型的比较 ###

*  1同2的区别是：自己轮询
 *  2同3的区别是：委托黄牛
 *  3同4的区别是：电话代替黄牛
 *  4同5的区别是：电话通知是自取还是送票上门
    
     *  根据上述5种IO模型，`前4种模型-阻塞IO、非阻塞IO、IO复用、信号驱动IO都是同步I/O模型`，因为其中真正的I/O操作`（recvfrom）`将阻塞进程，**在将内核数据copy到用户空间时都是阻塞的。**

常用的是IO多路复用型，比如Nginx

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 8]

## 6.总结 ##

**阻塞、非阻塞、多路IO复用，都是同步IO**，`异步必定是非阻塞的`，所以不存在异步阻塞和异步非阻塞的说法。

*  真正的异步IO需要`CPU的深度参与`。换句话说，**只有用户线程在操作IO的时候根本不去考虑IO的执行全部都交给CPU去完成，而自己只等待一个完成信号的时候，才是真正的异步IO。**  
    所以，`拉一个子线程去轮询、去死循环，或者使用select、poll、epool，都不是异步。`

## 四.从Java语言层面理解BIO，NIO，AIO ##

[【Java基础】从Java语言层面理解BIO，NIO，AIO(二)  
][Java_Java_BIO_NIO_AIO_]

--------------------

参考  
[五种IO模型和三种实现方式][IO]  
[IO多路复用机制详解][IO 1]  
[聊聊Linux 五种IO模型][Linux _IO]  
[聊聊IO多路复用之select、poll、epoll详解][IO_select_poll_epoll]

--------------------

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210605113910751.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20210604173136634.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70#pic_center
[Link 1]: https://www.cnblogs.com/Allen-rg/p/7171105.html
[Linux]: https://www.cnblogs.com/shijiaqi1066/p/5749030.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210609144132472.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210609144205826.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210609104505771.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210609105551940.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210609104936875.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[IO_selector_.]: https://img-blog.csdnimg.cn/20210604143540662.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210609105148152.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20210609105230190.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20210609105815213.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[Java_Java_BIO_NIO_AIO_]: https://blog.csdn.net/qq877728715/article/details/106781128
[IO]: https://www.cnblogs.com/Otiger/p/14748569.html
[IO 1]: https://www.cnblogs.com/yanguhung/p/10145755.html
[Linux _IO]: https://www.jianshu.com/p/486b0965c296
[IO_select_poll_epoll]: https://www.jianshu.com/p/dfd940e7fca2