【操作系统】进程管理-优快云博客

本文链接：https://blog.youkuaiyun.com/a20040518/article/details/144173617

进程

进程的概念

简单理解为运行中的程序

进程的状态

基本状态：创建状态、就绪状态、运行状态、阻塞状态、结束状态、挂起状态

挂起状态可以分为两种：

阻塞挂起状态：进程在外存（硬盘），等待某个事件的出现；
就绪挂起状态：进程在外存（硬盘），但只要进入内存，即刻运行；

导致进程挂起的原因：

1.调到外存节省内存

2.通过 sleep 挂起进程

3.用户希望挂起一个程序的执行，比如 ctrl+z 挂起进程

挂起与阻塞状态有什么区别？

进程控制结构

PCB 是进程存在的唯一标识

PCB 中具体包含什么信息？

进程描述信息：

进程标识符：标识各个进程，每个进程有且仅有一个
用户标识符：标识进程归属的用户，主要为共享和保护服务。

进程控制和管理信息：

进程当前的状态：如 new、ready、running。。。
进程优先级：进程抢占 CPU 时的优先级

资源分配清单：

有关内存地址空间或虚拟地址空间的信息、所打开文件的列表和所使用的 I/O 设备信息

CPU 相关信息

CPU 中各个寄存器的值，当进程被切换时，CPU 的状态信息都会被保存在相应的 PCB 中，以便程序重新执行时，能从断点处继续执行。

每个 PCB 是如何组织的呢？

通过链表的方式进行组织，把相同状态的进程链在一起，组成各种队列，比如就绪队列、阻塞队列。。。还可以使用索引的方式，把相同状态的进程组织在一个索引表中，索引项指向相应的 PCB，但不如链表，因为面临进程创建销毁，链表插入删除更灵活。

进程的控制

包括进程的创建、终止、阻塞、唤醒

创建进程

申请一个空白的 PCB，并向 PCB 中填写一些控制和管理进程的信息，比如进程的唯一标识。。。
为该进程分配运行时所必需的资源，比如内存资源。。。
将 PCB 插入到就绪队列，等待被调度运行；

终止进程

三种方式：正常结束、异常结束以及外界干预（信号 kill 掉）

子进程终止，归还继承父进程的资源，父进程终止，子进程变孤儿，交给1号进程。

查找终止进程的 PCB
如果处于执行状态，则立刻终止，然后将 CPU 分配给其他进程
如果其还有子进程，则将子进程交给1号进程接管
将该进程所拥有的全部资源归还操作系统
将其从 PCB 队列中删除

阻塞进程

当进程需要等待某一事件完成时，它可以调用阻塞语句把自己阻塞等待。而一旦被阻塞等待，它

只能由另一个进程唤醒。

找到将要被阻塞进程的 PCB；
如果该进程为运行状态，则保护其现场，将其状态转为阻塞状态，停止运行；
将该 PCB 插入到阻塞队列中去；

唤醒进程

在阻塞队列中找到相应进程的 PCB；
将其从阻塞队列中移出，并置其状态为就绪状态；
把该 PCB 插入到就绪队列中，等待调度；

进程的上下文切换

由一个进程切换到另一个进程运行

场景：

时间片耗尽
系统资源不足，挂起当前进程，执行其他进程
进程通过 sleep 主动挂起
当有优先级更高的进程运行时，挂起当前进程，执行高优先级进程
发生硬件中断时，CPU 上的进程会被中断挂起，转而执行内核中的中断服务程序；

并发与并行

线程

什么是线程？

线程是进程当中的一条执行流程。

同一个进程内多个线程之间可以共享代码段、数据段、打开的文件等资源，但每个线程各自都有一套独立的寄存器和栈，这样可以确保线程的控制流是相对独立的。

线程的优缺点？

优点：

一个进程中可以同时存在多个线程
各个线程之间可以并发执行
各个线程之间可以共享地址空间和文件等资源

缺点：

当进程中的一个线程崩溃时，会导致其所属进程的所有线程崩溃

线程与进程比较

进程是资源分配的单位，线程是 CPU 调度的单位；
进程拥有一个完整的资源平台，而线程只独享必不可少的资源，如寄存器和栈；
线程同样具有就绪、阻塞、运行三种基本状态，同样具有状态之间的转换关系；
线程能减少并发执行的时间和空间开销；

