【多线程】线程互斥 {竞态条件，互斥锁的基本用法，pthread_mutex系列函数，互斥锁的原理；死锁；可重入函数和线程安全}

2023-10-30 16:36
文章标签 互斥 线程 条件 函数 安全 多线程 系列 原理 用法 基本 死锁 pthread mutex 重入 竞态

本文主要是介绍【多线程】线程互斥 {竞态条件，互斥锁的基本用法，pthread_mutex系列函数，互斥锁的原理；死锁；可重入函数和线程安全}，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一、进程线程间通信的相关概念

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

二、互斥锁

2.1 竞态条件

  • 大部分情况，线程使用的数据都是局部变量，变量存储在线程栈空间内。这种情况，变量归属单个线程，其他线程无法访问这种变量。
  • 但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。比如，全局数据、堆空间数据。
  • 多个线程并发的操作共享变量，会带来数据竞争，冲突以及数据不一致等竞态条件问题。

竞态条件：

  • 竞态条件（Race Condition）是指多个线程或进程同时访问共享资源，并且对资源的访问顺序不确定，导致最终结果的正确性依赖于线程执行的具体时序。竞态条件可能导致不可预测的结果，破坏程序的正确性和一致性。
  • 竞态条件通常发生在多个线程或进程同时对共享资源进行读写操作时，其中至少一个是写操作。当多个线程或进程同时读写共享资源时，由于执行顺序的不确定性，可能会导致数据的不一致性、丢失、覆盖等问题。

测试程序：

