🍑个人主页：Jupiter. 🚀 所属专栏：Linux从入门到进阶 欢迎大家点赞收藏评论😊

---

🦅Linux线程互斥

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

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

🦌互斥锁mutex

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

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

下面是一个：操作共享变量会有问题的售票系统代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

int ticket = 10;

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;
        }
    }
    return nullptr;
}
int main(void)
{
    pthread_t t1, t2, t3, t4;

    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);

    return 0;
}

运行结果：

为什么可能无法获得争取结果？

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

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

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

取出ticket- -部分的汇编代码

objdump -d a.out > test.objdump 
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>

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

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

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

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

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

🐒互斥锁的接口

初始化互斥锁

• 方法1，静态分配（定义一把静态或则全局的锁）:
  pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER
• 方法2，动态分配（局部的锁）:
  int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
  参数：
  • mutex：要初始化的互斥锁
  • attr：NULL

销毁互斥量

• 销毁互斥量需要注意：
  • 使用 PTHREAD_ MUTEX_ INITIALIZER 初始化的互斥锁不需要销毁
  • 不要销毁一个已经加锁的互斥锁
  • 已经销毁的互斥锁，要确保后面不会有线程再尝试加锁

int pthread_mutex_destroy(pthread_mutex_t *mutex)；

互斥量加锁和解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);

• 申请锁成功，函数返回，允许继续向后运行。
• 申请锁失败，函数阻塞，不允许向后运行。
• 函数调用失败，出错返回。

int pthread_mutex_unlock(pthread_mutex_t *mutex);

• 返回值:成功返回0,失败返回错误号

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

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

改进上面的售票系统:

int ticket = 100;

// 定义一个全局的锁
pthread_mutex_t mutex = PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP;

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);
        }
        else{
            pthread_mutex_unlock(&mutex);
            break;
        }
    }
    return nullptr;
}

int main(void){
    pthread_t t1, t2, t3, t4;

    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);

    return 0;
}

运行结果:加锁后没有出现减到负数的情况。

🐗RAII风格的加锁解锁

#ifndef __LOCK_GUARD_HPP__
#define __LOCK_GUARD_HPP__

#include <pthread.h>
#include <iostream>

class LockGuard
{
public:
    LockGuard(pthread_mutex_t *mutex) : _mutex(mutex)
    {
        pthread_mutex_lock(_mutex);
    }

    ~LockGuard()
    {
        pthread_mutex_unlock(_mutex);
    }

private:
    pthread_mutex_t *_mutex;
};

#endif

🐬互斥锁实现原理探究

经过上面的例子，已经意识到单纯的i++ 或者 ++i都不是原子的，有可能会有数据一致性问题为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的总线周期也有先后,一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。 现在我们把lock和unlock的伪代码改一下，下面mutex的初始值为1，

---