【Linux】线程互斥

【Linux】线程互斥
文章目录
- 线程互斥
  互斥量 mutex
  初始化互斥量
  加锁与解锁
  
  可重入和线程安全
  常见的线程安全情况
  常见的线程安全的情况
  常见的不可重入情况
  常见的可重入情况
  可重入与线程安全联系
  可重入与线程安全区别
  
  死锁
  死锁的四个必要条件
  避免死锁
线程互斥

进程线程间的互斥相关背景概念
- 临界资源： 多线程执行流共享的资源叫做临界资源。
- 临界区： 每个线程内部，访问临界资源的代码，就叫做临界区。
- 互斥： 任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用。
- 原子性： 不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成。
注：临界资源可能会因为多个线程同时访问这块资源导致数据错乱。
```
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
 
// int 票数计数器
int tickets = 1000; // 临界资源，可能会因为共同访问，造成数据不一致的问题
 
void *getTickets(void *args)
{
    const char *name = static_cast<const char *>(args);
    while (true)
    {
        // 临界区
        if (tickets > 0)
        {
            usleep(1000);
            cout << name << " 抢到了票, 票的编号: " << tickets << endl;
            tickets--;
        }else
        {
            break;
        }
    }
    return nullptr;
}
int main()
{
    pthread_t tid1;
    pthread_t tid2;
    pthread_t tid3;
    pthread_t tid4;
    pthread_create(&tid1, nullptr, getTickets, (void *)"thread 1");//线程1
    pthread_create(&tid2, nullptr, getTickets, (void *)"thread 2");//线程2
    pthread_create(&tid3, nullptr, getTickets, (void *)"thread 3");//线程3
    pthread_create(&tid4, nullptr, getTickets, (void *)"thread 4");//线程4
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    pthread_join(tid4,NULL);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
```
可以看到，明明就设置了1000张票，怎么会出现编号为-1、-2的票呢？

这是因为tickets--的操作不是原子性的，而是分为三个步骤：
1. 将共享变量tickets从内存加载到寄存器中
2. 更新寄存器里面的值执行-1操作
3. 将新值从寄存器写回共享变量tickets的内存地址
汇编代码如下：

既然–操作要经历三个步骤才能完成那么有可能thread1刚刚把1000读进cpu就被切换了

当该线程被切换的时候会保存它对应的上下文信息 1000这个数据当然也在里面之后thread1被挂起。

之后我们的thread2进程就被调度了因为当thread1被切换的时候内存中的tickek值并没有被改变所以说thread2看到的值还是1000

我们假设thread2的竞争性比较强它执行了100次之后才被切换那么此时的ticket的值就由1000变成了900。

当thread2切换挂起之后我们的thread1回来继续执行此时恢复它的上下文数据

由于上次保存时它寄存器中的数据是1000 所以说再经历23两步操作之后变为999之后加载到内存中

于是内存中的数据便从900变成999了相当于此时多了1000张票。

从上面的流程中我们可以看出 --ticket这个操作并不是原子性的

那么我们如何解决上面的问题呢？

其实思路很简单我们只需要将--ticket这个操作变成原子性的就好了

那么怎么将它变成原子性的呢？我们的策略是加锁。

互斥量 mutex

要解决如上的问题就得做到以下三点：
- 代码必须有互斥行为：当代码进入临界区执行时不允许其他线程进入该临界区
- 如果多个线程同时要求执行临界区的代码并且此时临界区没有线程在执行那么只能允许一个线程进入该临界区
- 如果线程不在临界区中执行那么该线程不能阻止其他线程进入临界区
我们可以使用如下代码来定义一个互斥量。
```
pthread_mutex_t mutex;
1
```
初始化互斥量
```
#include 
 
int pthread_mutex_destroy(pthread_mutex_t *mutex);
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
       const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
1
2
3
4
5
6
```
- 返回值：成功返回0，失败返回错误号。
pthread_mutex_init函数对Mutex做初始化，参数attr设定Mutex的属性，如果attr为NULL则表示缺省属性。用pthread_mutex_init函数初始化的Mutex可以用pthread_mutex_destroy销毁。如果Mutex变量是静态分配的（全局变量或static变量），也可以用宏定义PTHREAD_MUTEX_INITIALIZER来初始化，相当于用pthread_mutex_init初始化并且attr参数为NULL。

加锁与解锁
```
#include 
 
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
1
2
3
4
5
```
- 返回值：成功返回0，失败返回错误号。
一个线程可以调用pthread_mutex_lock获得Mutex，如果这时另一个线程已经调用pthread_mutex_lock获得了该Mutex，则当前线程需要挂起等待，直到另一个线程调用pthread_mutex_unlock释放Mutex，当前线程被唤醒，才能获得该Mutex并继续执行。

