【Java多线程】高并发修炼基础之高并发必须了解的概念

今天药忘吃喽~ 2022-09-06 13:29 303阅读 0赞

### 文章目录 ###

*   *  前言
     *  1.高并发
     *  2.CPU与超线程技术
     *   *  2.1.Windows下的CPU与超线程
         *  2.2.Linux下查看物理CPU个数、CPU核数及逻辑CPU个数
         *  2.3.Linux下确认CPU是否开启超线程
     *  3.同步和异步
     *  4.临界区(临界值)
     *  5.线程状态
     *  6.上下文切换
     *   *  6.1.CPU上下文切换
         *  6.2.线程上下文切换
         *  6.3.引起线程上下文切换的因素
         *  6.4.线程上下文切换优化手段
     *  7.并发和并行
     *   *  7.1.并行与并发的浅析
     *  8.单核cpu和多核cpu
     *   *  8.1.单核cpu与多核cpu的区别
         *  8.2.单核多线程与多核多线程
         *  8.3. 线程越多越好吗？什么时候才有必要用多线程？
     *  9.线程调度
     *   *  9.1.抢占式线程调度和非抢占式线程调度
         *  9.2种线程调度的区别
         *  9.3常见线程调度算法
     *  10.线程的睡眠，挂起，和阻塞
     *   *  10.1.简述
         *  10.2.具体操作
     *  11.阻塞和非阻塞
     *  12.线程stop()、suspend()、resume() 弃用的原因
     *   *  12.1.stop()
         *  12.2.suspend() 和 resume() 方法
     *  13.死锁、饥饿、活锁
     *  14.并发级别

## 前言 ##

[【Java多线程】多线程与CPU、内存和I/O][Java_CPU_I_O]  
[【Java多线程】并发编程笔记(持续更新)][Java]  
[【Java基础】多线程从入门到掌握][Java 1]  
[ 【Java多线程】了解Java锁机制 ][_Java_Java_]  
[ 【Java多线程】了解线程的锁池和等待池概念 ][_Java_]

## 1.高并发 ##

*  它是互联网分布式系统架构设计中必须考虑的因素之一，通常是指 **`系统能够同时并行化处理海量请求`**

## 2.CPU与超线程技术 ##

### 2.1.Windows下的CPU与超线程 ###

**查看电脑核数**

*  `右键计算机->设备管理器->处理器`（如下图，按这种方式来看我的电脑为`12核`，其实并不是这样，**12核并不是Cpu物理个数，而是逻辑个数**，也可以理解为是`线程数，即我的电脑为12线程`）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70]  
**查看电脑线程数**

*  **启动任务管理器->性能->CPU->右键将图像更改为选择逻辑处理器**（如下图，有几个框即为几线程，我的电脑为12线程，`这种方式查看线程是可以的，但用这种方式查看核数是错误的`）

> ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_20_color_FFFFFF_t_70_g_se_x_16]![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_13_color_FFFFFF_t_70_g_se_x_16]  
> 所谓的两路cpu就是指 主板上面有2个CPU插座，可以插2个cpu，四路也是这个道理，我的电脑是属于一路cpu
> 
>  *  两路双核四线程CPU，即主板上面有2个CPU插座，可以插2个cpu，四核是每个cpu有4个核心，然后使用超线程技术，让一个处理器通过技术手段模拟成两个处理器,就是 `2*2*4=16`个逻辑处理器

然而真的是这样吗？我买的电脑官方提供的配置信息为**6核12线程**，难道设备商好**心多给了6核**？**事实是设备商采用了`超线程技术`。**

*  超线程技术是`英特尔在奔腾四代在奔腾处理器上广泛采用的一个技术`，**让一个处理器通过技术手段模拟成两个处理器，从而提高多任务的协调处理性能。也由于这个原因，所以`单核心支持超线程技术的处理器在Windows操作系统下均会被识别成两个处理器`。**

### 2.2.Linux下查看物理CPU个数、CPU核数及逻辑CPU个数 ###

*  **CPU总核数 = 物理CPU个数 \* 每颗物理CPU的核数**
 *  **总逻辑CPU数 = 物理CPU个数 \* 每颗物理CPU的核数 \* 超线程数**

这些都代表什么，那就请看CPU架构

**多个物理CPU，CPU通过总线进行通信，效率比较低，如下：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 1]

**多核CPU，不同的核通过L2 cache进行通信，存储和外设通过总线与CPU通信，如下：**

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

**多核超线程,每个核有两个逻辑的处理单元，两个核共同分享一个核的资源，如下：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 3]  
**从上面执行的结果来看，证明我的电脑有物理cpu1个，每个物理cpu上面有4个核心，每个核有2个超线程，根据公式得出`总逻辑CPU数`为： `1 * 4 * 2 =8`核**

### 2.3.Linux下确认CPU是否开启超线程 ###

*  [Linux下确认CPU是否开启超线程][Linux_CPU]

## 3.同步和异步 ##

*  **浏览器请求同步和异步**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 4]
    
     *  同步：发送一个请求，等待返回，然后再发送下一个请求。
        
         *  提交请求 -> 等待服务器处理 -> 处理完返回，此期间客户端浏览器不能干任何事
     *  异步：发送一个请求，不等待返回，随时可以再发送下一个请求，当有返回时通过回调函数的形式处理请求。
        
         *  提交请求 -> 服务器处理（这时浏览器仍然可以作其他事情）-> 处理完毕(回调函数)

**从上图可以知道，同步一步一步的执行着，在异步中，当一个异步过程调用发出后，调用者不能立即得到结果，实际上会开启一个线程执行这部分内容，这个线程处理完了之后，`通过状态，通知和回调等机制来通知调用者来处理`。**

