（学习笔记-进程管理）多线程冲突如何解决

对于共享资源，如果没有上锁，在多线程的环境里，很有可能发生翻车。

竞争与合作

在单核 CPU 系统里，为了实现多个程序同时运行的假象，操作系统通常以时间片调度的方式，让每个进程每次执行一个时间片，时间片用完了，就切换下一个进程运行，由于这个时间片的时间很短，于是就造成了并发现象

另外，操作系统也为每个进程创建巨大，私有的虚拟内存的假象，这种地址空间的抽象，让每个程序好像拥有自己的内存，而实际上操作系统在背后秘密地让多个地址空间复用物理内存或磁盘。

如果一个程序只有一个执行流程，也代表它是单线程的。当然一个程序可以有多个执行流程，也就是所谓的多线程程序，线程是调度的基本单位，进程则是资源分配的基本单位。

所以，线程之间是可以共享进程的资源，比如代码段、堆空间、数据段、打开的文件等资源、但每个线程都有自己独立的栈空间。

那么问题就来了，多个线程如果竞争共享资源，如果不采取有效的措施，则会造成共享数据的混乱。

实验：创建两个线程，它们分别对共享变量 i 自增 1 执行 10000 次，如下代码：

按理来说， i 变量最后应该是 20000 ，但是，实际结果如下：

运行了两次，发现结果 i 值可能会20000，也可能为其他结果。

每次运行不但会产生错误，而且得到不同的结果。在计算机里是不能容忍的，虽然是小概率出现的错误，但是小概率事件它一定是会发生的。

为什么会出现这种情况？

为了理解为什么会发生这种情况，必须了解编译器为更新计数器 i 变量生成的代码序列，也就是要了解汇编指令的执行顺序。

在这个例子中，我们只是想给 i 加上数字 1 ，那么它对应的汇编指令执行的过程是这样的：

可以发现，只是单纯给 i 加上数字 1，在 CPU 运行的时候，实际上要执行 3 条指令。

假设线程 1 进入这个代码区域，它将 i 的值(假设此时为 50 ) 从内存加载到它的寄存器中，然后它向寄存器加 1 ，此时在寄存器中的 i 的值是 51 。

现在，不幸的事情发生了：时钟中断发生。因此，操作系统将当前正在运行的线程的状态保存到线程的线程控制块 TCB。

现在更糟糕的事情发生了：线程 2 被调度运行，并进入同一段代码。它也执行了第一条指令，从内存获取 i 值并将其放入到寄存器中，此时内存中的 i 的值仍为 50，因此线程2寄存器中的 i 值也是 50。假设线程 2 执行接下来的两条指令，将寄存器中的 i 值 +1，然后将寄存器中的 i 值保存到内存中，于是此时全局变量 i 值是 51。

最后，又发生了一次上下文切换，线程 1 恢复执行。还记得它已经执行了两条汇编指令，现在准备执行后一条指令。在前面，线程 1 寄存器中的 i值为51，因此执行最后一条指令后，将值保存到内存，全局变量 i 的值再次被设置为 51.

简单来说，增加 i（值为50）的代码被运行两次，按理来说，最后的 i值应该是 52 ，但是由于不可控的调度，导致最后 i 值为 51.

针对2上面线程 1 和线程 2 的执行过程，可以表示为：

互斥

上面展示的情况称为竞争条件，当多线程相互竞争操作共享变量时，由于运气不好，即在执行过程中发生了上下文切换，我们得到了错误的结果，事实上，每次运行都可能得到不同的结果，因此输出的结果存在不确定性。

由于多线程执行操作共享变量的这段代码可能会导致竞争状态，因此我们将此段代码称为临界区，它是访问共享资源的代码片段，一定不能给多线程同时执行。

我们希望这段代码是互斥的，也就是说保证一个线程在临界区执行时，其他线程应该被阻止进入临界区，即这段代码执行过程中，最多只能出现一个线程。

另外，互斥并不是只针对多线程。在多线程竞争共享资源的时候，也同样是可以使用互斥的方式来避免资源竞争造成的资源混乱。

同步

互斥解决了并发进程/线程对临界区的使用问题。这种基于临界区控制的交互作用是比较简单的，只要一个进程/线程加入了临界区，其他试图想进入临界区的进程/线程都会被阻塞，直到第一个进程/线程离开了临界区。

在多线程里，每个线程并不一定是顺序执行的，它们基本是以各自独立的、不可预知的速度向前推进，但是有时候我们又希望多个线程能密切合作，以实现一个共同的任务

