【Linux从入门到精通】多线程 | 线程互斥（互斥锁）

🙋‍♂️ 作者：@Ggggggtm 🙋‍♂️

👀 专栏：Linux从入门到精通 👀

💥 标题：线程互斥💥

** ❣️ 寄语：与其忙着诉苦，不如低头赶路，奋路前行，终将遇到一番好风景 ❣️**

引入

我们先看一段多线程抢票的代码：

int tickets=10000;

void* getTickets(void* args)
{
    while(true)
    {
        if(tickets>0)
        {
            usleep(1000);
            printf("%s: %d\n",(char*)args,tickets);
            tickets--;
        }
        else
            break;
    }

    return nullptr;
}
int main( void )
{
    srand(time(nullptr));
    pthread_t t1, t2, t3, t4;
    pthread_create(&t1, NULL, getTickets, (void*)"thread 1");
    pthread_create(&t2, NULL, getTickets, (void*)"thread 2");
    pthread_create(&t3, NULL, getTickets, (void*)"thread 3");
    pthread_create(&t4, NULL, getTickets, (void*)"thread 4");

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);

    return 0;
}

上述代码就是创建了四个新线程同时去抢票，当票数为0时，就停止抢票。那我们看一下运行结果：

怎么票数会被抢到负数呢？上述代码明明就是在票数为0的时候就终止了。这是为什么呢？我们接着往下看。

一、重入与临界

1、1 可重入与不被重入函数

我们先看下图：

上图就是一个链表的节点插入。我们之前学的是单进程进行链表的插入，也就是但是执行流进行的插入。当然，但执行流是没有任何问题。如果现在有多个执行流在执行链表的插入呢？会不会出现意想不到的问题呢？我们看如下情况。

main函数调用insert函数向一个链表head中插入节点node1,插入操作分为两步,刚做完第一步的时候,因为硬件中断使进程切换到内核,再次回用户态之前检查到有信号待处理,于是切换 到sighandler函数,sighandler也调用insert函数向同一个链表head中插入节点node2,插入操作的 两步都做完之后从sighandler返回内核态,再次回到用户态就从main函数调用的insert函数中继续 往下执行,先前做第一步之后被打断,现在继续做完第二步。结果是,main函数和sighandler先后 向链表中插入两个节点,而最后只有一个节点真正插入链表中了。我们发现就出现了一个节点的丢失。

1、1、1 不可重入函数

不可重入函数（Non-reentrant Function），它在被多个任务并发调用时可能会出现竞争条件（Race Condition）或数据不一致的问题。

在上述情况中，我们发现插入节点的函数被多个执行流执行时，发生了意想不到的错误，出现了数据丢失的问题。我们称之为该函数不可被重入。

1、1、2 可重入函数

可重入函数（Reentrant Function）是指可以被同时多个任务调用而不会发生错误或产生意外结果的函数。换句话说，可重入函数在被多个任务并发调用时，能够保持其内部状态的一致性。我们所学的大部分函数都是不可被重入的。

1、2 临界资源与临界区

1、2、1 临界资源

临界资源（Critical Resource）是指在并发编程中，多个任务或线程之间共享的某一资源，但同时只能被一个任务或线程访问和操作的资源。

1、2、2 临界区

临界区（Critical Section）是指代码中访问临界资源的那一部分代码段或区域。在临界区内部，任务或线程可以对临界资源进行读取、写入或其他操作。因为临界资源只能被一个任务或线程访问，所以必须确保在任何时刻只有一个任务或线程能够进入临界区，以避免对临界资源造成竞争条件和不确定的结果。

这里先给大家把概念引出，后面会再次结合例子来解释临界资源与临界区。

1、3 原子性

其实我们也不难发现上述情况问题的所在。一是有多个执行流在执行同一个操作。因为当一个进程在运行时，任何时刻都有可能被切换下去，去执行另一个进程。二是插入操作分为多个步骤完成。两点一结合，就是在插入没有完成的时候该执行流就被切换走了，进而导致出现问题。原子性是一个操作没有中间的状态。就是一个操作要执行就执行结束，要不就不执行，没有其他的状态。加入插入操作是原子性的，也就不会发生数据错误。

二、 线程互斥

2、1 分析原因与再次理解概念

上面我们了解了重入与临界的概念后，我们再看引入中抢票的例子。抢票例子是多线程进行抢票。也就是有多个执行流在进行抢票。我们以为tickets--在CPU內部直接减1就完了吗？实际上并不是。具体如下图：

假设线程1抢票时，此时票好有10000张。

于是就进行判断，打印。刚打印完，把tickets=10000读到寄存器中，还没有抢票（tickets--），该线程的时间片到了被切换下去。此时线程1的上下文会被保存起来。然后线程2被调度。