*  **更深层次：IO层面上的同步和异步**
    
     *  [【Java基础】从网络层面理解BIO，NIO，AIO(一)][Java_BIO_NIO_AIO]

## 4.临界区(临界值) ##

*  临界区表示一种 **`可以被多个线程使用的公共资源或者说是共享数据`**，**但是每一次只能有`一个线程使用它`，一旦临界区资源`被占用`，其他线程想要使用这个资源，就必须进入`等待阻塞`状态。**

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

*  **临界区是我们开发中经常要加锁的地方，如 `synchronized 关键字，或是 Lock接口。`**

## 5.线程状态 ##

首先了解一下什么是线程的状态，线程状态就是当线程被创建（new），并且启动（start）后，它不是一启动就进入了执行状态（run），也不是一直都处于执行状态。

这里说一下Java 的`Thread类里面有一个State方法`，这个方法里面涵盖了6种线程的状态，如下：

public enum State { 
        // 尚未启动的线程的线程状态。
        NEW,
        // 可运行线程的线程状态。
        RUNNABLE,
        // 线程的线程状态被阻塞，等待监视器锁定。
        BLOCKED,
        // 等待线程的线程状态。
        WAITING,
        // 具有指定等待时间的等待线程的线程状态。
        TIMED_WAITING,
        // 终止线程的线程状态。
        TERMINATED;
    }

## 6.上下文切换 ##

### 6.1.CPU上下文切换 ###

**Linux 是一个多任务操作系统，它支持远大于 CPU 数量的任务同时运行。但任务实际上并不是真的在同时运行，而是因为系统在很短的时间内，将 CPU时间片 轮流分配给它们，造成多任务同时运行的错觉。**

*  而在每个任务运行前，CPU 都需要知道`任务从哪里加载、又从哪里开始运行`，也就是说，`需要系统事先帮它设置好CPU寄存器和程序计数器`

**什么是 CPU 上下文**

*  **CPU 寄存器和程序计数器就是 CPU 上下文，因为它们都是 CPU 在运行任何任务前，必须的依赖环境。**
    
     *  `cpu寄存器`，`CPU 内置的容量小、但速度极快的内存`。
    
    > 可用来暂存指令，数据等处理对象，可以将其看做是内存的一种。根据种类的不同，一个CPU内部会有20~100个寄存器。
    
     *  `程序计数器（PC）`，又叫`“指令计数器”`, 是用来`存储 CPU 正在执行的指令位置、或者即将执行的下一条指令位置`。
    
    > 百度解释：在CPU控制部件中的`程序计数器（PC）`的功能是用于`存放指令的地址`。程序执行时，PC的初值为程序第一条指令的地址，在顺序执行程序时，控制器首先按程序计数器所指出的指令地址从内存中取出一条指令，然后分析和执行该指令，同时将PC的值加1指向下一条要执行的指令。此后经过分析指令，执行指令。完成第一条指令的执行，而后根据PC取出第二条指令的地址，如此循环，执行每一条指令。
    
     *  [浅谈CPU — （CPU结构【寄存器】）][CPU _ _CPU]

**什么是 CPU 上下文切换**

*  就是先把**前一个任务的 CPU 上下文（也就是CPU 寄存器和程序计数器）保存起来**，然后**加载新任务的上下文到这些寄存器和程序计数器，最后再跳转到程序计数器所指的新位置，运行新任务。**
    
     *  这些保存下来的上下文，会存储在系统内核中，并在任务重新调度执行时再次加载进来。这样就能保证任务原来的状态不受影响，让任务看起来还是连续运行。

**CPU 上下文切换在上对于线程的操作：**

1.  `挂起`一个线程，将这个线程在 CPU 中的状态`（上下文）`存储于内存中的某处，
2.  在内存中搜索下一个线程的上下文并将其在 `CPU 的寄存器`中恢复
3.  跳转到`程序计数器`所指向的位置（即跳转到进程被中断时的代码行），以`恢复`该线程。

### 6.2.线程上下文切换 ###

*  **线程上下文切换，即：同一进程中的多个线程之间的切换**
 *  也就是CPU通过 **`时间片分配算法来循环切换执行任务`**，**当前任务执行一个时间片后会`切换`到下一个任务**。并且在`切换前会保存上一个任务的状态`，`当切换回上一个任务时可以继续加载该任务的状态`，**从任务保存到再加载的过程就是一次`上下文切换`。**
    
     *  每个线程执行的时间片非常短，CPU通过不停地切换线程执行。在表面上看起来就好像`同时执行多个线程`。
    
    > 注意： 进程内的线程会共享相同的虚拟内存和全局变量等资源。这些资源在上下文切换时是不需要保存的。 而线程的私有数据，比如程序计数器,寄存器和栈等，在上下文切换时才需要保存。

### 6.3.引起线程上下文切换的因素 ###

*  `当前执行线程的时间片用完`，CPU正常调度下一个线程
 *  `中断处理`，在中断处理中，其他程序”打断”了当前正在运行的程序。当CPU接收到中断请求时，会在正在运行的程序和发起中断请求的程序之间进行一次上下文切换。中断分为硬件中断和软件中断，软件中断包括因为IO阻塞、未抢到资源或者用户代码等原因，线程被挂起。
 *  `用户态切换`，对于一些操作系统，当进行用户态切换时也会进行一次上下文切换，虽然这不是必须的。
 *  `多个线程抢占锁资源`，CPU会在不同线程之间来回切换，每个线程都有相应的处理时间片，CPU在两个时间片的间隔中进行上下文切换

### 6.4.线程上下文切换优化手段 ###

