前言

进程间通信告诉我们，两个进程要想进行通信，就必须先看到一份临界资源。而对于临界资源的操作，管道是自带同步与互斥机制的。

假若我们对于一份临界资源不加某种限制的话，两个线程同时对其进行操作时，就可能会发生数据不一致的问题。

来举个例子：
在这里插入图片描述

今有一全局变量tickets，作为临界资源；有2个线程对于tickets进行操作：tickets++，假设tickets初始为0

thread1 执行tickets++时，会发生以下的事件：

tickets从内存拷贝到cpu寄存器
cpu++ tickets
cpu寄存器写回内存

但是我们知道，线程每次将数据放入cpu寄存器并进行运算的时候，都会有一个时间片，如果时间片到了，那么寄存器会保存上下文，该线程进入等待队列，等待下一次的载入寄存器。

当我们的thread1完成了++之后，此时时间片恰好到了，寄存器里的值（1）没有写回到内存，而此时，thread2来了，thread2看到的内存中的值并不是++后的（1）而是++前的（0），所以，thread2从0加到1，并把1写回到内存。
此时thread2时间片到了；thread1来了，thread1恢复上下文，并把1写回到内存。

最终，thread1和thread2虽然各++了一次，但是内存中的tickets值却是1

归根结底，造成这一切的罪魁祸首是thread1 执行cnt++还没结束，就因为时间片到了被切出去了，然后thread2对于临界资源cnt进行了修改

线程切换的时机：内核态返回用户态（比如进行系统调用就会发生内核态用户态的切换）

我们必须引入互斥量，对于临界资源的操作进行一定的限制

1.术语

临界资源：多线程执行流共享的资源就叫做临界资源
临界区：每个线程内部，访问临界资源的代码，就叫做临界区
互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用
原子性：不会被任何调度机制打断的操作，该操作只有两态：
- 要么完成
- 要么未完成

互斥量mutex

大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。
但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。
多个线程并发的操作共享变量，会带来一些问题。

2.买票案例

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#define NUM 5

using namespace std;

int tickets = 1000;
void* routine(void* args) {
  while(true) {
    if(tickets > 0) {
      usleep(1000);
      printf("thread NO.  0x%x get a ticket, %d left\n",  pthread_self(), tickets--);
      usleep(1000);
    }
    else {
      printf("0x%x qiut... ticket: %d\n", pthread_self(), tickets);
      break;
    }
  }
  return nullptr;
}
int main()
{
  pthread_t tids[NUM];
  for(int i = 0; i < NUM; i++) {
    pthread_create(tids+i, nullptr, routine, nullptr);
  }
  for(int i = 0; i < NUM; i++) {
    pthread_join(tids[i], nullptr);
  }
  return 0;
}

五个线程不加锁同时抢票，就会发生同时访问临界资源造成操作不一致的问题，票会被抢到负数

在这里插入图片描述

所以说，我们要让抢票这一过程变成原子的

做到原子需要满足：

代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区
如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区
如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区

我们直接加锁🔒！

接口：
创建🔒

pthread_mutex_t lock;

初始化🔒

pthread_mutex_init(&lock, nullptr);

加🔒

pthread_mutex_lock(&lock);

解🔒

pthread_mutex_unlock(&lock);

销毁🔒

pthread_mutex_destroy(&lock);

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#define NUM 5

using namespace std;

int tickets = 1000;
pthread_mutex_t lock;
struct arg{
  int x;
};
void* routine(void* args) {
  while(true) {
    pthread_mutex_lock(&lock);
    if(tickets > 0) {
      usleep(1000);
      printf("thread NO. %d 0x%x get a ticket, %d left\n", ((arg*)args)->x, pthread_self(), tickets--);
      usleep(1000);
      pthread_mutex_unlock(&lock);
    }
    else {
      printf("0x%x qiut... ticket: %d\n", pthread_self(), tickets);
      pthread_mutex_unlock(&lock);
      break;
    }
  }
  return nullptr;
}
int main()
{

  pthread_mutex_init(&lock, nullptr);
  arg* arg1 = new arg;
  arg1->x = 1;
  pthread_t tids[NUM];
  for(int i = 0; i < NUM; i++) {
    pthread_create(tids+i, nullptr, routine, arg1);
  }
  for(int i = 0; i < NUM; i++) {
    pthread_join(tids[i], nullptr);
  }
  pthread_mutex_destroy(&lock);
  return 0;
}

加锁带来的是我们对于临界资源的操作变成原子的：

在这里插入图片描述

3.互斥锁的本质

我们有没有想过，锁既然能被所有线程看到，那么是不是就是说锁本身就是一个临界资源，那么既然如此，也就是说，申请锁/释放锁的操作本身就是原子的。那这是如何实现的呢？

为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的总线周期也有先后,一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。lock和unlock的汇编伪代码：

在这里插入图片描述

%al是一个寄存器的值，也就是上下文数据，是线程私有的
mutex是一个内存中的一个存储空间，空间里的值是1
exchange是一条汇编指令，保证加锁的原子性

整个过程中，值为1的mutex只有一份，拿到1的线程才拿到了锁🔒
一条exchange汇编就能完成内存和寄存器的数据的交换
mutex_lock是原子的

我们来看一下如果申请锁的时候分别在1、2、3步线程切出去会怎么样：

把0赋给al寄存器：这步切出去没什么影响，寄存器一开始保存的就是随机值
交换内存单元中锁（值为1）与寄存器（值为0）的值：由于该步一条exchange汇编指令就能完成，交换完之后，代表锁的1就到了寄存器里，锁里装了0。假如切出去了，其他线程也到了这一步想来申请锁，执行了exchange指令，没关系，你执行好了，反正1已经被上一个线程换走了，你换到的还是0，所以if判断不成立，挂起等待
在if判断的时候切出去，更没什么影响了，由于1只能被一个线程拿到，所以只有一个线程能执行if成功后的语句。其他线程此时只能因为if判断失败等着被别人解锁后唤醒，唤醒后竞争锁。

4.可重入与线程安全

线程安全：多个线程并发同一段代码时，不会出现不同的结果。常见对全局变量或者静态变量进行操作，并且没有锁保护的情况下，会出现该问题。
重入：同一个函数被不同的执行流调用，当前一个流程还没有执行完，就有其他的执行流再次进入，我们称之为重入。一个函数在重入的情况下，运行结果不会出现任何不同或者任何问题，则该函数被称为可重入函数，否则，是不可重入函数。