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

2025-04-27 18:37:07 0 阅读

Linux学习笔记：

https://blog.csdn.net/2301_80220607/category_12805278.html?spm=1001.2014.3001.5482

前言：

在上篇我们已经学习了关于线程的大部分知识，包括线程概念和线程控制等内容，今天我们来学习一下使用线程要做到的很重要的一步，那就是要保证线程的同步与互斥，从而确保线程安全问题，我们将通过一些生活中的例子和代码示例来理解如何做到线程的互斥与同步

前提知识

线程的互斥

什么是线程的互斥

为什么需要线程的互斥

互斥的实现方法：互斥量

1. 互斥量的概念

2. 互斥量的接口函数

初始化与销毁

加锁与解锁

尝试加锁

3. 互斥量的使用

互斥锁实现互斥的原理

互斥量的使用场景

保护共享资源

避免竞态条件

互斥量的注意事项

死锁问题

性能开销

总结

前提知识

在深入探讨线程的互斥与同步之前，我们需要了解一些基本概念：

并发与并行：并发是指多个任务在同一时间段内交替执行，而并行是指多个任务在同一时刻同时执行。
临界区：临界区是指访问共享资源的代码段，这些资源在同一时刻只能被一个线程访问。
竞态条件：当多个线程同时访问共享资源时，如果对资源的访问顺序不确定，可能会导致程序的行为不可预测，这种情况称为竞态条件。

线程的互斥

什么是线程的互斥

互斥是指在同一时刻，只允许一个线程访问共享资源。互斥机制确保了一个线程在访问共享资源时，其他线程不能同时访问该资源，从而避免了竞态条件的发生。

为什么需要线程的互斥

在多线程编程中，多个线程可能会同时访问共享资源。如果没有互斥机制，可能会导致以下问题：

数据不一致：当多个线程同时修改共享数据时，可能会导致数据的不一致。例如，两个线程同时对一个变量进行自增操作，可能会导致最终结果不正确。
竞态条件：竞态条件是指程序的输出依赖于线程的执行顺序，这会导致程序的行为不可预测。

下面我们通过一个春节购票系统来看一下会有什么问题：

我们定义一个全局变量count=1000表示有1000张票，我们再创建四个新线程，这四个新线程执行抢票工作，主线程等待回收它们，抢票的逻辑具体分为以下三步：

1、先检查是否还有余票。if(count>0)

2、如果有余票就让count--，同时子线程返回抢票的那一步

3、如果没有余票就退出

#include
#include
#include
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
",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

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

初始化与销毁

pthread_mutex_init

用于初始化互斥量。

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：适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。

pthread_mutex_destroy

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

int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数：

mutex：指向互斥量的指针。

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

加锁与解锁

pthread_mutex_lock

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

int pthread_mutex_lock(pthread_mutex_t *mutex);

参数：

mutex：指向互斥量的指针。

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

pthread_mutex_unlock

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

int pthread_mutex_unlock(pthread_mutex_t *mutex);

参数：

mutex：指向互斥量的指针。

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

尝试加锁

pthread_mutex_trylock

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

int pthread_mutex_trylock(pthread_mutex_t *mutex);

参数：

mutex：指向互斥量的指针。

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

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

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

3. 互斥量的使用

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

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

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

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

#include
#include
#include
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
",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;
}

运行结果：