*  `无锁并发编程`，多线程处理数据时，可以用一些办法来避免使用锁，如`ConcurrentHashMap`，将数据的ID按照Hash取模分段，不同的线程处理不同段的数据
 *  `CAS算法`，Java的`Atomic包`使用CAS算法来更新数据，而不需要加锁
 *  `使用最少线程`
 *  `协程`：即单线程里实现多任务的调度，并在单线程里维持多个任务间的切换
    
    > 协程，英文Coroutines，是一种`比线程更加轻量级的存在`。正如一个进程可以拥有多个线程一样，`一个线程也可以拥有多个协程`。
    > 
    >  *  协程不被操作系统内核所管理，而完全是由程序所控制（也就是在用户态执行）。
    >  *  减少线程的上下文切换次数，减少线程上下文切换带来的资源消耗。
    >  *  `Java的原生语法中并没有实现协程`（某些开源框架实现了协程，但是很少被使用）

## 7.并发和并行 ##

### 7.1.并行与并发的浅析 ###

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

*  **`单核CPU(单核处理器)上`，`只可能存在并发`而不可能存在并行。**
 *  **`并行在”多核处理器(多核CPU)”系统中存在，而并发可以在 “单核处理器” 和 ”多核处理器”系统中都存在`**，并发能够在单处理器系统中存在是因为 “并发是并行的假象”，**`并行要求程序能够同时执行多个操作`**，而 **`并发只是要求程序假装同时执行多个操作`（每个小时间片执行一个操作，多个操作快速切换执行)**
 *  **并发是`“伪并行”`，看似并行，而实际上还是一个`CPU(单处理器)`执行一切任务，只是`切换的太快`，我们没法察觉罢了。**

## 8.单核cpu和多核cpu ##

### 8.1.单核cpu与多核cpu的区别 ###

单核cpu和多核心cpu最大的区别就是`CPU处理器中的核心数量(物理核心)，这里的核心又可以称为 "内核"`，不同的内核数量，`直接影响着CPU执行任务时的速度和效率`。而**cpu内核又分为物理内核与逻辑内核**

1.  `单核cpu`指的是一枚处理器中**一个物理内核**
2.  `多核cpu`是指一枚处理器中集成**多个物理内核**，而双核又分为`双核双线程，双核四线程，四核八线程，四核四线程`。
    
    >  *  双核四线程是指两个物理内核或四个逻辑内核
    >  *  四核八线程是指四个物核内核八个逻辑内核。。。。
3.  我们可以从`数量`上来理解多核的含义。简单来说，`双核就是CPU中有两个核心`，就是**将两个物理核心集成进一个CPU之中**。**四核指的是CPU中的核心数量由`两个双核`组成，整个CPU之中有`四个运算核心`。**
4.  **目前市场上虽然已经出现了八核甚至核心更多的处理器，但是由于`功耗方面`的原因，更受人们欢迎的还是`双核和四核处理器`。**

### 8.2.单核多线程与多核多线程 ###

**1.单核cpu多线程**：指的是CPU只有一个内核`轮流执行`多个线程，通过给每个线程分配`CPU时间片`来实现，只是因为这个时间片非常短（几十毫秒），所以在用户角度上感觉是多个线程同时执行。也叫`并发执行`

>  *  单核CPU上运行的多线程程序, 同一时间只能一个线程在跑, `系统给每个线程分配时间片快速切换线程(并发)执行`,看起来像是同时跑, 但实际上是每个线程跑一点点就`切换`到其它线程继续跑，效率不会有提高的，`切换线程反倒会增加开销`。
>  *  在单核CPU的时候，不推荐使用多线程。`并发执行任务`，在没有获取到cpu时间片是，通常是有线程要处于`等待阻塞状态`。

**2.多核cpu多线程**：指的是CPU有多个内核，系统将线程分配给不同的核心处理，相当于`多个线程并行的在执行`，即`线程在不同的内核中是并行的，但在同一核心的线程还是并发执行的`

**3.CPU的多核和应用程序的多线程的关系**

1.  `多核就是CPU有多个核心，系统同时可以运行多个线程`，比如双核可以同时执行1个线程。单核儿只能一次执行1个线程
2.  `多核可以减少线程间上下文切换的频率 以提高性能`。
3.  **多核也要用多线程才能发挥优势。多线程要在多核上才能真正发挥出真正的优势**。

**4.规律**

1.  单CPU中进程只能是并发，多CPU计算机中进程可以并行也可以并发。
2.  `单CPU单核中线程只能并发，单CPU多核中线程可以并行也可以并发。`

### 8.3. 线程越多越好吗？什么时候才有必要用多线程？ ###

**线程必然不是越多越好，`线程上下文切换`也是要开销的，当你增加一个线程的时候，`增加的额外开销要小于该线程能够消除的阻塞时间`，这才叫物有所值。`只有合理设置线程数目既可以最大化利用CPU，又可以减少线程切换的开销。`**

这要分4种情况讨论：

1.  **单核CPU—计算密集型任务**：此时的任务已经把CPU资源100%消耗了，就没必要也不可能使用多线程来提高计算效率了；相反，如果要做人机交互，最好还是要用多线程，避免用户没法对计算机进行操作。
2.  **多核CPU—计算密集型任务**：此时要尽量使用多线程，可以提高任务执行效率，例如加密解密，数据压缩解压缩（视频、音频、普通数据），否则只能使一个核心满载，而其他核心闲置。
3.  **单核CPU—IO密集型任务**：使用多线程还是为了避免阻塞，人机交互方便，
4.  **多核CPU—IO密集型任务**：这就更不用说了，跟单核时候原因一样，避免阻塞。

## 9.线程调度 ##

### 9.1.抢占式线程调度和非抢占式线程调度 ###

**什么是线程调度?**

*  **线程调度一般指的是`系统为线程分配CPU使用权`的过程，这个过程会产生`上下文切换：`即操作系统的`CPU利用时间片轮转的方式`给每个线程分配一定的执行时间，然后把当前线程`状态`保存下来，接着加载下一线程的状态并执行，它是一个`状态保存与加载的过程`。**