由于各种原因，线程2的优先级较高。线程二就行行疯狂抢票。一下子抢了1000多张票。然后线程2被切换下去，线程1重新被调度。操作系统会先回复线程1的上下文数据。此时CPU拿到的tickets又变成了10000，线程1再进行抢票。此时就出现了CPU与内存中的数据错乱的问题。

我们再看tickets--。这也正是tickets能够变成负数的原因。当一个tickets==1时，发现能够抢票。当时刚执行完打印，也就是并没有抢票就被切换下去了，此时该线程也并没有保存tickets数据。同时其它线程被切换上来进行抢票后，票数变为0。再次恢复之前被切换下去的下线程，此时已经没票了，但是该线程以为还有票，于是当把tickets数据读到寄存器中后（tickets为0），进行计算--操作，再次写入内存票数就变成了负数。

上述讲解了两种出现错误的情况。针对上述例子，我们再来看一下临界资源和临界区：

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

• load ：将共享变量ticket从内存加载到寄存器中
• update : 更新寄存器里面的值，执行-1操作
• store ：将新值，从寄存器写回共享变量ticket的内存地址

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

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

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

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

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

2、2 互斥锁

什么是锁？在Linux操作系统中，锁（Lock）是一种同步机制，用于保护共享资源免受多个并发线程访问和修改的干扰。锁可以防止多个线程同时访问或修改共享资源，从而确保对共享资源的安全访问。

2、2、1 什么是互斥锁

当有一个线程申请互斥锁资源，也就是加锁成功后，其他线程就不会申请锁资源成功。其他线程也就会进入阻塞等待状态。可以理解为把其他线程阻塞在外面了，不能有多个线程同时执行去申请互斥锁。这就是线程互斥。同一个线程不能执行互斥锁内的资源，同时只有一个线程能够执行。当进行对锁资源释放，也就是解锁后，其他线程才可申请锁资源。

2、2、2 pthread_mutex_t

pthread_mutex_t是一个用于实现线程同步的互斥量类型，也就是我们所说的互斥锁的类型。pthread_mutex_t可以用来保护共享资源，防止多个线程同时访问和修改数据而导致的竞争条件。使用pthread_mutex_t时，通常需要进行以下步骤：初始化、加锁、解锁、销毁。

下面对每个步骤进行详细解释，并提供一个示例代码：

1. 初始化互斥锁： 可以使用pthread_mutex_init函数来初始化互斥锁。初始化后的互斥锁状态为未锁定状态。示例代码：pthread_mutex_t mutex; // 定义互斥锁变量// 初始化互斥锁int result = pthread_mutex_init(&mutex, NULL);if (result != 0) { // 初始化失败的处理逻辑}
2. 加锁： 使用pthread_mutex_lock函数可以将互斥锁设置为锁定状态，如果互斥锁已被其他线程锁定，当前线程会进入阻塞状态，直到获取到锁。示例代码：// 加锁int result = pthread_mutex_lock(&mutex);if (result != 0) { // 加锁失败的处理逻辑}
3. 解锁： 使用pthread_mutex_unlock函数可以将互斥锁设置为未锁定状态，释放锁供其他线程使用。示例代码：// 解锁int result = pthread_mutex_unlock(&mutex);if (result != 0) { // 解锁失败的处理逻辑}
4. 销毁互斥锁： 在不再需要使用互斥锁时，可以使用pthread_mutex_destroy函数来销毁已初始化的互斥锁。示例代码：// 销毁互斥锁int result = pthread_mutex_destroy(&mutex);if (result != 0) { // 销毁失败的处理逻辑}

注意事项：

• pthread_mutex_t的初始化应该在使用前完成，并且应该确保互斥锁变量的作用域覆盖了所有对该锁的访问。

• 对于每个加锁操作，都应该有对应的解锁操作，以避免资源泄漏和死锁的情况发生。

• 建议在使用互斥锁时考虑锁的粒度，尽量保持锁的范围小并且锁的持有时间短，以提高并发性能。

  后面也会对注意事项接进行解释。线面我们先来看一下对pthread_mutex_t 进行初始化处理操作的详解。其他操作简单，就不再解释。

2、2、3 pthread_mutex_init 初始化

pthread_mutex_init函数是一个用于初始化互斥锁的函数，它的原型如下：

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

该函数主要用于将传入的mutex指向的互斥锁对象进行初始化，使其可以正确地使用。

参数说明：

• mutex：指向要初始化的互斥锁对象的指针。

• attr：指向包含互斥锁属性的对象的指针。可以通过该参数来设置互斥锁的属性，如果为NULL，则使用默认属性。

  返回值：

• 若成功，返回0；

• 若失败，返回错误代码。

  调用pthread_mutex_init函数会对互斥锁进行初始化，包括分配内存和设定默认属性。属性我们一般选择传入nullptr，就是默认属性。