例子，线程 1 是负责读入数据的，而线程 2 是负责处理数据的，这两个线程是相互合作、相互依赖的。线程 2 在没有收到线程 1 的唤醒通知时，就会一直阻塞等待，当线程 1 读完数据需要把数据传给线程 2 时，线程 1 会唤醒线程 2，并把数据交给线程 2 处理。

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

PS:同步和互斥是两种不同的概念：

同步： [操作A应在操作B之前执行]，[操作C必须在操作A和操作B都完成后才能执行] 等
互斥： [操作A和操作B不能在同一时刻执行]；

互斥与同步的实现和使用

在进程/线程并发执行的过程中，进程/线程之间存在协作的关系，例如有互斥、同步的关系。

为了实现进程/线程间正确的协作，操作系统必须提供实现进程协作的措施和方法，主要方法有两种：

锁：加锁、解锁操作
信号量：P、V操作

这两个都可以方便地实现进程/线程互斥、而信号量比锁的功能更强一些，它还能方便地实现进程/线程同步。

锁

使用加锁操作和解锁操作可以解决并发线程/进程的互斥问题。

任何想进入临界区的线程，必须先执行加锁操作。若加锁操作顺利通过，则线程可进入临界区；在完成对临界资源的访问后再执行解锁操作，以释放该临界资源。

根据锁的实现不同，可以分为 [忙等待锁] 和 [无忙等待锁]。

忙等待锁的实现

在说明忙等待锁的实现之前，需要先了解一下现代CPU体系结构提供的特殊原子操作指令 -- 测试和置位（Test-and-Set）指令。

如果用 C 代码表示 Test-and-Set指令，形式如下：

测试并设置指令做了下述事情：

把 old_ptr 更新为 new 的新值
返回 old_ptr 的旧值

关键的是这些代码是原子执行的。因为既可以测试旧值，又可以设置新值，所以我们把这条指令叫做 [测试并设置]。

原子操作：要么全部执行，要么都不执行，不能出现执行到一半的中间状态。

我们可以运用Test-and-Set指令来实现 [忙等待锁]，代码如下：

我们来理解为什么这个锁能够工作：

场景一：首先假设一个线程正在运行，调用 lock() ，没有其他线程持有锁，所以 flag 是 0。当调用 TestAndSet(flag , 1) 方法，返回 0，线程会跳出 while 循环，获取锁。同时也会原子的设置 flag为 1 ，标志锁已经被持有。当线程离开临界区，调用 unlock() 将 flag 清理为 0.
场景二：当某个线程已经持有锁(即 flag 为 1)。本线程调用 lock()，然后调用 TestAndSet(flag , 1) ，这一次返回 1 ，只要另一个线程一直持有锁，TestAndSet() 会重复返回 1 ，本线程会一直忙等。当 flag 终于被改为 0，本线程会调用 TestAndSet() ，返回 0 并且原子地设置为 1 ，从而获得锁，进入临界区。

很明显，当获取不到锁时，线程会一直 while 循环，不做任何事情，所以就被称为 [忙等待锁]，也被称为 自旋锁 。

这是最简单的一种锁，一直自旋，利用CPU周期，直到锁可用。在单处理器上，需要抢占式的调度器（即不断通过时钟中断一个线程，运行其他线程。）否则，自旋锁在单CPU上无法使用，因为一个自旋的线程永远不会放弃CPU。

无等待锁的实现

无等待锁：获取不到锁的时候，不用自旋。当没有获取到锁的时候，就把当前线程放入到锁的等待队列，然后执行调度程序，把CPU让给其他线程执行

本次只是提出了两种简单锁的实现方式。当然，在具体操作系统中，会更复杂，但也离不开本例中两个基本元素。

信号量

信号量是操作系统提供的一种协调共享资源访问的方法。

通常信号量表示资源的数量，对应的变量是一个整型（sem）变量。

另外，还有两个原子操作的系统调用函数来控制信号的，分别是：

P操作：将 sem 减 1 ，相减后，如果 sem < 0 ，则进程/线程进入阻塞等待，否则继续，表明 P 操作可能会阻塞；
V操作：将 sem 加 1 ，相加后，如果 sem <= 0，唤醒一个等待中的进程/线程，表明 V 操作不会阻塞；

TIP 为什么V 操作中是sem <= 0

例子：如果 sem = 1 ，有三个线程进行了 P 操作：

第一个线程 P 操作后，sem = 0；第一个线程继续运行
第二个线程 P 操作后，sem = -1；sem < 0 第二个线程阻塞等待
第三个线程 P 操作后，sem = -2；sem < 0 第三个线程阻塞等待

这时，第一个线程在执行 V 操作后，sem=-1；sem <=0,所以要唤醒阻塞等待中的第二个线程或第三个线程。