线程相比进程能减少开销体现在：

线程的创建时间比进程快，因为进程在创建的过程中，还需要资源管理信息，比如内存管理信息、文件管理信息，而线程在创建的过程中，不会涉及这些资源管理信息，而是共享它们；
线程的终止时间比进程快，因为线程释放的资源相比进程少很多；
同一个进程内的线程切换比进程切换快，因为线程具有相同的地址空间（虚拟内存共享），这意味着同一个进程的线程都具有同一个页表，那么在切换的时候不需要切换页表。而对于进程之间的切换，切换的时候要把页表给切换掉，而页表的切换过程开销是比较大的；
由于同一进程的各线程间共享内存和文件资源，那么在线程之间数据传递的时候，就不需要经过内核了，这就使得线程之间的数据交互效率更高了；

线程的上下文切换

当两个线程不是属于同一个进程，则切换的过程就跟进程上下文切换一样；
当两个线程是属于同一个进程，因为虚拟内存是共享的，所以在切换时，虚拟内存这些资源就保持不动，只需要切换线程的私有数据、寄存器等不共享的数据；

线程的实现

主要有三种实现方式：

用户线程：在用户空间实现的线程，不是由内核管理的线程，是由用户态的线程库管理；
内核线程：在内核中实现的线程，是由内核管理的线程；
轻量级进程：在内核中来支持用户线程；

用户线程如何理解？优缺点？

用户线程的整个线程管理和调度，操作系统是不直接参与的，而是由用户级线程库函数来

完成线程的管理，包括线程的创建、终止、同步和调度等。

优点：

每个进程都需要有私有的线程控制块列表，用来跟踪记录各个线程状态信息，TCB 由用户级线程库函数来维护，可用于不支持线程技术的操作系统；
用户线程的切换也是由线程库函数来完成的，无需用户态与内核态的切换，所以速度特别快；

缺点：

由于操作系统不参与线程的调度，如果一个线程发起了系统调用而阻塞，那进程所包含的用户线程都不能执行了。
当一个线程开始运行后，除非它主动地交出 CPU 的使用权，否则它所在的进程中的其他线程无法运行，因为用户态的线程无法打断当前运行中的线程，它没有这个特权，只有操作系统才有，但是用户线程不是由操作系统管理的。
由于时间片分配给进程，故与其他进程比，在多线程执行时，每个线程得到的时间片较少，执行会比较慢；

内核线程如何理解？优缺点？

内核线程是由操作系统管理的，线程对应的 TCB 放在操作系统，线程的创建、终止和管理等都是由操作系统负责。

优点：

在一个进程中，如果某个内核线程发起系统调用而被阻塞，并不会影响其他内核线程的运行；
时间片分配给线程，多线程的进程获得更多的 CPU 运行时间；

缺点：

在支持内核线程的操作系统中，由内核来维护进程和线程的上下文信息，如 PCB 和 TCB；
线程的创建、终止和切换都是通过系统调用来进行，因此对于系统来说，系统开销比较大；

轻量级进程如何理解？优缺点？

轻量级进程是内核支持的用户线程，一个进程可有一个或多个 LWP，每个 LWP 跟内核线程一对一映射的，而且 LWP 是由内核管理并像普通进程一样被调度。

LWP与普通进程的区别？

在 LWP 之上是可以使用用户线程的，LWP 与用户线程的对应关系有三种：

1 : 1 ：一个用户线程对应一个 LWP；
N : 1 ：多个用户线程对应一个 LWP；
M : N ：多个用户线程对应多个 LWP；

1 : 1 模式

一个线程对应到一个 LWP 再对应到一个内核线程，如上图的进程 4，属于此模型。

优点：实现并行，当一个 LWP 阻塞，不会影响其他 LWP；
缺点：每一个用户线程，就产生一个内核线程，创建线程的开销较大。

N : 1 模式

多个用户线程对应一个 LWP 再对应一个内核线程，如上图的进程 2，线程管理是在用户空间完成

的，此模式中用户的线程对操作系统不可见。

优点：用户线程要开几个都没问题，且上下文切换发生在用户空间，切换的效率较高；
缺点：一个用户线程如果阻塞了，则整个进程都将会阻塞，另外在多核 CPU 中，是没办法充分利用 CPU 的。

M : N 模式