当pthread_mutex_t 对象为全局时，我们也可选择不用 pthread_mutex_init 进行初始化。可直接使用宏：PTHREAD_MUTEX_INITIALIZER来初始化。代码如下：

pthread_mutex_t mtx=PTHREAD_MUTEX_INITIALIZER;

2、3 抢票加互斥锁

我们对抢票的临界区加锁，这样就不会出现多个执行流去访问临界资源的情况了。

代码如下：

int tickets=10000;
pthread_mutex_t mtx=PTHREAD_MUTEX_INITIALIZER;

void* getTickets(void* args)
{
    while(true)
    {
        pthread_mutex_lock(&mtx);
        if(tickets>0)
        {
            usleep(1000);
            printf("%s: %d\n",(char*)args,tickets);
            tickets--;
            pthread_mutex_unlock(&mtx);
        }
        else
        {
            pthread_mutex_unlock(&mtx);
            break;
        }
        usleep(rand()%2000);
    }

    return nullptr;
}
int main( void )
{
    srand(time(nullptr));
    pthread_t t1, t2, t3, t4;
    pthread_create(&t1, NULL, getTickets, (void*)"thread 1");
    pthread_create(&t2, NULL, getTickets, (void*)"thread 2");
    pthread_create(&t3, NULL, getTickets, (void*)"thread 3");
    pthread_create(&t4, NULL, getTickets, (void*)"thread 4");

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);

    return 0;
}

我们再看运行结果：

上述代码是定义全局变量的互斥锁。我们再来看一下局部变量的互斥锁是怎么使用的。代码如下：

#define THREAD_NUM 5

int tickets=10000;

class ThreadData
{
public:
    ThreadData(const string& n,pthread_mutex_t* pm)
        :tname(n)
        ,pmtx(pm)
    {}

public:
    string tname;
    pthread_mutex_t* pmtx;
};

void* getTickets(void* args)
{
    ThreadData* data=(ThreadData*) args;
    while(true)
    {
        pthread_mutex_lock(data->pmtx);
        if(tickets>0)
        {
            usleep(1000);
            printf("%s: %d\n",data->tname.c_str(),tickets);
            tickets--;
            pthread_mutex_unlock(data->pmtx);
        }
        else
        {
            pthread_mutex_unlock(data->pmtx);
            break;
        }
        usleep(rand()%2000);
    }

    return nullptr;
}
int main( void )
{
    srand(time(nullptr));
    pthread_t t1, t2, t3, t4;

    pthread_mutex_t mtx;

    pthread_mutex_init(&mtx,nullptr);
    pthread_t t[THREAD_NUM];
    // 多线程抢票的逻辑
    for(int i = 0; i < THREAD_NUM; i++)
    {
        std::string name = "thread ";
        name += std::to_string(i+1);
        ThreadData *td = new ThreadData(name, &mtx);
        pthread_create(t + i, nullptr, getTickets, (void*)td);
    }

    for(int i = 0; i < THREAD_NUM; i++)
    {
        pthread_join(t[i], nullptr);
    }

    pthread_mutex_destroy(&mtx);
    return 0;
}

2、4 互斥锁总结

加锁就是串行执行了吗?答案是是的。任何时候只允许申请锁成功的线程执行临界区代码。因为变为串行执行，所以我们要在加锁的时候，一定要保证加锁的粒度，越小越好！！！不必要的代码可放在锁外。

** 加锁了之后，线程在临界区中，是否会切换，会有问题吗？答案是会被切换的。但是并不会出现问题**。虽然被切换了，但是你是持有锁被切换的，所以其他抢票线程要执行临界区代码，也必须先申请锁，锁它是无法申请成功的，所以也不会让其他线程进入临界区，就保证了临界区中数据一致性！！！只要一个线程，且需要访问临界资源，就必须申请锁。

在没有持有锁的线程看来，对我最有意义的情况只有两种:1.线程1没有持有锁(什么都没做)）2．线程1释放锁(做完)，此时我可以申请锁！！！

要访问临界资源，每一个线程都必须现申请锁，每一个线程都必须先看到同一把锁且访问它，锁本身不就是一种共享资源吗！！！那么谁来保证锁的安全呢?所以为了保证锁的安全，申请和释放锁，必须是原子性的。所以是由它自己自己保证。那么是怎么保证的呢？

三、互斥锁实现原理

经过上面的例子，大家已经意识到单纯的 i++ 或者 ++i 都不是原子的，有可能会有数据一致性问题。

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

具体可结合下图理解：

其实我们也不难发现，申请互斥锁资源的在底层本质就是一个交换指令。而交换的本质就是使其在内存中的共享资源变成了线程的私有资源！！！当交换后值为1时，就说明申请互斥锁资源成功。从头到尾，一直是在交换，一直是只有一个1。所以保证了只有一个线程能够申请互斥锁资源成功。