int tickets = 100; //共有100张票void *ThreadRoutine(void *name)
{while (1){if (tickets > 0){usleep(rand() % 1000); // 模拟业务过程花费的时间printf("%s sells ticket:%d\n", (char *)name, tickets);--tickets;}else{break;}usleep(rand() % 1000); // 模拟处理其他业务花费的时间}return nullptr;
}int main()
{srand((unsigned)time(nullptr));pthread_t tid1, tid2, tid3, tid4;pthread_create(&tid1, nullptr, ThreadRoutine, (void *)"child thread 1");pthread_create(&tid2, nullptr, ThreadRoutine, (void *)"child thread 2");pthread_create(&tid3, nullptr, ThreadRoutine, (void *)"child thread 3");pthread_create(&tid4, nullptr, ThreadRoutine, (void *)"child thread 4");pthread_join(tid1, nullptr);pthread_join(tid2, nullptr);pthread_join(tid3, nullptr);pthread_join(tid4, nullptr);return 0;
}

运行结果：

在这里插入图片描述

  1. 同一编号的票被多个线程售出
  2. 某些线程售出了负数编号的票

该程序存在竞态条件问题，即公共变量tickets被多执行流同时访问和修改。

提示：除了多线程进程外，信号处理函数也是异步执行的（多执行流执行），同样存在竞态条件问题。

并发运行问题

例如：tickets > 0和--tickets操作并不是原子性操作，而是对应三条汇编指令：

  1. 将数据从内存加载到寄存器（当前线程的上下文中）
  2. 进行逻辑运算或算数运算
  3. 将数据写回内存

在这三条步骤的其中任何一步，该线程都有可能被切换，切换前线程上下文会被保存。其他线程在执行时也对tickets进行了访问和修改。当原线程再次被CPU调度执行时，恢复上下文数据，此时的寄存器与内存就会发生数据不一致的错误。

并行运行问题

多核CPU允许多线程并行（同时）运行。在ThreadRoutine函数中，由于没有对访问tickets的操作进行互斥，可能会导致多个线程同时读取和修改tickets变量，从而产生不可预测的结果。

例如：当多个线程同时执行if (tickets > 0)语句时，可能会出现以下情况：

  • 线程A和线程B同时读取tickets的值为1。
  • 线程A先执行--tickets操作，将tickets的值减为0。
  • 线程B再执行--tickets操作，将tickets的值减为-1。

这样，就会出现某些线程售出了负数编号的票。

2.2 互斥锁的基本用法

为了解决竞态条件问题，可以使用互斥锁（Mutex）来保护对tickets变量的访问。互斥锁可以确保在同一时间只有一个线程能够访问临界区（对tickets变量的访问），从而避免数据竞争的发生。

在这里插入图片描述

下面是互斥锁的基本使用方法：

  1. 定义互斥锁变量：在使用互斥锁之前，需要先定义一个互斥锁变量。可以使用pthread_mutex_t类型来声明互斥锁变量，例如：pthread_mutex_t mutex;
  2. 初始化互斥锁：在使用互斥锁之前，需要对互斥锁进行初始化。
    • 静态初始化：在定义互斥锁变量时，使用PTHREAD_MUTEX_INITIALIZER宏进行初始化。
    • 动态初始化：可以使用pthread_mutex_init函数来初始化互斥锁，例如：pthread_mutex_init(&mutex, NULL);。第一个参数是要初始化的互斥锁变量，第二个参数是互斥锁的属性，通常使用NULL表示使用默认属性；
  3. 加锁：在访问共享资源之前，需要先加锁。可以使用pthread_mutex_lock函数来加锁，例如：pthread_mutex_lock(&mutex);。如果互斥锁已经被其他线程锁定，那么当前线程会被阻塞，直到互斥锁被解锁。
  4. 访问共享资源：在互斥锁被锁定的情况下，可以安全地串行访问共享资源。
  5. 解锁：在访问共享资源完成后，需要解锁互斥锁，以便其他线程可以继续访问共享资源。可以使用pthread_mutex_unlock函数来解锁，例如：pthread_mutex_unlock(&mutex);。
  6. 销毁互斥锁：
    • 不再需要使用互斥锁时，需要将其销毁。可以使用pthread_mutex_destroy函数来销毁互斥锁，例如：pthread_mutex_destroy(&mutex);。
    • 静态初始化的互斥锁在程序结束时会自动被系统回收，无需手动销毁。
    • 不要销毁一个已经加锁的互斥量
    • 对于已经销毁的互斥量，要确保后面不会有线程再尝试加锁

我们将上面的售票程序加入互斥锁：

int tickets = 100; //临界资源
// 定义一个全局的互斥锁变量，并利用宏进行初始化（静态初始化）
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;void *ThreadRoutine(void *name)
{while (1){// 在访问共享资源之前，需要先加锁。pthread_mutex_lock(&mtx);//临界区if (tickets > 0){usleep(rand() % 1000); // 模拟业务过程花费的时间printf("%s sells ticket:%d\n", (char *)name, tickets);--tickets;// 在访问共享资源完成后，需要解锁互斥锁。pthread_mutex_unlock(&mtx);}else{// 在访问共享资源完成后，需要解锁互斥锁。pthread_mutex_unlock(&mtx);break;}// 在此处解锁？不行，如果线程执行break，就不会解锁互斥锁。其他线程会被一直阻塞。usleep(rand() % 1000); // 模拟处理其他业务花费的时间}return nullptr;
}

运行结果：

在这里插入图片描述

需要注意的几点：

  1. 在访问共享资源完成后，需要解锁互斥锁。否则，其他线程会被一直阻塞。需要特别注意break, goto等跳转语句跳过解锁函数。

  2. 被互斥锁锁定的临界区只能串行执行（互斥访问），虽然保证了多执行流访问临界资源的安全性，但是会在一定程度上降低程序的效率。

  3. 尽量保证被互斥锁锁定的代码都是访问临界资源的代码，不要将其他无关的操作也放入临界区中。因为相比并发或并行执行，临界区串行执行的效率较低。

再次改进上面的代码：

#define THREAD_NUM 5
int tickets = 100;//声明一个ThreadData类，使线程入口函数的参数更多样化。
class ThreadData
{
public:string _tname; //线程名pthread_mutex_t *_pmtx; //互斥锁变量的地址ThreadData(const string &tname, pthread_mutex_t *pmtx): _tname(tname),_pmtx(pmtx){};
};void *ThreadRoutine(void *arg)
{ThreadData *td = (ThreadData *)arg;while (1){// 在访问临界资源前进行加锁pthread_mutex_lock(td->_pmtx);if (tickets > 0){usleep(rand() % 1000); // 模拟业务过程花费的时间printf("%s sells ticket:%d\n", td->_tname.c_str(), tickets);--tickets;// 不再访问临界资源时需要解锁。pthread_mutex_unlock(td->_pmtx);}else{// 不再访问临界资源时需要解锁。pthread_mutex_unlock(td->_pmtx);break;}usleep(rand() % 1000); // 模拟处理其他业务花费的时间}delete td; // 释放各自的ThreadData结构空间return nullptr;
}int main()
{srand((unsigned)time(nullptr));// 在主线程栈区创建互斥锁变量pthread_mutex_t mtx;// 调用pthread_mutex_init初始化互斥锁（动态初始化）pthread_mutex_init(&mtx, nullptr);// 循环创建子线程pthread_t tid[THREAD_NUM];for (int i = 0; i < THREAD_NUM; ++i){string tmp = "child thread ";tmp += to_string(i + 1);ThreadData *td = new ThreadData(tmp, &mtx);pthread_create(tid + i, nullptr, ThreadRoutine, td); //传入ThreadData对象的指针}// 循环等待子线程for (int i = 0; i < THREAD_NUM; ++i){pthread_join(tid[i], nullptr);}// 在不再需要使用互斥锁时，需要将其销毁。（动态初始化的互斥锁需要进行销毁，而静态初始化不需要）pthread_mutex_destroy(&mtx);return 0;
}

新的问题：

  1. 加锁了之后，线程在执行临界区代码时，是否会被切换，会有问题吗?
    会被切换，但不会有问题！虽然被切换了，但是你是持有锁被切换的, 所以其他抢票线程要执行临界区代码，也必须先申请锁，而它是无法申请成功的。所以，也不会让其他线程进入临界区，就保证了临界区中数据一致性！

  2. 对于访问临界资源的线程而言，临界区代码要么全部执行成功，要么全部不执行，访问临界资源的操作不可被中断（不能同时执行其他线程的临界区代码），这就是原子性的体现。

  3. 要访问临界资源，每一个线程都必须先申请锁，而锁本身就是一种共享资源，那么谁来保证锁的安全呢？

    所以，为了保证锁的安全，申请和释放锁，必须是原子的！

2.3 互斥锁的原理

  1. 在汇编层面，一条汇编语句要么已经执行完，要么就还没有执行，是原子性的。
  2. 为了实现互斥锁操作，大多数体系结构都提供了swap或exchange汇编指令，该指令的作用是把寄存器和内存单元的数据相交换，由于只有一条指令，保证了原子性。即使是多处理器平台（并行），访问内存的总线周期也有先后，一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。
  3. CPU的寄存器数据，本质就是当前执行流的上下文。寄存器的存储空间被所有执行流共享，但是寄存器的内容是被每一个执行流私有的。所以在切换线程时，要将当前线程的寄存器数据保存到其PCB中，并恢复下一个线程的寄存器数据。

以下是加锁的核心汇编伪代码：

lock:movb $0, %al // 将数值0，move到al寄存器中xchgb %al, mutex //交换al寄存器与mutex变量（内存）的数据if(al寄存器的内容 > 0){return 0;}else挂起等待;goto lock; //跳转到lock标签，再次申请锁
  1. 我们可以将互斥锁变量mutex理解成一个整形变量，值为1表示互斥锁未被线程持有；值为0，表示互斥锁已经被其他线程锁定。创建互斥锁变量并进行初始化后，其默认值为1。
  2. 由于exchange汇编指令是原子的，所以不管线程如何切换，只有一个线程能够将mutex（内存）中的1值交换到自己的寄存器当中，即该线程的上下文中。而线程上下文是线程的私有数据，实现了公有到私有的转换。同时寄存器当中的0值被交换到了mutex中，其他线程再进行交换也只能交换到0。
  3. 在进行if判断时，交换到1值的线程执行return 0，可以安全地进入临界区访问临界资源；而交换到0值的线程阻塞等待，直到互斥锁被解锁，这些线程才会被唤醒，然后再次尝试申请锁。

以下是解锁的核心汇编伪代码：

unlock:movb $1, mutex //将数值1，move到mutex变量（内存）唤醒等待mutex的线程;return 0;
  1. 当持有锁的线程访问完临界资源后，会将mutex变量重新置为1，即解锁互斥锁。
  2. 同时，应该唤醒等待互斥锁解锁的线程，让他们再次竞争申请锁。

回答之前的问题：

  1. 谁来保证锁的安全呢？

    为了保证锁的安全，申请和释放锁，必须是原子的！在设计加锁时，通过一条原子性的exchange指令，保证了加锁和解锁的原子性。

  2. 加锁了之后，线程在临界区中，是否会切换，会有问题吗?

    线程在临界区中也可能会被切换，但他是持有锁被切换的，所谓持有锁切换是指互斥锁的1值保存在当前线程的上下文，被当前线程私有。而其他线程即使被CPU调度执行，也无法抢占互斥锁，也就无法访问临界区代码。所以不会有任何问题。

三、可重入函数和线程安全

  • 可重入函数：同一个函数被多个执行流同时进入，就叫重入。如果该函数在被重入执行的过程中不会出现任何错误，则被称为可重入函数。反之就是不可重入函数。
  • 线程安全：多个线程并发执行时，在没有锁保护的情况下访问了共享资源（如全局或静态变量，堆区数据等），会出现数据竞争从而导致数据冲突，数据不一致等线程安全问题。

3.1 线程安全的情况

  1. 仅使用本地（局部）数据，或者通过制作全局数据的本地拷贝来保护全局数据。
  2. 使用互斥锁（Mutex）来保护对共享资源的访问。互斥锁可以确保在同一时间只有一个线程能够访问临界区，从而避免数据竞争的发生。
  3. 每个线程对共享资源只有读取的权限，而没有写入的权限，一般来说这些线程是安全的。
  4. 不调用线程不安全的函数

3.2 可重入函数的情况

  1. 仅使用本地（局部）数据，或者通过制作全局数据的本地拷贝来保护全局数据。
  2. 使用互斥锁（Mutex）来保护对共享资源的访问。如全局、静态变量或其他共享资源。
  3. 不调用不可重入函数

常见不可重入的情况

  1. 调用了malloc/free函数，因为Linux内核是用全局链表和全局红黑树结构来组织和管理堆空间的。（请看提示）
  2. 调用了标准I/O库函数，因为标准I/O库的很多实现都以不可重入的方式使用了全局数据结构。

提示：

  1. 关于Linux内核中的堆区管理，请阅读：【多线程】线程的概念 {Linux内核中的堆区管理；虚拟地址到物理地址的转换，页，页框，页表，MMU内存管理单元；Linux线程概念，轻量级进程；线程共享进程的资源；线程的优缺点；线程的用途}-CSDN博客
  2. 关于多执行流调用不可重入函数插入链表节点，请阅读：【信号】信号处理 {信号处理的时机；内核态和用户态；信号捕捉的原理；信号处理函数：signal, sigaction；可重入函数；volatile关键字；SIGCHLD信号}-CSDN博客

3.3 区别和联系

联系

  1. 函数是可重入的，那就是线程安全的。
  2. 函数是不可重入的，那就不能由多个线程使用，有可能引发线程安全问题。

区别

  1. 可重入函数是线程安全函数的一种。
  2. 线程安全不一定是可重入的，而可重入函数则一定是线程安全的。
  3. 如果将对临界资源的访问加上锁，则这个函数是线程安全的。但如果这个重入函数加锁还未释放则会产生死锁，因此是不可重入的。

四、死锁

死锁（Deadlock）是指在并发系统中，两个或多个进程（或线程）因为互相等待对方释放资源而无法继续执行的状态。在死锁状态下，进程无法前进，也无法释放资源，导致系统无法正常运行。

死锁通常发生在多个进程（或线程）同时竞争有限的资源时，每个进程都在等待其他进程释放资源，而自己又无法释放已经占有的资源。

在这里插入图片描述

特殊情况：一个执行流，一把互斥锁也可能导致死锁，即加锁后，不解锁，再次申请锁。

死锁的发生需要满足以下四个条件，也被称为死锁的必要条件：

  1. 互斥条件：一个资源每次只能被一个执行流使用（不加锁自然就不会产生死锁）。

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

  3. 不剥夺条件：一个执行流已获得的资源，在未使用完之前，不能强行剥夺。

  4. 循环等待条件：若干执行流之间形成一种头尾相接的循环等待资源的关系，使得每个执行流都在等待下一个执行流所占有的资源。

当这四个条件同时满足时，就可能发生死锁。一旦发生死锁，系统将无法自动解除死锁状态，需要通过人工干预来解决。

为了避免死锁的发生，可以采取以下策略：

  1. 破坏互斥条件：例如，允许多个进程（或线程）同时访问某些资源。

  2. 破坏请求与保持条件：例如，要求进程（或线程）在执行之前一次性获取所有需要的资源，否则在等待资源时释放已经占有的资源。

  3. 破坏不可剥夺条件：例如，允许系统强制剥夺某些进程（或线程）的资源。

  4. 破坏循环等待条件：例如，通过对资源进行排序，按照固定的顺序申请资源，避免交叉申请，循环等待。（T1,T2都先申请R1再申请R2）

  5. 其他方法：精简临界区代码，缩短持有锁的时间；合并临界区，资源一次性分配（一把锁）；

死锁是并发系统中的一个重要问题，对系统的性能和可靠性有很大影响。因此，在设计和实现并发系统时，需要合理地分配和管理资源，以避免死锁的发生。

这篇关于【多线程】线程互斥 {竞态条件，互斥锁的基本用法，pthread_mutex系列函数，互斥锁的原理；死锁；可重入函数和线程安全}的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

原文地址:
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.chinasem.cn/article/309203。

相关文章

Python中help()和dir()函数的使用

Python中help()和dir()函数的使用

《Python中help()和dir()函数的使用》我们经常需要查看某个对象（如模块、类、函数等）的属性和方法,Python提供了两个内置函数help()和dir(),它们可以帮助我们快速了解代... 目录1. 引言2. help() 函数2.1 作用2.2 使用方法2.3 示例(1) 查看内置函数的帮助(
阅读更多...
mapstruct中的@Mapper注解的基本用法

mapstruct中的@Mapper注解的基本用法

《mapstruct中的@Mapper注解的基本用法》在MapStruct中,@Mapper注解是核心注解之一,用于标记一个接口或抽象类为MapStruct的映射器（Mapper）,本文给大家介绍ma... 目录1. 基本用法2. 常用属性3. 高级用法4. 注意事项5. 总结6. 编译异常处理在MapSt
阅读更多...
Python中使用uv创建环境及原理举例详解

Python中使用uv创建环境及原理举例详解

《Python中使用uv创建环境及原理举例详解》uv是Astral团队开发的高性能Python工具,整合包管理、虚拟环境、Python版本控制等功能,：本文主要介绍Python中使用uv创建环境及... 目录一、uv工具简介核心特点：二、安装uv1. 通过pip安装2. 通过脚本安装验证安装：配置镜像源（可
阅读更多...
C++ 函数 strftime 和时间格式示例详解

C++ 函数 strftime 和时间格式示例详解

《C++函数strftime和时间格式示例详解》strftime是C/C++标准库中用于格式化日期和时间的函数,定义在ctime头文件中,它将tm结构体中的时间信息转换为指定格式的字符串,是处理... 目录C++ 函数 strftipythonme 详解一、函数原型二、功能描述三、格式字符串说明四、返回值五
阅读更多...
java中long的一些常见用法

java中long的一些常见用法

《java中long的一些常见用法》在Java中,long是一种基本数据类型,用于表示长整型数值,接下来通过本文给大家介绍java中long的一些常见用法,感兴趣的朋友一起看看吧... 在Java中，long是一种基本数据类型，用于表示长整型数值。它的取值范围比int更大，从-922337203685477
阅读更多...
SQL中JOIN操作的条件使用总结与实践

SQL中JOIN操作的条件使用总结与实践

《SQL中JOIN操作的条件使用总结与实践》在SQL查询中,JOIN操作是多表关联的核心工具,本文将从原理,场景和最佳实践三个方面总结JOIN条件的使用规则,希望可以帮助开发者精准控制查询逻辑... 目录一、ON与WHERE的本质区别二、场景化条件使用规则三、最佳实践建议1.优先使用ON条件2.WHERE用
阅读更多...
MyBatis ResultMap 的基本用法示例详解

MyBatis ResultMap 的基本用法示例详解

《MyBatisResultMap的基本用法示例详解》在MyBatis中,resultMap用于定义数据库查询结果到Java对象属性的映射关系,本文给大家介绍MyBatisResultMap的基本... 目录MyBATis 中的 resultMap1. resultMap 的基本语法2. 简单的 resul
阅读更多...
Python主动抛出异常的各种用法和场景分析

Python主动抛出异常的各种用法和场景分析

《Python主动抛出异常的各种用法和场景分析》在Python中,我们不仅可以捕获和处理异常,还可以主动抛出异常,也就是以类的方式自定义错误的类型和提示信息,这在编程中非常有用,下面我将详细解释主动抛... 目录一、为什么要主动抛出异常？二、基本语法：raise关键字基本示例三、raise的多种用法1. 抛
阅读更多...
Java中实现线程的创建和启动的方法

Java中实现线程的创建和启动的方法

《Java中实现线程的创建和启动的方法》在Java中,实现线程的创建和启动是两个不同但紧密相关的概念,理解为什么要启动线程（调用start()方法）而非直接调用run()方法,是掌握多线程编程的关键,... 目录1. 线程的生命周期2. start() vs run() 的本质区别3. 为什么必须通过 st
阅读更多...
Java死锁问题解决方案及示例详解

Java死锁问题解决方案及示例详解

《Java死锁问题解决方案及示例详解》死锁是指两个或多个线程因争夺资源而相互等待,导致所有线程都无法继续执行的一种状态,本文给大家详细介绍了Java死锁问题解决方案详解及实践样例,需要的朋友可以参考下... 目录1、简述死锁的四个必要条件：2、死锁示例代码3、如何检测死锁？3.1 使用 jstack3.2
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2