【Linux探索学习】第三十弹——线程互斥与同步（上）：深入理解线程保证安全的机制

#include<iostream>
#include<pthread.h>
#include<unistd.h>
using namespace std;

int count=1000;

void *GetTickets(void *args)
{
    int thread_id = (int)(intptr_t)args; // 获取线程ID
    while(1)
    {
        if(count>0)
        {
            usleep(10000);   //模拟购票准备工作所需时间
            printf("[pthread %d] get a picket, the picket number: %d\n",thread_id,count);
            --count;
        }
        else
        {
            //如果没票，直接退出
            break;
        }
    }
    return nullptr;
}
int main()
{
    //创建四个新线程
    pthread_t tids[4];
    for(int i=0;i<4;i++)
    {
        pthread_create(&tids[i],nullptr,GetTickets,(void*)(intptr_t)(i+1));
    }
    //阻塞等待回收线程
    for(int i=0;i<4;i++)
    {
        pthread_join(tids[i],nullptr);
    }
    return 0;
}

执行结果（只截取了最后几行）：

我们发现出现了错误，按照逻辑票应该是一张一张减少的，而且最终票数到0之后就不能再购买了，但是这里多购买了三张，那么原因是什么呢？

该错误是由以下两个原因组成的：

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

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

简单点来说就是在一个线程执行购票过程的时候，其它线程也可能会进入进行购票，因为线程是并发执行的，最终就可能会导致票数已经为0了，但是有些进程已经在票数为0前进入到if判断中了，就可能导致以上问题

根本原因就是--操作并不是原子的（简单来说并不是一次完成的），而是对应三条汇编指令：

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

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

store ：将新值，从寄存器写回共享变量ticket的内存地址
要解决以上问题，需要做到三点：

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

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

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

要做到以上三点，本质上就是需要一把锁，在一个线程进入临界区时将临界区的入口锁住不让其它线程进入，Linux提供的这个锁叫做互斥量

互斥的实现方法：互斥量

1. 互斥量的概念

互斥量是一种用于多线程编程的同步机制，用于确保同一时刻只有一个线程可以访问共享资源。互斥量的核心思想是通过加锁（Lock）和解锁（Unlock）操作来控制对共享资源的访问，从而避免多个线程同时修改共享资源导致的数据不一致或竞态条件。

互斥量通常用于保护临界区，即访问共享资源的代码段。当一个线程进入临界区时，它会先加锁；当线程离开临界区时，它会解锁，允许其他线程进入。

2. 互斥量的接口函数

1、互斥量的接口函数头文件都是 #include<pthread.h>

2、返回值都是：成功返回0，失败返回相应的错误码

初始化与销毁

cpp 复制代码

pthread_mutex_init

用于初始化互斥量。

cpp 复制代码

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

参数：

mutex：指向互斥量的指针。

attr：互斥量属性，通常设置为NULL以使用默认属性。

返回值 ：成功返回0，失败返回错误码。

PTHREAD_MUTEX_TIMED_NP：这时默认值，也就是普通锁。当一个线程加锁以后，其它申请该锁的线程组成一个资源等待队列，并在解锁后按优先级获得锁。这种解锁策略保证了资源分配的公平性。
PTHREAD_MUTEX_RECURSIVE_NP：嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁后重新竞争。
PTHREAD_MUTEX_ERRORCHECK_NP：检错锁，如果同一个线程请求同一个锁，则返回EDEADLK错误，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时，不会出现最简单情况下的死锁。
PTHREAD_MUTEX_ADAPTIVE_NP：适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。

cpp 复制代码

pthread_mutex_destroy

用于销毁互斥量，释放相关资源。

cpp 复制代码

int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数：

mutex：指向互斥量的指针。

返回值 ：成功返回0，失败返回错误码。

加锁与解锁

cpp 复制代码

pthread_mutex_lock

用于加锁互斥量。如果互斥量已被其他线程锁定，当前线程会被阻塞，直到互斥量被解锁。

cpp 复制代码

int pthread_mutex_lock(pthread_mutex_t *mutex);

参数：

mutex：指向互斥量的指针。

返回值 ：成功返回0，失败返回错误码。

cpp 复制代码

pthread_mutex_unlock

用于解锁互斥量，允许其他线程加锁。

cpp 复制代码

int pthread_mutex_unlock(pthread_mutex_t *mutex);

参数：

mutex：指向互斥量的指针。

返回值 ：成功返回0，失败返回错误码。

尝试加锁

cpp 复制代码

pthread_mutex_trylock

尝试加锁互斥量。如果互斥量已被其他线程锁定，函数立即返回，不会阻塞当前线程。

cpp 复制代码

int pthread_mutex_trylock(pthread_mutex_t *mutex);

参数：

mutex：指向互斥量的指针。

返回值 ：成功返回0，失败返回错误码（如EBUSY表示互斥量已被锁定）。

在锁的初始化上除了上面用函数来初始化外，我们也可以直接初始化：

这种初始化的方法叫做静态初始化，它将锁的声明、定义和初始化全部完成了，而且这样初始化的锁最后也不需要我们手动销毁

3. 互斥量的使用

我们使用一把互斥锁来对我们上面的购票系统进行一下加工：

首先我们先定义一个全局的互斥量，因为多个线程都要使用，定义全局的可以提高效率

主线程对所进行初始化，然后等待子线程都执行完后，回收子线程并且销毁锁

子线程在进入临界区时加锁，出临界区时解锁

cpp 复制代码

#include<iostream>
#include<pthread.h>
#include<unistd.h>
using namespace std;

int count=1000;
pthread_mutex_t mutex;

void *GetTickets(void *args)
{
    int thread_id = (int)(intptr_t)args; // 获取线程ID
    while(1)
    {
        //进入临界区时加锁
        pthread_mutex_lock(&mutex);
        if(count>0)
        {
            usleep(10000);   //模拟购票准备工作所需时间
            printf("[pthread %d] get a picket, the picket number: %d\n",thread_id,count);
            --count;
            pthread_mutex_unlock(&mutex);    //买完票后退出重新进入购票队列，并把锁释放
        }
        else
        {
            //如果没票，直接退出
            pthread_mutex_unlock(&mutex);
            break;
        }
    }
    return nullptr;
}
int main()
{
    //创建新线程前先把锁初始化了
    pthread_mutex_init(&mutex,nullptr);
    //创建四个新线程
    pthread_t tids[4];
    for(int i=0;i<4;i++)
    {
        pthread_create(&tids[i],nullptr,GetTickets,(void*)(intptr_t)(i+1));
    }
    //阻塞等待回收线程
    for(int i=0;i<4;i++)
    {
        pthread_join(tids[i],nullptr);
    }
    //线程都回收后把锁也销毁了
    pthread_mutex_destroy(&mutex);
    return 0;
}