### 9.2种线程调度的区别 ###

1.  **抢占式线程调度**：**指的是线程的CPU执行时间分配、线程的切换都由操作系统控制**。*系统控制：指的是在系统某种线程调度机制下，可能每个线程都分同样的cpu时间片，也可能是有的线程cpu时间片较长，甚至可能有的线程得不到cpu时间片*。这种机制下**一个线程的堵塞不会导致整个进程堵塞。缺点是需要进行线程同步**
    
    >  *  **何为抢？** 当任务权重大或者优先级高，自然而然“抢”到运行的机会。
    >  *  **何为占？** 任务抢到运行行时间（即CPU时间）后，在这个时间内，系统只运行该任务，直到下一次系统利用算法重新分配任务的运行时间之前。
2.  **协同式线程调度(同步调度)**：指**某一线程执行完后`主动通知`操作系统`切换`到另一线程上执行**，这种模式就像接力赛一样，一个人跑完自己的路程就把接力棒交接给下一个人，下个人继续往下跑。`线程的CPU执行时间由线程本身控制，线程切换可以预知，不存在多线程同步问题`，但它有一个致命弱点：**如果一个线程编写有问题，运行到一半就一直堵塞，那么可能导致整个系统崩溃。**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 7]

*  **左边为抢占式线程调度**：如3条线程需要运行，CPU运行的路径是在**线程一**运行一个时间片后强制切换到**线程二**运行一个时间片，然后切到**线程三**，再回到线程一，如此循环直至三条线程都执行完。
 *  **右为协同式线程调度**：它会先将**线程一**执行完，线程一再**通知线程二**执行，线程二再**通知线程三**，直到线程三执行完。

**二者的比较**：抢占式线程调度不易发生饥饿现象，不易因为一个线程的问题而影响整个进程的执行，但是其`“频繁上下文切换”会造成系统资源的浪费`。协作式的线程调度**很容易因为一个线程的问题导致整个进程中其它线程饥饿。**

**Java使用的是哪种线程调度模式？**

*  此问题涉及到JVM的实现，JVM规范中规定：**每个线程都有优先级，且优先级越高越优先执行，但优先级高并不代表能独自占用执行时间片，可能是优先级高得到越多的执行时间片，反之，优先级低的分到的执行时间少但不会分配不到执行时间。**
 *  **JVM的规范没有严格地给调度策略定义，一般Java使用的线程调度是`抢占式调度`**，**在JVM中体现为**：`可运行池(锁池)中优先级高的线程优先分配CPU时间片，如果可运行池(锁池)中线程优先级一样则随机选择线程分配`，但要注意的是*实际上一个绝对时间点只有一个线程在运行（这里是相对于`一个CPU`来说），直到此线程进入非可运行状态或另一个具有更高优先级的线程进入可运行线程池，才会使之让出CPU的使用权。*

### 9.3常见线程调度算法 ###

**1.先来先服务调度算法(FCFS）**

*  最简单的调度算法，也是在单核CPU系统中最常见的 非抢占式的**先来先服务算法**(`First Come First Severd FCFS`)
    
     *  即每次取就绪队列最先进入队列的任务，然后一直运行，直到任务结束或被阻塞，才会继续从队列中选择一个任务接着运行  
        ![在这里插入图片描述][f7f597664110493ab835ee3aeb66895d.png]

**2. 最短作业优先调度算法(Shortest Job First SJF)**

*  它会**优先选择运行时间最短的任务来运行**，这有助于提高系统的吞吐量
    
     *  这显然对长任务不不合理，很容易造成一种极端现象。比如：一个长任务在就绪队列等待运行，而这个就绪队列有非常多的短任务，那么就会是的长任务不断往后推，致使长任务长期不会被运行。

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

**3.时间片轮转调度算法(Roud Robin ，RR)**： 最古老、最简单、最公平 且使用最广的算法法 ，即: **每个任务分配一个时间段，称为时间片(Quantum)，即允许该任务在该时间段中运行**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 9]

**4.最高优先级优先调度算法**: **从就绪队列中选择最高优先级的任务进行运行，这称为最高优先级调度算法(Highest Proority First , hpf)**

**导致这六种线程状态发生的条件**

**New – 新建**

*  线程对象已经创建，不过还没有被启动（`还没有调用start方法`）

**Runnable – 可运行(就绪状态) 或者 运行**

*  处于可运行状态的线程正在Java虚拟机中执行，或者正在等待操作系统的调度。

> Runnable分为 可运行状态 和 运行状态 2种情况
> 
> 1.  **可运行状态**：当线程`有资格运行`，但`线程调度程序还没有把它选定为运行线程时线程所处的状态`。**当start()方法调用时，线程首先进入可运行状态**。或者`线程从阻塞、等待或睡眠状态回来后，也返回到可运行状态`。
> 2.  **运行状态**：线程调度程序`从可运行池根据中选择一个线程作为当前线程时线程所处的状态`。(具体怎么选择看线程调度算法)。**这是线程进入运行状态的唯一方式。**

**Blocked – 锁阻塞**

*  当一个线程想获取一个`对象锁`，不过该`对象锁`被其它的线程`占用时`，该线程就会进入`阻塞状态`；当该线程获取到锁时，该线程将会变成 **`可运行的状态`.**

**Waiting – 无限等待**

*  当一个线程在`等待另一个线程执行一个（唤醒）动作时`，该线程就会进入**无限等待状态**。进入这个状态后是`不能自动唤醒的`，要等待另一个线程调用`notify()方法或notifyall()方法`才能够被唤醒，**等待结束后变为`可运行状态`。**

**Timed\_Waiting – 计时等待**

