Linux-线程互斥和死锁

一.线程互斥

[1.1 进程线程间的互斥相关背景概念](#1.1 进程线程间的互斥相关背景概念)

[1.2 互斥量mutex](#1.2 互斥量mutex)

二.互斥量的接口

[2.1 初始化互斥量](#2.1 初始化互斥量)

[2.2 销毁互斥量](#2.2 销毁互斥量)

[2.3 互斥量加锁和解锁](#2.3 互斥量加锁和解锁)

[2.4 改进后售票代码](#2.4 改进后售票代码)

三.死锁

3.1.什么是死锁？

3.2.死锁四个必要条件

[3.3 避免死锁](#3.3 避免死锁)

一.线程互斥

1.1 进程线程间的互斥相关背景概念

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

1.2 互斥量mutex

大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。

但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。

多个线程并发的操作共享变量，会带来一些问题。

cpp 复制代码

// 操作共享变量会有问题的售票系统代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
int ticket = 100;
void *route(void *arg)
{
    char *id = (char *)arg;
    while (1)
    {
        if (ticket > 0)
        {
            usleep(1000);
            printf("%s sells ticket:%d\n", id, ticket);
            ticket--;
        }
        else
        {
            break;
        }
    }
}
int main(void)
{
    pthread_t t1, t2, t3, t4;
    pthread_create(&t1, NULL, route, "thread 1");
    pthread_create(&t2, NULL, route, "thread 2");
    pthread_create(&t3, NULL, route, "thread 3");
    pthread_create(&t4, NULL, route, "thread 4");
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
}

为什么结果会到负数？

if 语句判断条件为真以后，代码可以并发的切换到其他线程

usleep这个模拟漫长业务的过程，在这个漫长的业务过程中，可能有很多个线程会进入该代码段

--ticket操作本身就不是一个原子操作

cpp 复制代码

--操作的汇编代码
152 40064b: 8b 05 e3 04 20 00 mov 0x2004e3(%rip),%eax # 600b34 <ticket>
153 400651: 83 e8 01 sub $0x1,%eax
154 400654: 89 05 da 04 20 00 mov %eax,0x2004da(%rip) # 600b34 <ticket>

--操作并不是原子操作，而是对应三条汇编指令：

将共享变量ticket从内存加载到寄存器中

更新寄存器里面的值，执行-1操作

将新值，从寄存器写回共享变量ticket的内存地址

要解决以上问题，需要做到三点：

代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。

如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。

如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区。

要做到这三点，本质上就是需要一把锁。Linux上提供的这把锁叫互斥量。

二.互斥量的接口

2.1 初始化互斥量

Linux下

cpp 复制代码

//静态分配
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

//动态分配
pthread_mutex_t mutex;
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t
*restrict attr);

参数：
mutex：要初始化的互斥量
attr：NULL

C++(默认构造创建的时候就初始化了)

cpp 复制代码

std::mutex mu;

2.2 销毁互斥量

销毁互斥量需要注意：

不要销毁一个已经加锁的互斥量

使用PTHREAD_ MUTEX_ INITIALIZER初始化的互斥量不需要销毁

已经销毁的互斥量，要确保后面不会有线程再尝试加锁

cpp 复制代码

int pthread_mutex_destroy(pthread_mutex_t *mutex)；

在C++中，使用 <mutex> 标准库时，std::mutex 对象的销毁会自动发生 ，通常不需要手动干预。当 std::mutex 对象的生命周期结束时，其析构函数会被自动调用 ，这会释放它所持有的任何系统资源。这意味着，如果在函数中创建了一个局部 std::mutex 对象，或者当它的作用域结束时，析构函数会被调用。

2.3 互斥量加锁和解锁

cpp 复制代码

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值:成功返回0,失败返回错误号

cpp 复制代码

std::mutex mu;
mu.lock(); // 请求锁定
    
mu.unlock(); // 完成后解锁

调用pthread_ lock 时，可能会遇到以下情况:

互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功

发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那么pthread_ lock调用会陷入阻塞(执行流被挂起)，等待互斥量解锁。

2.4 改进后售票代码

cpp 复制代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>
int ticket = 100;
pthread_mutex_t mutex;
void *route(void *arg)
{
    char *id = (char *)arg;
    while (1)
    {
        pthread_mutex_lock(&mutex);
        if (ticket > 0)
        {
            usleep(1000);
            printf("%s sells ticket:%d\n", id, ticket);
            ticket--;
            pthread_mutex_unlock(&mutex);
            // sched_yield(); 放弃CPU
        }
        else
        {
            pthread_mutex_unlock(&mutex);
            break;
        }
    }
}
int main(void)
{
    pthread_t t1, t2, t3, t4;
    pthread_mutex_init(&mutex, NULL);

    pthread_create(&t1, NULL, route, (void *)"thread 1");
    pthread_create(&t2, NULL, route, (void *)"thread 2");
    pthread_create(&t3, NULL, route, (void *)"thread 3");
    pthread_create(&t4, NULL, route, (void *)"thread 4");

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
    pthread_mutex_destroy(&mutex);
}

三.死锁

3.1.什么是死锁？

死锁是指在一组进程中的各个进程均占有不会释放的资源 ，但因互相申请被其他进程所站用不会释放的资源而处于的一种永久等待状态。

3.2.死锁四个必要条件

互斥条件：一个资源每次只能被一个执行流使用

请求与保持条件：一个执行流因请求资源而阻塞时，对已获得的资源保持不放

不剥夺条件:一个执行流已获得的资源，在末使用完之前，不能强行剥夺

循环等待条件:若干执行流之间形成一种头尾相接的循环等待资源的关系

3.3 避免死锁

破坏死锁的四个必要条件

加锁顺序一致

避免锁未释放的场景

资源一次性分配