根据前面的两个模型混搭一起，就形成 M:N 模型，该模型提供了两级控制，首先多个用户线程

对应到多个 LWP，LWP 再一一对应到内核线程，如上图的进程 3。

优点：综合了前两种优点，大部分的线程上下文发生在用户空间，且多个线程又可以充分利用多核 CPU 的资源。

组合模式

如上图的进程 5，此进程结合 1:1 模型和 M:N 模型。开发人员可以针对不同的应用特点调节内

核线程的数目来达到物理并行性和逻辑并行性的最佳方案。

协程

什么是协程？

我的理解：一个进程可以包含多个线程，这些线程可以并发执行，同时共享进程资源；而对于协程，协程允许多个任务在同一线程上并发执行，一个线程可以包含多个协程，同时共享线程资源。

为什么用协程？

背景知识：

引入协程正是可以避免由于线程调度造成的上下文切换开销：

进程间有哪些通信方式？

每个进程的用户空间都是独立的，不能互相访问，但内核空间是共享的，所以进程之间要通信必须通过内核。

管道

匿名管道：没有名字标识，只存在于内存的特殊文件，不存在于文件系统中，shell 命令中的“|”就是匿名管道，通信的数据是无格式的流并且大小受限，通信的方式是单向的，数据只能在一个方向上流动，如果要双向通信，需要创建两个管道。只能用于存在父子关系的进程间通信，匿名管道的生命周期随着进程创建而建立，随着进程终止而消失。

int pipe(int pipefd[2]);

功能：创建一个匿名管道，返回两个文件描述符，分别用于管道的读端和写端。
参数：pipefd 是一个包含两个元素的整数数组，pipefd[0] 用于从管道读取数据（读端），pipefd[1] 用于向管道写入数据（写端）。
返回值：成功时返回 0，失败时返回 -1，并设置相应的错误码。

命名管道：突破了匿名管道只能在亲缘关系进程间的通信限制，使用命名管道需要在文件系统创建一个类型为 p 的设备文件（mkfifo pipeFile），进程间可以通过这个设备文件进行通信。不管是匿名管道还是命名管道，进程写入的数据都缓存在内核中，另一个进程从内核中读取，同时通信数据都遵循先进先出原则，不支持 lseek 之类的文件定位操作。

int mkfifo(const char *pathname, mode_t mode);

功能：创建一个有名管道文件。
参数：
pathname：指定有名管道文件的路径名。
mode：指定管道文件的权限，类似于创建普通文件时的权限设置，例如 0666 表示所有用户都有读写权限。

返回值：成功时返回 0，失败时返回 -1，并设置相应的错误码。

优点：实现简单。

缺点：1.通信方式效率低，不适合进程之间频繁交换数据。2.通信数据是无格式字节流且大小受限

特殊情况：管道默认阻塞，即当管道满时会阻塞写端，管道为空时会阻塞读端。当写端关闭时，如果管道有数据，读端读取完剩余数据后返回0；管道读端关闭，写端尝试写数据，系统会向写端进程发送SIGPIPE信号（可利用MSG_NOSIGNAL忽略信号）。

消息队列

消息队列克服了管道通信的数据是无格式的字节流的问题，它是保存在内核的消息链表，消息队列的消息体可以是用户自定义的数据类型，发送数据时，会被分成一个一个独立的消息体，接收数据时，要与发送方发送的消息体的数据类型保持一致，这样才能保证读取的数据是正确的。消息队列通信不及时且不适合大数据传输，同时每次数据的写入和读取都需要经过用户态与内核态之间的拷贝过程。

优点：类似于邮件的通信方式，不存在阻塞，A进程将数据放入消息队列就可以返回了，当B进程有需要时再去消息队列中读取。

缺点：1.不适合较大数据的传输，因为消息体和消息队列都有最大长度限制。2.消息队列通信中， 存在用户态到内核态之间的数据拷贝开销（进程写入数据到内核中的消息队列，会发生用户态到内核态之间的拷贝开销，另一进程读取时，会发生内核态拷贝数据到用户态的过程）。

共享内存

共享内存可以解决消息队列通信中用户态和内核态之间数据拷贝带来的开销，它直接分配一个共享内存，每个进程都可以直接访问，是最快的进程间通信方式。问题：多进程竞争同一个共享资源会造成数据错乱。