*  类似于无限等待状态，有几个方法有超时参数，如：Thread.sleep、Object.wait方法。调用这些方法，进入`计时等待状态`。**计时等待状态将会一直保持到超时期满 或者 接收到唤醒通知。**，**计时等待结束后变为`可运行状态`。**

> 阻塞(Blocked)/无限等待(Waiting)/计时等待(Timed\_Waiting)：实际上这个三状态组合为一种，其共同点是：**如果满足某种条件，他们都可能变为可运行状态(Runnable)。**

**terminated – 被终止**

*  因为`run方法的正常退出`而死亡。
 *  因为没有捕获的`异常`，终止了run方法而死亡。

## 10.线程的睡眠，挂起，和阻塞 ##

### 10.1.简述 ###

下图是使用`时间片轮转法`的**线程**的状态转换。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 10]

*  `睡眠和挂起是控制线程的2种行为，阻塞则是线程一种状态`。
 *  `挂起和睡眠是主动的`，**挂起恢复**需要`主动解除`，**睡眠恢复**则是`自动完成`的，因为睡眠有一个睡眠时间，睡眠时间到则恢复到就绪状态。而**阻塞**是`被动`的，`是在等待某种事件或者资源`，一旦获得所需资源或者事件信息就自动恢复到就绪状态。

系统中**睡眠、阻塞、挂起**都是对于`线程`来说的。**对线程的控制就好比你控制了一个雇工为你干活**

*  **挂起线程**：就是你对主动对雇工说：**“你睡觉去吧，用着你的时候我主动去叫你，然后接着干活”`->雇主主动唤醒雇工`**。
 *  **线程睡眠**：就是你主动对雇工说：**“你睡觉去吧，某时某刻过来报到，然后接着干活”`->雇工主动醒来干活`**。
 *  **线程阻塞**：就是，你突然发现，你的雇工不知道在什么时候没经过你允许，自己睡觉呢，但是你不能怪雇工，肯定你这个雇主没注意，本来你让雇工扫地，结果扫帚被偷了或被邻居家借去了，你又没让雇工继续干别的活，他就只好睡觉了。但是雇工一旦发现扫帚回来了，他就会自己去干活的 **`->雇工等待获取到某种条件后主动醒来干活`**。

### 10.2.具体操作 ###

**线程睡眠方法(行为)**

引发：thread.Join()或 Thread.Sleep()
    解除：thread.Interrupt()//注意：thread.Interrupt()会导致线程在阻塞处抛出异常，注意捕捉。

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

**线程挂起方法(行为)**

引发：thread.suspend()  //挂起线程 
    解除：thread.resume()   //恢复线程 
    //它们用于临时挂起和重启某个线程，这2个方法已经被废弃了，因为它们是不安全的，不稳定的
    //如果在不合适的时候挂起线程（比如，锁定共享资源时），此时便可能会发生死锁——其他线程在等待该线程释放锁，但该线程却被挂起了，便会发生死锁。另外，在长时间计算期间挂起线程也可能导致问题。

*  上面两个方法是`配套使用`，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须调用其对应的resume()方法，才能使得线程重新进入`就绪状态`
 *  **和wait() 和 notify() 方法的区别**：`suspend()及其它所有方法在线程阻塞时都不会释放占用的锁（如果占用了的话），而wait() 和 notify() 这一对方法则相反`。

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

**进入线程阻塞状态方法(线程状态)**

*  阻塞状态BLOCKED是线程因为某种原因`放弃CPU使用权`，暂时停止运行。

> **阻塞的情况分3种**：

1.  **等待阻塞**：运行的线程执行`wait()`方法，该线程会`释放占用的锁`，JVM会把该线程放入[等待池][_Java_]中。进入这个状态后是不能自动唤醒的，需要其他线程调用`对应notify()或者notifyAll()`方法才能被唤醒。
2.  **同步阻塞**：运行的线程在获取对象的`同步锁`时，若`该同步锁被别的线程占用`，则JVM会把该线程放入[锁池][_Java_]中。
3.  **其他阻塞**：运行的线程执行`sleep()或join()方`法，或者发出了`I/O请求时，`JVM会把该线程置为阻塞状态。`当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时`，线程重新转入`就绪状态`。

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

*  **Thread.Sleep()** ：指定时间内使线程进入`阻塞状态`，但`不会释放"占用的锁"`，通过`interrupt()可以中断休眠`（sleep 让线程从 【running】 → 【阻塞状态】`睡眠时间结束/调用interrupt()`→ 【runnable】）
 *  **thread.yield()**：`不使线程阻塞`，暂停线程运行,使线程`重新进入就绪状态(可运行状态)`，重新竞争CPU时间片，但`不会释放"占用的锁"`，只能使同优先级或更高优先级的线程有执行的机会
 *  **thread.Join()** ：使当前线程进入`阻塞状态`，`等待调用join方法的线程结束`再继续执行。
 *  **thread.wait()**：`必须在synchronized中使用,` 使线程进入`阻塞状态`，会`释放掉它所"占用的锁"`，需要调用线程的`notify()或notifyAll()方法` ，才能进入就绪状态(wait 让线程从 【running】 → 【等待队列】调用notify()/notifyAll() → 【锁池】 → 【runnable】)
 *  **thread.suspend()**：挂起线程, 使线程进入`阻塞状态`，但`不会释放"占用的锁"`, 需要调用线程的`resume()`，才能进入就绪状态
 *  **LockSupport.park()**：使线程进入阻塞状态，但`不会释放"占用的锁"`, 需要调用LockSupport.unpark(线程实例)，才能进入就绪状态

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

**wait和sleep的区别**