如果一个线程既想获得锁，又不想挂起等待，可以调用pthread_mutex_trylock，如果Mutex已经被另一个线程获得，这个函数会失败返回EBUSY，而不会使线程挂起等待。
```
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
 
// int 票数计数器
int tickets = 1000; // 临界资源，可能会因为共同访问，造成数据不一致的问题
//pthread_mutex_t Mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t Mutex;
void *getTickets(void *args)
{
    const char *name = static_cast<const char *>(args);
    while (true)
    {
        pthread_mutex_lock(&Mutex);
        // 临界区
        if (tickets > 0)
        {
            usleep(100);
            cout << name << " 抢到了票, 票的编号: " << tickets << endl;
            tickets--;
        }else
        {
            break;
        }
        pthread_mutex_unlock(&Mutex);
    }
    return nullptr;
}
int main()
{
    pthread_mutex_init(&Mutex,NULL);
    pthread_t tid1;
    pthread_t tid2;
    pthread_t tid3;
    pthread_t tid4;
    pthread_create(&tid1, nullptr, getTickets, (void *)"thread 1");//线程1
    pthread_create(&tid2, nullptr, getTickets, (void *)"thread 2");//线程2
    pthread_create(&tid3, nullptr, getTickets, (void *)"thread 3");//线程3
    pthread_create(&tid4, nullptr, getTickets, (void *)"thread 4");//线程4
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    pthread_join(tid4,NULL);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
```
这样就不会出现票数小于等于0的情况了，但是为什么一直都是thread 4抢到票呢？其他的线程为什么不能抢票？

这是因为锁的钥匙已经被线程4早早地拿走了，其他线程没有钥匙是打不开锁的，就只能在锁区域外等候。

锁是否需要被保护呢？

锁是不许要被保护的，因为从汇编层面保证了加锁是原子性的，争夺锁只有两种可能，要么拿到了，要么没有拿到。

为了实现互斥锁的操作，大多数体系结构都提供了swap或exchange指令该指令的作用就是把寄存器和内存单元的数据相交换。
以加锁示例，这是由多态汇编语句执行的，上述%al是寄存器，mutex就是内存中的一个变量。每个线程申请锁时都要执行上述语句，执行步骤如下：
- （movb $0，%al）先将al寄存器中的值清0。该动作可以被多个线程同时执行，因为每个线程都有自己的一组寄存器（上下文信息），执行该动作本质上是将自己的al寄存器清0。注意：凡是在寄存器中的数据，全部都是线程的内部上下文！多个线程看起来同时在访问寄存器，但是互不影响。
- （xchgb %al，mutex）然后用此一条指令交换al寄存器和内存中mutex的值，xchgb是体系结构提供的交换指令，该指令可以完成寄存器和内存单元之间数据的交换。
- 最后判断al寄存器中的值是否大于0。若大于0则申请锁成功，此时就可以进入临界区访问对应的临界资源；否则申请锁失败需要被挂起等待，直到锁被释放后再次竞争申请锁。
- 示例：假设内存中有一个变量mutex为1，cpu内部有%al寄存器，我们有threadA和threadB俩线程，
**示例：**现在线程A要开始加锁，执行上述语句。首先（movb $0，%al），线程A把0读进al寄存器（清0寄存器），然后执行第二条语句（xchgb %al，mutex），将al寄存器中的值与内存中mutex的值进行交换。
- 交换完成后，寄存器al的值为1，内存中mutex的值为0。此时这个过程就是加锁
- 当线程A争议执行第三条语句if判断时，发生了线程切换（切至线程B），但是线程A要把自己的上下文（1）带走。线程B也要执行加锁动作，同样是第一条语句把0加载到寄存器，清0寄存器。
- 随后线程B执行第二条语句交换动作，可是mutex的数据先前已经被线程A交换至寄存器，然后保存到线程A的上下文了，现在的mutex为0，而线程B执行交换动作，拿寄存器al的0去换内存中mutex的0。
即使我线程A在执行第一条语句把寄存器清0后就发生了线程切换（切至线程B），线程A保存上下文数据（0），此时线程B执行第一条语句把0写进寄存器，随后线程B执行第二条语句xchgb交换：

此时线程A执行第三条语句if判断失败，只能被挂起等待，线程A只能把自己的上下文数据保存，重新切换至线程B，也就是说我线程B只要不运行，你们其它所有线程都无法申请成功。线程B恢复上下文数据（1）到内存，然后执行第三条语句if成功，返回结果