优点：解决消息队列读取和写入的过程中涉及的用户态与内核态之间的拷贝。共享内存机制实际上就是不同进程拿出一块虚拟地址空间，映射到相同的物理内存，这样就 避免了拷贝，大大提高了进程间的通信速度。

缺点：需要进程间协调访问，避免竞态条件。

适用场景：1.进程间需要频繁交互数据 2.数据量大，且需要高效传输

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

addr：指定映射的起始地址，通常设置为 NULL，让操作系统自动选择合适的地址。
length：映射区域的长度，即要映射的文件或设备的字节数。
prot：指定映射区域的访问权限，可选值如下：
PROT_READ：允许读操作。
PROT_WRITE：允许写操作。
PROT_EXEC：允许执行操作。
PROT_NONE：禁止访问。
可以使用按位或（|）组合多个权限，例如 PROT_READ | PROT_WRITE 表示既允许读也允许写。
flags：控制映射的类型和行为，常见的标志如下：
MAP_SHARED：对映射区域的写操作会反映到文件中，并且其他映射了同一个文件的进程也能看到这些修改。常用于进程间通信。
MAP_PRIVATE：对映射区域的写操作不会反映到文件中，而是创建一个该文件的私有副本，其他进程看不到这些修改。
MAP_ANONYMOUS：创建一个匿名映射，不与任何文件关联，通常用于创建共享的内存区域进行进程间通信。此时 fd 参数会被忽略，offset 通常设置为 0。
fd：文件描述符，指定要映射的文件或设备。
offset：文件的偏移量，指定从文件的哪个位置开始映射。

int munmap(void *addr, size_t length);

addr：要解除映射的起始地址，即 mmap 函数返回的地址。
length：要解除映射的区域长度，应与 mmap 时指定的长度一致。

信号量

信号量可以用来保护共享资源，确保任何时刻只能有一个进程访问共享资源。信号量不仅可以实现互斥访问，还可以实现进程同步，信号量是一个整型计数器，表示的是资源个数，其值可以通过两个原子操作来控制，分别是 P 操作和 V 操作。

P 操作，将信号量减 1，相减后如果信号量 < 0，则表明资源已被占用，进程需阻塞等待；相减后如果信号量 >= 0，则表明还有资源可使用，进程可正常继续执行。
V 操作，将信号量加 1，相加后如果信号量 <= 0，则表明当前有阻塞中的进程，于是将该进程唤醒运行；相加后如果信号量 > 0，则表明当前没有阻塞的进程。

优点：一种保护机制，防止多进程竞争共享资源造成数据错乱，使共享的资源在任意时刻只能被一个进程访问。 信号量实际是一个整型计数器，主要用于实现进程间的互斥和同步，不用于缓存进程间的通信数据。

信号

信号可以在应用进程和内核之间直接交互，内核也可以利用信号来通知用户空间的进程发生了哪些系统事件，信号事件的来源主要有硬件来源（如键盘 Cltr+C ）和软件来源（如 kill 命令），一旦有信号发生， 进程有三种方式响应信号：执行默认操作、捕捉信号、忽略信号。

注：有两个信号是应用进程无法捕捉和忽略的，即 SIGKILL 和 SIGSTOP ，这是为了方便我们能在任何时候结束或停止某个进程。

应用场景：上面介绍的都是常规状态下的工作模式，信号可用于异常状况下通知进程。

Socket

Socket 不仅可以用于不同主机进程间通信，还可以用于本地主机进程间通信，可根据创建 Socket 的类型不同，分为三种常见的通信方式：基于 TCP 协议的通信方式、基于 UDP 协议的通信方式、本地进程间通信方式。

应用场景：前面说到的通信机制，都是工作与同一台主机，如果要与不同主机的进程间通信，就需要用到socket。

多线程冲突了怎么办？

竞争与协作

互斥的概念

一个线程在临界区执行时，其他线程阻止进入临界区。

同步的概念

并发进程/线程在一些关键点上可能需要互相等待与互通消息，这种相互制约的等待与互通信息称为进程/线程同步。

互斥与同步的实现

锁

信号量

生产者-消费者问题

生产者在生成数据后，放入缓冲区；
消费者从缓冲区取出数据处理；
任何时刻，只能有一个生产者或消费者可以访问缓冲区；

经典同步问题

哲学家就餐问题