> 相同点：
> 
>  *  都可以使线程进入阻塞状态，并且设置阻塞时间时间
>  *  `都可以通过interrupt()方法打断线程的阻塞状态`，但是线程会抛出`InterruptedException`
>  *  需要注意的是，`InterruptedException是线程自己从内部抛出的`，并不是interrupt()方法抛出的。，`如果该线程正在执行普通代码调用 interrupt()时`，该线程不会抛出InterruptedException。**`但是，一旦该线程进入到 wait()/sleep()/join()后(组塞状态)调用interrupt()，就会立刻抛出InterruptedException`。**

> 不同点：
> 
>  *  sleep(),yield()是Thread类的方法 、wait()和notify()、notifyAll()是Object类的方法
>  *  . wait，notify和notifyAll只能在`同步方法`或者`同步代码块`里面使用, 否则会在程序运行时抛出`java.lang.IllegalMonitorStateException`异常。，而**sleep可以在任何地方使用**
>  *  **sleep必须捕获异常**，而wait，notify和notifyAll不需要捕获异常
>  *  **最大的不同：sleep()睡眠时，不会释放占用的锁，仍然占有该锁；`而wait()睡眠时，会释放占用的锁，使得其他线程可以进入持有一把锁的同步代码块，或者同步方法` 。**

## 11.阻塞和非阻塞 ##

*  **线程的阻塞和非阻塞**
    
     *  阻塞(Blocking)和非阻塞(Non-Blocking)通常用来形容`多线程间的相互影响`，
     *  比如一个线程占用`临界区`资源，那么其他所有需要这个资源的线程就必须在这个`临界区外`中进行等待，`等待会导致线程挂起(线程主动阻塞,等待锁被释放)，这种情况就是阻塞`。如**果占用锁的线程一直不愿意释放锁，那么其它所有阻塞在这个临界区上的线程都不能工作。**
     *  非阻塞(Non-Blocking)允许多个线程同时进入临界区。
 *  **更深层次：IO层面上的阻塞和非阻塞**
    
     *  [【Java基础】从网络层面理解BIO，NIO，AIO(一)][Java_BIO_NIO_AIO]

## 12.线程stop()、suspend()、resume() 弃用的原因 ##

### 12.1.stop() ###

*  stop() 方法可以停止一个正在运行的线程，`它会立即释放CPU资源和释放锁`，是不安全的，可能会导致被保护数据不同步和一些`清理性的工作得不到完成`，如：关闭文件，关闭连接等，**这个方法在Java中`已废弃`。**
    
    1.  调用 stop() 方法时，会抛出`java.lang.ThreadDeath 错误`，`该错误不需要显式的捕获`。
    2.  **方法 stop() 已废弃**，因为如果强制让线程停止则可能会**使一些清理性的工作得不到完成**。*如：关闭文件，关闭连接等*。另外一种情况就是**对锁定的对象进行了“解锁”，导致被保护数据得不到同步的处理，出现数据不一致的问题。**（`调用 stop() 方法会释放锁，使线程由执行状态转为阻塞状态`）