**注意：**上述xchgb就是申请锁的过程。申请锁是将数据从内存交换到寄存器，本质就是将数据从共享内存变成线程私有。
- mutex就是内存里的全局变量，被所有线程共享，但是一旦用一条汇编语句将内存的mutex值交换到寄存器，寄存器内部是哪个线程使用，那么此mutex就是哪个线程的上下文数据，那么就意味着交换成功后，其它任何一个线程都不可能再申请锁成功了，因为mutex已经独属于某线程私有了。
- 这个mutex = 1就如同令牌一般，哪个线程先交换拿到1，那么哪个线程就能申请锁成功，所以加锁是原子的
- 当线程释放锁时，需要执行以下步骤：
1. 将内存中的mutex置回1。使得下一个申请锁的线程在执行交换指令后能够得到1，形象地说就是“将锁的钥匙放回去”。
2. 唤醒等待Mutex的线程。唤醒这些因为申请锁失败而被挂起的线程，让它们继续竞争申请锁。
总结：
- 在申请锁时本质上就是哪一个线程先执行了交换指令，那么该线程就申请锁成功，因为此时该线程的al寄存器中的值就是1了。而交换指令就只是一条汇编指令，一个线程要么执行了交换指令，要么没有执行交换指令，所以申请锁的过程是原子的。
- 在线程释放锁时没有将当前线程al寄存器中的值清0，这不会造成影响，因为每次线程在申请锁时都会先将自己al寄存器中的值清0，再执行交换指令。
- CPU内的寄存器不是被所有的线程共享的，每个线程都有自己的一组寄存器，但内存中的数据是各个线程共享的。申请锁实际就是，把内存中的mutex通过交换指令，原子性的交换到自己的al寄存器中。
可重入和线程安全
- 线程安全：多个线程并发同一段代码时不会出现不同的结果常见对全局变量或者静态变量进行操作并且没有锁保护的情况下会出现线程安全问题
- 重入：同一个函数被不同的执行流调用当前一个流程还没有执行完就有其他的执行流再次进入我们称之为重入一个函数在重入的情况下运行结果不会出现任何不同或者任何问题则该函数被称为可重入函数否则是不可重入函数
常见的线程安全情况
- 不保护共享变量的函数
- 函数状态随着被调用状态发生变化的函数
- 返回指向静态变量指针的函数
- 调用线程不安全函数的函数
常见的线程安全的情况
- 每个线程对全局变量或者静态变量只有读取的权限而没有写入的权限一般来说这些线程是安全的
- 类或者接口对于线程来说都是原子操作
- 多个线程之间的切换不会导致该接口的执行结果存在二义性
常见的不可重入情况
- 调用了malloc/free函数因为malloc函数是用全局链表来管理堆的
- 调用了标准I/O库函数标准I/O可以的很多实现都是以不可重入的方式使用全局数据结构
- 可重入函数体内使用了静态的数据结构
常见的可重入情况
- 不使用全局变量或静态变量
- 不使用malloc或者new开辟出的空间
- 不调用不可重入函数
- 不返回静态或全局数据所有数据都由函数的调用者提供
- 使用本地数据或者通过制作全局数据的本地拷贝来保护全局数据
可重入与线程安全联系
- 函数是可重入的那就是线程安全的
- 函数是不可重入的那就不能由多个线程使用有可能引发线程安全问题
- 如果一个函数中有全局变量那么这个函数既不是线程安全也不是可重入的
可重入与线程安全区别
- 可重入函数是线程安全函数的一种
- 线程安全不一定是可重入的而可重入函数则一定是线程安全的
- 如果对临界资源的访问加上锁则这个函数是线程安全的但如果这个重入函数的锁还未释放则会产生死锁因此是不可重入的
死锁

一般情况下，如果同一个线程先后两次调用lock，在第二次调用时，由于锁已经被占用，该线程会挂起等待别的线程释放锁，然而锁正是被自己占用着的，该线程又被挂起而没有机会释放锁，因此就永远处于挂起等待状态了，这叫做死锁（Deadlock）。另一种典型的死锁情形是这样：线程A获得了锁1，线程B获得了锁2，这时线程A调用lock试图获得锁2，结果是需要挂起等待线程B释放锁2，而这时线程B也调用lock试图获得锁1，结果是需要挂起等待线程A释放锁1，于是线程A和B都永远处于挂起状态了。