P操作是在进入临界区之前，V操作是作用在离开临界区之后，这两个操作必须是成对出现的。

举个类比，2 个资源的信号量，相当于 2 条火车轨道，PV 操作如下图过程：

操作系统是如何实现PV操作的呢？

信号量数据结构与PV操作的算法描述如下图：

PV 操作的函数是由操作系统管理和实现的，所以操作系统已经使得执行 PV 函数时是具有原子性的。

PV操作是如何使用的呢？

信号量不仅可以实现临界区的互斥访问控制，还可以线程间的事件同步

信号量实现临界区的互斥访问

为每类共享资源设置一个信号量 s ，其初始值为 1 ，表示该临界资源未被占用。

只要把进入临界区的操作置于 P(s) 和 V(s) 之间，即可实现进程/线程互斥：

此时，任何想进入临界区的线程，必先在互斥信号量上执行 P 操作，在完成对临界资源的访问后再执行 V 操作。由于互斥信号量的初始值为 1 ，故在第一个线程执行 P 操作后 s 值变为 0，表示临界资源为空闲，可分配给该线程，使之进入临界区。

若此时又有第二个线程想进入临界区，也应先执行 P 操作，结果使 s 变为负值，这就意味着临界资源已被占用，因此第二个线程被阻塞。

并且，直到第一个线程执行 V 操作，释放临界资源而恢复 s 值为 0 后，才唤醒第二个线程，使之进入临界区，待它完成临界资源的访问后，又执行 V 操作，使 s 恢复到初始值 1 。

对于两个并发线程，互斥信号量的值仅取 1、0和-1三个值，分别表示：

如果互斥信号量为 1，表示没有线程进入临界区
如果互斥信号量为 0，表示有一个线程进入临界区
如果互斥信号量为 -1，表示一个线程进入临界区，另一个线程等待进入

通过互斥信号量，就能保证临界区任何时刻只有一个线程在执行，就达到了互斥的效果。

信号量实现事件同步

同步的方式是设置一个信号量，其初值为 0 。

妈妈一开始询问儿子要不要做饭时，执行的是 P(s1) ，相当于询问儿子需不需要吃饭，由于 s1 初始值为 0，此时 s1 变成 -1，表明儿子不需要吃饭，所以妈妈线程就进入等待状态。

当儿子肚子饿时，执行了 V(s1)，使得 s1 信号量从 -1 变成 0，表明此时儿子需要吃饭了，于是就唤醒了阻塞中的妈妈线程，妈妈线程就开始做饭。

接着，儿子线程执行了 P(s2)，相当于询问妈妈饭做完了吗，由于 s2 初始值是 0，则此时 s2 变成 -1，说明妈妈还没做完饭，儿子线程就等待状态。

最后，妈妈终于做完饭了，于是执行 V(s2)，s2 信号量从 -1 变回了 0，于是就唤醒等待中的儿子线程，唤醒后，儿子线程就可以进行吃饭了

生产者-消费者问题

生产者-消费者问题描述：

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

对问题分析可以得出：

任何时刻只能有一个线程操作缓冲区，说明操作缓冲区的是临界代码，需要互斥；
缓冲区空时，消费者必须等待生产者生成数据；缓冲区满时，生产者必须等待消费者取出数据。说明生产者和消费者需要同步。

那么我们需要三个信号量，分别是：

互斥信号量 mutex ：用于互斥访问缓冲区，初始化值为 1；
资源信号量 fullBuffers ：用于消费者询问缓冲区是否有数据，有数据则读取数据，初始值为 0（表明缓冲区一开始为空）；
资源信号量 emptyBuffers ：用于生产者询问缓冲区是否有空位，有空位则生成数据，初始化值为 n（缓冲区大小）；

具体实现代码：

如果消费者线程一开始执行 P(fullBuffers)，由于信号量 fullBuffers 初始值为 0，则此时 fullBuffers 的值从 0 变为 -1，说明缓冲区里没有数据，消费者只能等待。

接着，轮到生产者执行 P(fullBuffers)，表示减少 1 个空槽，如果当前没有其他生产者线程在临界区执行代码，那么生产者线程就可以把数据放到缓冲区，放完后，执行V(fullBuffers)，信号量 fullBuffers 从 -1 变成 0，表明有消费者线程正在阻塞等待数据，于是阻塞等待的消费者线程会被唤醒。

消费者线程被唤醒后，如果此时还没有其他消费者线程在读数据，那么就可以直接进入临界区，从缓冲区读取数据。最后，离开临界区，把空槽的个数 + 1。