描述：5个哲学家，每个哲学家有两种行为：思考和就餐。桌上有5根筷子，每两个哲学家之间放一根筷子，每个哲学家只有拿起与他相邻的两根筷子才能就餐，并且一次只能拿起一根筷子。

方案一：先拿左边的，再拿右边的

问题：产生死锁。可能存在5个哲学家同时都拿左边的。

方案二：在拿筷子之前加互斥信号量

问题：只要有一个哲学家进入临界区（准备拿筷子），其他哲学家都不能动，只有当前哲学家用完了，才能轮到下一个哲学家。

方案三：让偶数编号的哲学家先拿左边的再拿右边的，让奇数编号的哲学家先拿右边的再拿左边的（该方法是通过打破循环等待从而避免死锁）

既不会出现死锁，也可以两人同时进餐。

举例说明：

假设有 5 个哲学家（编号 0 到 4）：

偶数编号哲学家（0、2、4）：
- 先拿左边的叉子，再拿右边的叉子。
奇数编号哲学家（1、3）：
- 先拿右边的叉子，再拿左边的叉子。

具体过程：

哲学家 0 拿叉子 0 和叉子 1。
哲学家 1 拿叉子 2 和叉子 1（但叉子 1 已被哲学家 0 占用，因此哲学家 1 等待）。
哲学家 2 拿叉子 2 和叉子 3。
哲学家 3 拿叉子 4 和叉子 3（但叉子 3 已被哲学家 2 占用，因此哲学家 3 等待）。
哲学家 4 拿叉子 4 和叉子 0（但叉子 4 已被哲学家 3 占用，因此哲学家 4 等待）。

通过这种方式，哲学家 0 和哲学家 2 可以成功进餐，而其他哲学家会等待，从而避免死锁。

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>

const int N = 5; // 哲学家个数
std::vector<std::mutex> forks(N); // 每个叉子一个互斥锁

void think(int id) {
    std::cout << "Philosopher " << id << " is thinking.\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 模拟思考
}

void eat(int id) {
    std::cout << "Philosopher " << id << " is eating.\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 模拟进餐
}

void philosopher(int i) {
    while (true) {
        think(i);

        if (i % 2 == 0) {
            forks[i].lock(); // 拿左边的叉子
            forks[(i + 1) % N].lock(); // 拿右边的叉子
        } else {
            forks[(i + 1) % N].lock(); // 拿右边的叉子
            forks[i].lock(); // 拿左边的叉子
        }

        eat(i);

        forks[i].unlock(); // 放下左边的叉子
        forks[(i + 1) % N].unlock(); // 放下右边的叉子
    }
}

int main() {
    std::vector<std::thread> philosophers;

    for (int i = 0; i < N; ++i) {
        philosophers.emplace_back(philosopher, i);
    }

    for (auto& t : philosophers) {
        t.join();
    }

    return 0;
}

方案四：用 state 数组来记录每一位哲学家的三个状态，分别是进餐状态，思考状态，饥饿状态（正在试图拿筷子）。一个哲学家只有两个邻居都没有进餐时，才可以进入进餐状态。进餐结束后，唤醒邻居。（该方法是通过打破循环等待从而避免死锁）

既不会出现死锁，也可以两人同时进餐。

举例说明：

一个哲学家只有在两个邻居都没有进餐时才能进入进餐状态。当一个哲学家进餐结束后，会检查其邻居是否可以进餐。如果有邻居处于饥饿状态且满足条件，则唤醒该邻居。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <vector>

const int N = 5; // 哲学家个数
enum State { THINKING, HUNGRY, EATING }; // 哲学家的状态

std::vector<State> state(N, THINKING); // 每个哲学家的状态
std::vector<std::mutex> forks(N); // 每个叉子一个互斥锁
std::mutex mtx; // 用于保护状态数组
std::vector<std::condition_variable> cond_vars(N); // 每个哲学家一个条件变量

void test(int i) {
    // 检查哲学家 i 是否可以进餐
    if (state[i] == HUNGRY &&
        state[(i + N - 1) % N] != EATING && // 左邻居没有进餐
        state[(i + 1) % N] != EATING) {     // 右邻居没有进餐
        state[i] = EATING; // 进入进餐状态
        cond_vars[i].notify_one(); // 唤醒哲学家 i
    }
}