写程序时应该尽量避免同时获得多个锁，如果一定有必要这么做，则有一个原则：如果所有线程在需要多个锁时都按相同的先后顺序（常见的是按Mutex变量的地址顺序）获得锁，则不会出现死锁。比如一个程序中用到锁1、锁2、锁3，它们所对应的Mutex变量的地址是锁1<锁2<锁3，那么所有线程在需要同时获得2个或3个锁时都应该按锁1、锁2、锁3的顺序获得。如果要为所有的锁确定一个先后顺序比较困难，则应该尽量使用pthread_mutex_trylock调用代替pthread_mutex_lock调用，以免死锁。

Case1：因为自己拿了锁，又去申请这把锁，导致死锁了。
```
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
 
// int 票数计数器
int tickets = 1000; // 临界资源，可能会因为共同访问，造成数据不一致的问题
//pthread_mutex_t Mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t Mutex;
void *getTickets(void *args)
{
    const char *name = static_cast<const char *>(args);
    while (true)
    {
        pthread_mutex_lock(&Mutex);
        pthread_mutex_lock(&Mutex);
        // 临界区
        if (tickets > 0)
        {
            usleep(100);
            cout << name << " 抢到了票, 票的编号: " << tickets << endl;
            tickets--;
        }else
        {
            break;
        }
        pthread_mutex_unlock(&Mutex);
        pthread_mutex_unlock(&Mutex);
    }
    return nullptr;
}
int main()
{
    pthread_mutex_init(&Mutex,NULL);
    pthread_t tid1;
    pthread_create(&tid1, nullptr, getTickets, (void *)"thread 1");//线程1
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    pthread_join(tid4,NULL);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
```
Case2：互相申请对方的锁。
```
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
 
// int 票数计数器
int tickets = 1000; // 临界资源，可能会因为共同访问，造成数据不一致的问题
pthread_mutex_t Mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t Mutex1=PTHREAD_MUTEX_INITIALIZER;
void *getTickets(void *args)
{
    const char *name = static_cast<const char *>(args);
    while (true)
    {
        pthread_mutex_lock(&Mutex);
        sleep(1);
        pthread_mutex_lock(&Mutex1);
        // 临界区
        if (tickets > 0)
        {
            usleep(100);
            cout << name << " 抢到了票, 票的编号: " << tickets << endl;
            tickets--;
        }else
        {
            break;
        }
        pthread_mutex_unlock(&Mutex1);
        pthread_mutex_unlock(&Mutex);
    }
    return nullptr;
}

void *getTickets1(void *args)
{
    const char *name = static_cast<const char *>(args);
    while (true)
    {
        pthread_mutex_lock(&Mutex1);
        sleep(1);
        pthread_mutex_lock(&Mutex);
        // 临界区
        if (tickets > 0)
        {
            usleep(100);
            cout << name << " 抢到了票, 票的编号: " << tickets << endl;
            tickets--;
        }else
        {
            break;
        }
        pthread_mutex_unlock(&Mutex);
        pthread_mutex_unlock(&Mutex1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid1;
    pthread_t tid2;
    pthread_create(&tid1, nullptr, getTickets, (void *)"thread 1");//线程1
    pthread_create(&tid2, nullptr, getTickets1, (void *)"thread 2");//线程2
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
```
死锁的四个必要条件
- 互斥条件：一个资源每次只能被一个执行流使用
- 请求与保持条件：一个执行流因请求资源而阻塞时对已获得的资源保持不放
- 不剥夺条件：一个执行流已获得的资源在未使用完之前不能强行剥夺
- 循环等待条件：若干执行流之间形成一种头尾相接的循环等待资源的关系
注意这是四个必要条件也就是说四个条件全部满足才能够形成死锁

 避免死锁
- 破坏死锁的四个必要条件。
- 加锁顺序一致
- 避免锁未释放的场景
- 资源一次性分配
相关阅读:
WebSocket
MacOs下安装Kong网关
 Leetcode 16.07 最大数值
 OpenCV实现模板匹配和霍夫线检测，霍夫圆检测
 面向对象——抽象类
 实习day1
Linux 小技巧1
虚拟机如何连接MobaXterm
线上教育系统平台，企业如何才能运营呢？
Nuxt - [高效简洁] 路由不存在时，跳转到自己定制的 404.vue 页面（当路由不存在时自动重定向到自定义的 404 组件）路由配置的解决方案
原文地址：https://blog.csdn.net/2301_79516932/article/details/134477793

文章目录

线程互斥

互斥量 mutex

初始化互斥量

加锁与解锁

可重入和线程安全

常见的线程安全情况

常见的线程安全的情况

常见的不可重入情况

常见的可重入情况

可重入与线程安全联系

可重入与线程安全区别

死锁

死锁的四个必要条件

避免死锁