/** * 同步操作类 */
    class SynchronizedObject { 
        /** *用户名 */
        private String username = "admin";
        /** *密码 */
        private String password = "123456";
    
        public String getUsername() {  return username; }
        public void setUsername(String username) {  this.username = username; }
    
        public String getPassword() {  return password; }
    
        public void setPassword(String password) {  this.password = password; }
    
        /** * 同步方法,赋值用户名,休眠10s,在赋值 * @param username * @param password * @throws InterruptedException */
         public synchronized void setValue(String username, String password) throws InterruptedException { 
            this.username = username;
            //线程休眠10秒
            Thread.sleep(10000);
            this.password = password;
        }
    }
    
    
    /** * 线程类 */
    class MyThreadWithStop implements Runnable { 
        private SynchronizedObject synchronizedObject;
    
        public MyThreadWithStop(SynchronizedObject synchronizedObject) { 
            this.synchronizedObject = synchronizedObject;
        }
    
        @Override
        public void run() { 
            try { 
                //异步调用,同步方法,设置username,password
                synchronizedObject.setValue("zhangsan", "654321");
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    }
    
    
    public class StopTestRun{ 
        public static void main(String[] args) throws InterruptedException { 
            //创建同步操作类
            SynchronizedObject synchronizedObject = new SynchronizedObject();
            //创建线程,异步调用同步操作方法
            MyThreadWithStop mythread = new MyThreadWithStop(synchronizedObject);
    
            //开始执行:设置username=admin后休眠10秒在设置password=654321
            Thread thread = new Thread(mythread);
            thread.start();
    
            //主线程休眠500毫秒
            Thread.sleep(500);
    
            //停止线程
            thread.stop();
    
            //打印最终的值：zhangsan 123456? password=654321并没有执行完就结束了
            System.out.println(synchronizedObject.getUsername() + " " + synchronizedObject.getPassword());
        }
    }

**分析：**  
　　线程 MythreadWithStop 执行完 `this.username = username`后，此时username = admin，password = 123456，调用 `sleep()`方法让`当前线程睡眠 10s`，Main线程继续往下执行休眠500毫秒后调用 stop() 方法，停止 thread 线程。`setValue() 方法不再往下执行`。  
![在这里插入图片描述][cfb3406e06c44751b5e121bfc6f55216.png]

### 12.2.suspend() 和 resume() 方法 ###

*  **suspend()：暂停线程的执行(挂起线程,使线程进入阻塞状态,不会释放占用的锁)**
 *  **resume()：恢复线程的执行(恢复挂起线程)**
 *  **这2个方法在Java中`已废弃`。**

**缺点：**

*  因为 suspend() 在导致线程暂停的同时，并不会去释放任何锁资源。`导致其他线程都因无法访问被它占用的锁而阻塞`。直到对应的线程执行 resume() 方法后，被挂起的线程才能继续，从而`其它被阻塞在这个锁`的线程才可以继续执行。
    
     *  但是，如果因为操作不当`resume() 操作出现在 suspend() 之前执行，那么该线程将一直处于挂起状态，同时一直占用锁，这导致其他想要获取这把锁的线程也会进入阻塞状态，一只等待该线程释放锁，使系统进入一个类似"死锁"的状态。`。 而且，对于**被挂起的线程**，它的线程状态居然还是`Runnable。` 这也会严重影响我们对系统当前的判断。

public class SuspendResumeTest { 
        public static Object u = new Object();
        static TestThread t1 = new TestThread("线程1");
        static TestThread t2 = new TestThread("线程2");
    
        public static void main(String[] args) throws InterruptedException { 
            //线程1启动
            t1.start();
    
            //休眠200毫秒
            Thread.sleep(200);
    
            //线程2启动
            t2.start();
    
    
            //唤醒线程1
            t1.resume();
    
            //Thread.sleep(50);//唤醒t1后,休眠50毫秒,等待t2先执行suspend(),可以避免进入死锁
            
            //唤醒线程2
            t2.resume();
            // LockSupport.unpark(t1);
            // LockSupport.unpark(t2);
    
            //主线程等待线程1执行完在继续执行
            t1.join();
            //主线程等待线程2执行完在继续执行
            t2.join();
        }
    
        public static class TestThread extends Thread { 
            public TestThread(String name) { 
                super.setName(name);
            }
    
            @Override
            public void run() { 
                synchronized (u) { 
                    System.out.println("" + getName()+"持有锁");
                    //挂起线程
                    Thread.currentThread().suspend();
                    //LockSupport.park();
                    System.out.println(getName()+"运行结束,释放锁");
                }
            }
        }
    }

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

此时，通过 jps 和 jstack 命令，来观察线程状态，如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 12]  
**从输出结果来看，线程 t2 其实是`被挂起的`，但是从上图来看，它的线程状态却是`RUNNABLE`，这会使我们误判当前系统状态。**

结论:

1.  **被suspend挂起的线程状态显示为"RUNNABLE"状态，这给排查bug带来困难性。**
2.  **推荐使用wait()/notyft()/notifyAll() 或者 park()/unpark() 替代suspend()/resume()**

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

**线程挂起、恢复与终止的正确方法**

*  **通过`维护一个标记`，让线程在安全的位置挂起、恢复**
 *  **stop()的替代方案：同样是`维护一个标记`，通过控制标志位来终止线程。**

## 13.死锁、饥饿、活锁 ##

**死锁**

*  **指两个或两个以上的线程在执行过程中，相互占用对方的锁，而造成的一种互相等待的现象，导致系统一直处于阻塞状态。**
 *  产生死锁的条件
    
     *  **互斥条件**：如果一个线程对占用了锁，那么其他线程必须处于等待状态，直到该锁被释放。
     *  **请求和保持条件**：线程1已经占用了锁1 ,但又请求获取锁2，而此时，锁2被其他线程2占用，于是线程1也必须等待，但又对自己占用的锁1不释放。
     *  **不剥夺条件**：线程已占用的锁，在没有释放前，不能被其他线程获取，只能在使用完以后由自己释放。
     *  **环形等待条件**：在死锁发生时，必然存在一个`“环形链”`，即：\{t0,t1,t2,…tn\},进程t0线程等待t1占用的锁，t1 等待t2占用的锁，tn等待t0占用的锁。（**最直观的理解是，t0等待t1占用的锁，而t1而在等待t0占用的锁，于是两个线程就相互等待对方释放各自持有的锁）**

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

**活锁**

*  **指线程1可以使用资源，但它很礼貌，让其他线程先使用资源，线程2也可以使用资源，但它很绅士，也让其他线程先使用资源。这样你让我，我让你，最后两个线程都无法使用资源。**
    
     *  在街上遇到一妹子，刚好她朝着你的反方向走，与你正面碰到，你们都想让彼此过去。你往左边移，她也往左边移，两人还是无法过去。这时你往右边移，她也往右边移，如此循环下去。

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

**饥饿**

*  **指如果线程1占用了资源R，线程2又请求封锁R，于是线程2等待。线程3也请求资源R，当线程1释放了R上的封锁后，系统首先批准了线程3的请求，线程2仍然等待。然后线程4又请求封锁R，当T3释放了R上的封锁之后，系统又批准了线程4的请求……，线程2可能永远等待。** (`低优先级的线程2等待了最久却得不到执行的机会`)
    
     *  有两条道A和B上都堵满了车辆，其中**A道堵的时间最长，B相对相对堵的时间较短**，当前面道路疏通后，交警按照分配原则，示意B道上车辆先过，B道路上过了一辆又一辆，A道上排队时间最长的确没法通过，只能等B道上没有车辆通过的时候再等交警发指令让A道依次通过，**这也就是 ReentrantLock 显示锁里提供的不公平锁机制**（当然了，ReentrantLock 也提供了公平锁的机制，由用户根据具体的使用场景而决定到底使用哪种锁策略），**不公平锁能够提高吞吐量但不可避免的会造成低优先级线程容易产生饥饿。**

## 14.并发级别 ##

根据控制并发的策略，我们可以把并发的级别分为 `阻塞`和 `非阻塞`（**非阻塞分为`无障碍、无锁、无等待`**）

1.  **`阻塞(Blocking)`**: 当一个线程获取到锁进入临界区后，其他线程必须进入阻塞状态，等待该线程释放锁。

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

1.  **`无饥饿(Starvation-Free)`**：低优先级的线程产生饥饿
    
    > **系统总是会优先调度高优先级的线程，那么对于同一个资源的分配，是不公平的。锁也分公平锁和非公平锁，对于非公平锁来说，系统允许高优先级的线程插队获取资源。这样就可能`导致低优先级的线程产生饥饿`。但是如果是公平锁，满足先来后到，那么饥饿就不会产生，不管新来的线程优先级多高，要想获得资源，就必须乖乖排队。这样所有的线程都有机会执行。**

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

1.  **`无障碍(Obstruction-Free)`**：不加锁，都进入临界区，数据不一致，回滚
    
    > 无障碍是一种最弱的非阻塞调度。两个线程如果是无障碍的执行，那么他们不会因为临界区的问题导致一方被阻塞。**也就是大家都进入临界区了**。`如果大家一起修改共享区数据，把数据修改坏了怎么办呢？对于无障碍的线程来说，一旦检测到这种情况，它就会立即对自己所做的修改进行回滚，确保数据安全。但是如果没有数据竞争发生，那么线程就可以顺利完成自己的工作，走出临界区`。
    
    1.  从这个策略可以看出，无障碍的多线程程序不一定能顺畅的运行。`因为当临界区中存在严重的冲突时，所有的线程可能都会不断的回滚自己的操作，导致没有一个线程能顺利走出临界区。这种情况会影响系统的正常执行`。
    2.  **一种可行的无障碍实现**：可以依赖一个`“一致性标记”来实现`：线程在操作之前，先读取并保存这个标记，在操作完成之后，再次读取，检查这个标记是否更改过，如果两者是一致的，则说明资源访问没有冲突。如果不一致，则说明资源可能在操作过程中与其他线程存在冲突，需要重新操作。而任何对资源有修改操作的线程，在修改数据前，都需要更新这个一致性的标记，表示数据不再安全。

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

1.  **`无锁(Lock-Free)`**：无障碍基础上要求 必然有一个线程能够在有限步数内完成操作离开临界区
    
    1.  `无锁的并行都是无障碍的`。在无锁的情况下，所有的线程都能尝试对临界区进行访问，但不同的是，`无锁的并发保证必然有一个线程能够在有限步内完成操作走出临界区`。
    2.  在无锁的调用中，一个典型的特点是可能会包含一个`无线循环`。**在这个循环中，线程会不断尝试修改共享变量，如果没有冲突，修改成功，那么程序退出。否则继续尝试修改，但无论如何，无锁的并行总能保证一个线程胜出，不会全军覆没。至于临界区中竞争失败的线程，它们则必须不断重试，直到自己获胜，如果运气不好，总是不成功，则会出现饥饿的现象，线程会停止不前。**
    
        // 下面代码是Java中典型的无锁计算代码
        while (!atomicVar.compareAndSet(localVar, localVar+1)) {  
            localVar = atomicVar.get(); 
        }

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

1.  **`无等待(Wait-Free)`**：要求`所有的线程`都必须在有限步数内完成 ,一种典型的无等待结构就是`RCU(Read-Copy-Update)`，有点像svn解决冲突的方式
    
     *  无锁只要求一个线程可以在有限步数内完成操作，而无等待则是在无锁的基础上更进一步进行扩展，`它要求所有的线程都必须在有限步数内完成，这样就不会引起线程饥饿问题。`
    
    1.  一种典型的无等待结构是`RCU（Read-Copy-Update`）。它的基本思想是，`对数据的读可以不加控制`。因此，`所有的读操作是无等待的，他们既不会被锁定等待也不会引起任何冲突`。**但是在写数据的时候，先取得原始数据的副本，接着`只修改副本数据`（这就是为什么读可不加控制），修改完成后，在合适的时机`回写数据`。**

> **1、2 是阻塞，3、4、5是非阻塞，无锁用的更多**

[Java_CPU_I_O]: https://blog.csdn.net/qq877728715/article/details/101540623
[Java]: https://blog.csdn.net/qq877728715/article/details/97165955
[Java 1]: https://blog.csdn.net/qq877728715/article/details/104123655
[_Java_Java_]: https://blog.csdn.net/qq877728715/article/details/104429586
[_Java_]: https://blog.csdn.net/qq877728715/article/details/108880980
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70]: /images/20220829/e1e42290462b420e9703760bde420481.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/fb4e2697c0174eddb098fb0cb24a6e85.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5aKp5aKp5YiG5aKp,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_13_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/9c8610986ad74801ab6727d32f5041b3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 1]: /images/20220829/cddd9091eecd468a80dd43e4768b2f50.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 2]: /images/20220829/ac5819bd91514790a3fa358633eba79c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 3]: /images/20220829/de6238d3204840b58d0b0ab0edc4c3b5.png
[Linux_CPU]: https://blog.csdn.net/yetugeng/article/details/88196604?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-1.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-1.control
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 4]: /images/20220829/f1b633f0ded04cb489543d71344dcac5.png
[Java_BIO_NIO_AIO]: https://blog.csdn.net/qq877728715/article/details/104499859
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 5]: /images/20220829/052c3fe740fa4e2cb2065373a9a49e2b.png
[CPU _ _CPU]: https://www.cnblogs.com/mylearning-log/p/10932053.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 6]: /images/20220829/d3412171cf2640b99b00cd6954786dba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 7]: /images/20220829/2b665273ee9b421291f42f3144c1dd0d.png
[f7f597664110493ab835ee3aeb66895d.png]: /images/20220829/440bc7117899459eb832a8a0a9547777.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 8]: /images/20220829/551502f5d40c4025b081821ac944bad6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 9]: /images/20220829/cf191096ca8249149f3f7a71cdaf3f3a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 10]: /images/20220829/927b55fa6afc4150b09969a6cb75f0df.png
[cfb3406e06c44751b5e121bfc6f55216.png]: /images/20220829/55b4ca5f2d4444e896dde69ced13d6b0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 11]: /images/20220829/279fccb00c78471aba3881e843fc5fa4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 12]: /images/20220829/f581a1987d184b8787ae18d30950db70.png