void take_forks(int i) {
    std::unique_lock<std::mutex> lock(mtx);
    state[i] = HUNGRY; // 设置哲学家 i 为饥饿状态
    test(i); // 尝试进餐
    while (state[i] != EATING) {
        cond_vars[i].wait(lock); // 等待条件满足
    }
}

void put_forks(int i) {
    std::unique_lock<std::mutex> lock(mtx);
    state[i] = THINKING; // 设置哲学家 i 为思考状态
    // 检查左右邻居是否可以进餐
    test((i + N - 1) % N); // 左邻居
    test((i + 1) % N);     // 右邻居
}

void think(int i) {
    std::cout << "Philosopher " << i << " is thinking.\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 模拟思考
}

void eat(int i) {
    std::cout << "Philosopher " << i << " is eating.\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 模拟进餐
}

void philosopher(int i) {
    while (true) {
        think(i);
        take_forks(i); // 拿叉子
        eat(i);
        put_forks(i); // 放叉子
    }
}

int main() {
    std::vector<std::thread> philosophers;

    for (int i = 0; i < N; ++i) {
        philosophers.emplace_back(philosopher, i);
    }

    for (auto& t : philosophers) {
        t.join();
    }

    return 0;
}

读者-写者问题

读者只会读取数据，不会修改数据，而写者即可以读也可以修改数据。

描述：

读读允许：同一时刻，允许多个读者同时读
读写互斥：没有写者时读者才能读，没有读者时写者才能写
写写互斥：没有其他写者时，写者才能写

方案一：读者优先策略，只要有读者正在读，后来的读者都可以直接进入，如果读者持续不断进入，则写者会处于饥饿状态。

方案二：写者优先策略，只要有写者准备写入，写者应尽快执行写操作，后来的读者就必须阻塞，如果写者持续不断写入，则读者处于饥饿状态。

方案三：公平策略

优先级相同；
写者、读者互斥访问；
只能一个写者访问临界区；
可以有多个读者同时访问临界资源；

怎么避免死锁？

死锁的概念

两个线程都在等待对方释放锁，在没有外力作用下，这些线程就会一直相互等待，无法继续运行，这种情况就是发生了死锁。

死锁只有 同时满足以下四个条件才会发生：

互斥条件：多个线程不能同时使用一个资源
请求与保持条件：线程在等待资源的同时不会释放自己已经持有的资源
不可剥夺条件：线程持有的资源在其使用完之前别的线程不能获取
环路等待条件：每个线程都在等待相邻线程手中的资源，形成环路

避免死锁问题的发生

只需破坏其中一个条件即可，最常用的方法是使用资源有序分配法来破坏环路等待条件。

什么是悲观锁、乐观锁？

互斥锁

互斥锁加锁失败后，线程会释放 CPU 给其他进程，内核会将线程置为睡眠状态，等锁释放后，内核会在合适时机唤醒线程。

存在开销成本，涉及两次线程上下文切换：

当线程加锁失败时，内核会把线程的状态从运行态设置为睡眠态，然后把 CPU 切换给其他线程运行；
当锁被释放时，线程由睡眠态变就绪态，内核会在合适的时间将 CPU 交给线程执行；

线程的上下文切换的是什么？

当两个线程属于同一个进程，因为虚拟内存是共享的，所以在切换时，虚拟内存这些资源保持不动，只需要切换线程的私有数据、寄存器等不共享的数据。

自旋锁

自旋锁在用户态完成加锁和解锁，不会主动产生线程上下文切换，当加锁失败时，线程会忙等待直至获得锁。在单核 CPU 上，需要抢占式调度器（即不断通过时钟中断一个线程，运行其他线程），否则自旋锁在单核 CPU 上无法使用，因为自旋的线程永远不会放弃 CPU。

总结：如果已知被锁住的代码执行时间很短，那么应该选择开销更小的自旋锁。

读写锁

包括读锁和写锁，其中读锁共享，写锁互斥，根据实现的不同，分为读优先锁和写优先锁，读优先锁是当读线程先拥有读锁时，写线程获取写锁阻塞，但后来的读线程还可以获得读锁，问题：可能造成写线程饥饿；写优先锁当读线程先拥有读锁时，写线程获取写锁阻塞，但后来的读线程不可以获得读锁，当读线程执行完，写线程执行，问题：可能造成读线程饥饿。

采用公平读写锁，用队列把获取锁的线程排队，根据先进先出原则即可。