当前位置： 首页 > news >正文

【Linux】线程互斥

news 来源：原创 2024/5/13 7:29:20

文章目录

    • 线程互斥
    • 互斥量 mutex
      • 初始化互斥量
      • 加锁与解锁
    • 可重入和线程安全
      • 常见的线程安全情况
      • 常见的线程安全的情况
      • 常见的不可重入情况
      • 常见的可重入情况
      • 可重入与线程安全联系
      • 可重入与线程安全区别
    • 死锁
      • 死锁的四个必要条件
      • 避免死锁

线程互斥

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

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

注：临界资源可能会因为多个线程同时访问这块资源导致数据错乱。

#include <iostream>
#include <cstring>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/syscall.h>
using namespace std;// int 票数计数器
int tickets = 1000; // 临界资源，可能会因为共同访问，造成数据不一致的问题void *getTickets(void *args)
{const char *name = static_cast<const char *>(args);while (true){// 临界区if (tickets > 0){usleep(1000);cout << name << " 抢到了票, 票的编号: " << tickets << endl;tickets--;}else{break;}}return nullptr;
}
int main()
{pthread_t tid1;pthread_t tid2;pthread_t tid3;pthread_t tid4;pthread_create(&tid1, nullptr, getTickets, (void *)"thread 1");//线程1pthread_create(&tid2, nullptr, getTickets, (void *)"thread 2");//线程2pthread_create(&tid3, nullptr, getTickets, (void *)"thread 3");//线程3pthread_create(&tid4, nullptr, getTickets, (void *)"thread 4");//线程4pthread_join(tid1,NULL);pthread_join(tid2,NULL);pthread_join(tid3,NULL);pthread_join(tid4,NULL);return 0;
}

可以看到，明明就设置了1000张票，怎么会出现编号为-1、-2的票呢？

这是因为tickets--的操作不是原子性的，而是分为三个步骤：

  1. 将共享变量tickets从内存加载到寄存器中
  2. 更新寄存器里面的值 执行-1操作
  3. 将新值从寄存器写回共享变量tickets的内存地址

汇编代码如下：

既然–操作要经历三个步骤才能完成 那么有可能thread1刚刚把1000读进cpu就被切换了

当该线程被切换的时候会保存它对应的上下文信息 1000这个数据当然也在里面 之后thread1被挂起。

在这里插入图片描述

之后我们的thread2进程就被调度了 因为当thread1被切换的时候内存中的tickek值并没有被改变 所以说thread2看到的值还是1000

我们假设thread2的竞争性比较强 它执行了100次之后才被切换 那么此时的ticket的值就由1000变成了900。

当thread2切换挂起之后我们的thread1回来继续执行 此时恢复它的上下文数据

由于上次保存时它寄存器中的数据是1000 所以说再经历23两步操作之后变为999之后加载到内存中

于是内存中的数据便从900变成999了 相当于此时多了1000张票。

从上面的流程中我们可以看出 --ticket这个操作并不是原子性的

那么我们如何解决上面的问题呢？

其实思路很简单 我们只需要将--ticket这个操作变成原子性的就好了

那么怎么将它变成原子性的呢？ 我们的策略是加锁。

互斥量 mutex

要解决如上的问题就得做到以下三点：

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

我们可以使用如下代码来定义一个互斥量。

pthread_mutex_t mutex;

初始化互斥量

#include <pthread.h>int pthread_mutex_destroy(pthread_mutex_t *mutex);
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  • 返回值：成功返回0，失败返回错误号。

pthread_mutex_init函数对Mutex做初始化，参数attr设定Mutex的属性，如果attr为NULL则表示缺省属性。用pthread_mutex_init函数初始化的Mutex可以用pthread_mutex_destroy销毁。如果Mutex变量是静态分配的（全局变量或static变量），也可以用宏定义PTHREAD_MUTEX_INITIALIZER来初始化，相当于用pthread_mutex_init初始化并且attr参数为NULL。

加锁与解锁

#include <pthread.h>int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
  • 返回值：成功返回0，失败返回错误号。

一个线程可以调用pthread_mutex_lock获得Mutex，如果这时另一个线程已经调用pthread_mutex_lock获得了该Mutex，则当前线程需要挂起等待，直到另一个线程调用pthread_mutex_unlock释放Mutex，当前线程被唤醒，才能获得该Mutex并继续执行。

如果一个线程既想获得锁，又不想挂起等待，可以调用pthread_mutex_trylock，如果Mutex已经被另一个线程获得，这个函数会失败返回EBUSY，而不会使线程挂起等待。

#include <iostream>
#include <cstring>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/syscall.h>
using namespace std;// int 票数计数器
int tickets = 1000; // 临界资源，可能会因为共同访问，造成数据不一致的问题
//pthread_mutex_t Mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t Mutex;
void *getTickets(void *args)
{const char *name = static_cast<const char *>(args);while (true){pthread_mutex_lock(&Mutex);// 临界区if (tickets > 0){usleep(100);cout << name << " 抢到了票, 票的编号: " << tickets << endl;tickets--;}else{break;}pthread_mutex_unlock(&Mutex);}return nullptr;
}
int main()
{pthread_mutex_init(&Mutex,NULL);pthread_t tid1;pthread_t tid2;pthread_t tid3;pthread_t tid4;pthread_create(&tid1, nullptr, getTickets, (void *)"thread 1");//线程1pthread_create(&tid2, nullptr, getTickets, (void *)"thread 2");//线程2pthread_create(&tid3, nullptr, getTickets, (void *)"thread 3");//线程3pthread_create(&tid4, nullptr, getTickets, (void *)"thread 4");//线程4pthread_join(tid1,NULL);pthread_join(tid2,NULL);pthread_join(tid3,NULL);pthread_join(tid4,NULL);return 0;
}

这样就不会出现票数小于等于0的情况了，但是为什么一直都是thread 4抢到票呢？其他的线程为什么不能抢票？

这是因为锁的钥匙已经被线程4早早地拿走了，其他线程没有钥匙是打不开锁的，就只能在锁区域外等候。

锁是否需要被保护呢？

锁是不许要被保护的，因为从汇编层面保证了加锁是原子性的，争夺锁只有两种可能，要么拿到了，要么没有拿到。

为了实现互斥锁的操作，大多数体系结构都提供了swap或exchange指令该指令的作用就是把寄存器和内存单元的数据相交换。

以加锁示例，这是由多态汇编语句执行的，上述%al是寄存器，mutex就是内存中的一个变量。每个线程申请锁时都要执行上述语句，执行步骤如下：

  • （movb $0，%al）先将al寄存器中的值清0。该动作可以被多个线程同时执行，因为每个线程都有自己的一组寄存器（上下文信息），执行该动作本质上是将自己的al寄存器清0。注意：凡是在寄存器中的数据，全部都是线程的内部上下文！多个线程看起来同时在访问寄存器，但是互不影响。

  • （xchgb %al，mutex）然后用此一条指令交换al寄存器和内存中mutex的值，xchgb是体系结构提供的交换指令，该指令可以完成寄存器和内存单元之间数据的交换。

  • 最后判断al寄存器中的值是否大于0。若大于0则申请锁成功，此时就可以进入临界区访问对应的临界资源；否则申请锁失败需要被挂起等待，直到锁被释放后再次竞争申请锁。

  • 示例：假设内存中有一个变量mutex为1，cpu内部有%al寄存器，我们有threadA和threadB俩线程，

**示例：**现在线程A要开始加锁，执行上述语句。首先（movb $0，%al），线程A把0读进al寄存器（清0寄存器），然后执行第二条语句（xchgb %al，mutex），将al寄存器中的值与内存中mutex的值进行交换。

  • 交换完成后，寄存器al的值为1，内存中mutex的值为0。此时这个过程就是加锁

  • 当线程A争议执行第三条语句if判断时，发生了线程切换（切至线程B），但是线程A要把自己的上下文（1）带走。线程B也要执行加锁动作，同样是第一条语句把0加载到寄存器，清0寄存器。

  • 随后线程B执行第二条语句交换动作，可是mutex的数据先前已经被线程A交换至寄存器，然后保存到线程A的上下文了，现在的mutex为0，而线程B执行交换动作，拿寄存器al的0去换内存中mutex的0。

即使我线程A在执行第一条语句把寄存器清0后就发生了线程切换（切至线程B），线程A保存上下文数据（0），此时线程B执行第一条语句把0写进寄存器，随后线程B执行第二条语句xchgb交换：

此时线程A执行第三条语句if判断失败，只能被挂起等待，线程A只能把自己的上下文数据保存，重新切换至线程B，也就是说我线程B只要不运行，你们其它所有线程都无法申请成功。线程B恢复上下文数据（1）到内存，然后执行第三条语句if成功，返回结果

**注意：**上述xchgb就是申请锁的过程。申请锁是将数据从内存交换到寄存器，本质就是将数据从共享内存变成线程私有。

  • mutex就是内存里的全局变量，被所有线程共享，但是一旦用一条汇编语句将内存的mutex值交换到寄存器，寄存器内部是哪个线程使用，那么此mutex就是哪个线程的上下文数据，那么就意味着交换成功后，其它任何一个线程都不可能再申请锁成功了，因为mutex已经独属于某线程私有了。
  • 这个mutex = 1就如同令牌一般，哪个线程先交换拿到1，那么哪个线程就能申请锁成功，所以加锁是原子的
  • 当线程释放锁时，需要执行以下步骤：
  1. 将内存中的mutex置回1。使得下一个申请锁的线程在执行交换指令后能够得到1，形象地说就是“将锁的钥匙放回去”。
  2. 唤醒等待Mutex的线程。唤醒这些因为申请锁失败而被挂起的线程，让它们继续竞争申请锁。

总结：

  • 在申请锁时本质上就是哪一个线程先执行了交换指令，那么该线程就申请锁成功，因为此时该线程的al寄存器中的值就是1了。而交换指令就只是一条汇编指令，一个线程要么执行了交换指令，要么没有执行交换指令，所以申请锁的过程是原子的。
  • 在线程释放锁时没有将当前线程al寄存器中的值清0，这不会造成影响，因为每次线程在申请锁时都会先将自己al寄存器中的值清0，再执行交换指令。
  • CPU内的寄存器不是被所有的线程共享的，每个线程都有自己的一组寄存器，但内存中的数据是各个线程共享的。申请锁实际就是，把内存中的mutex通过交换指令，原子性的交换到自己的al寄存器中。

可重入和线程安全

  • 线程安全： 多个线程并发同一段代码时 不会出现不同的结果 常见对全局变量或者静态变量进行操作 并且没有锁保护的情况下 会出现线程安全问题
  • 重入： 同一个函数被不同的执行流调用 当前一个流程还没有执行完 就有其他的执行流再次进入 我们称之为重入 一个函数在重入的情况下 运行结果不会出现任何不同或者任何问题 则该函数被称为可重入函数 否则是不可重入函数

常见的线程安全情况

  • 不保护共享变量的函数
  • 函数状态随着被调用 状态发生变化的函数
  • 返回指向静态变量指针的函数
  • 调用线程不安全函数的函数

常见的线程安全的情况

  • 每个线程对全局变量或者静态变量只有读取的权限 而没有写入的权限 一般来说这些线程是安全的
  • 类或者接口对于线程来说都是原子操作
  • 多个线程之间的切换不会导致该接口的执行结果存在二义性

常见的不可重入情况

  • 调用了malloc/free函数 因为malloc函数是用全局链表来管理堆的
  • 调用了标准I/O库函数 标准I/O可以的很多实现都是以不可重入的方式使用全局数据结构
  • 可重入函数体内使用了静态的数据结构

常见的可重入情况

  • 不使用全局变量或静态变量
  • 不使用malloc或者new开辟出的空间
  • 不调用不可重入函数
  • 不返回静态或全局数据 所有数据都由函数的调用者提供
  • 使用本地数据或者通过制作全局数据的本地拷贝来保护全局数据

可重入与线程安全联系

  • 函数是可重入的 那就是线程安全的
  • 函数是不可重入的 那就不能由多个线程使用 有可能引发线程安全问题
  • 如果一个函数中有全局变量 那么这个函数既不是线程安全也不是可重入的

可重入与线程安全区别

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

死锁

一般情况下，如果同一个线程先后两次调用lock，在第二次调用时，由于锁已经被占用，该线程会挂起等待别的线程释放锁，然而锁正是被自己占用着的，该线程又被挂起而没有机会释放锁，因此就永远处于挂起等待状态了，这叫做死锁（Deadlock）。另一种典型的死锁情形是这样：线程A获得了锁1，线程B获得了锁2，这时线程A调用lock试图获得锁2，结果是需要挂起等待线程B释放锁2，而这时线程B也调用lock试图获得锁1，结果是需要挂起等待线程A释放锁1，于是线程A和B都永远处于挂起状态了。

写程序时应该尽量避免同时获得多个锁，如果一定有必要这么做，则有一个原则：如果所有线程在需要多个锁时都按相同的先后顺序（常见的是按Mutex变量的地址顺序）获得锁，则不会出现死锁。比如一个程序中用到锁1、锁2、锁3，它们所对应的Mutex变量的地址是锁1<锁2<锁3，那么所有线程在需要同时获得2个或3个锁时都应该按锁1、锁2、锁3的顺序获得。如果要为所有的锁确定一个先后顺序比较困难，则应该尽量使用pthread_mutex_trylock调用代替pthread_mutex_lock调用，以免死锁。

Case1：因为自己拿了锁，又去申请这把锁，导致死锁了。

#include <iostream>
#include <cstring>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/syscall.h>
using namespace std;// int 票数计数器
int tickets = 1000; // 临界资源，可能会因为共同访问，造成数据不一致的问题
//pthread_mutex_t Mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t Mutex;
void *getTickets(void *args)
{const char *name = static_cast<const char *>(args);while (true){pthread_mutex_lock(&Mutex);pthread_mutex_lock(&Mutex);// 临界区if (tickets > 0){usleep(100);cout << name << " 抢到了票, 票的编号: " << tickets << endl;tickets--;}else{break;}pthread_mutex_unlock(&Mutex);pthread_mutex_unlock(&Mutex);}return nullptr;
}
int main()
{pthread_mutex_init(&Mutex,NULL);pthread_t tid1;pthread_create(&tid1, nullptr, getTickets, (void *)"thread 1");//线程1pthread_join(tid1,NULL);pthread_join(tid2,NULL);pthread_join(tid3,NULL);pthread_join(tid4,NULL);return 0;
}

Case2：互相申请对方的锁。

#include <iostream>
#include <cstring>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/syscall.h>
using namespace std;// int 票数计数器
int tickets = 1000; // 临界资源，可能会因为共同访问，造成数据不一致的问题
pthread_mutex_t Mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t Mutex1=PTHREAD_MUTEX_INITIALIZER;
void *getTickets(void *args)
{const char *name = static_cast<const char *>(args);while (true){pthread_mutex_lock(&Mutex);sleep(1);pthread_mutex_lock(&Mutex1);// 临界区if (tickets > 0){usleep(100);cout << name << " 抢到了票, 票的编号: " << tickets << endl;tickets--;}else{break;}pthread_mutex_unlock(&Mutex1);pthread_mutex_unlock(&Mutex);}return nullptr;
}void *getTickets1(void *args)
{const char *name = static_cast<const char *>(args);while (true){pthread_mutex_lock(&Mutex1);sleep(1);pthread_mutex_lock(&Mutex);// 临界区if (tickets > 0){usleep(100);cout << name << " 抢到了票, 票的编号: " << tickets << endl;tickets--;}else{break;}pthread_mutex_unlock(&Mutex);pthread_mutex_unlock(&Mutex1);}return nullptr;
}int main()
{pthread_t tid1;pthread_t tid2;pthread_create(&tid1, nullptr, getTickets, (void *)"thread 1");//线程1pthread_create(&tid2, nullptr, getTickets1, (void *)"thread 2");//线程2pthread_join(tid1,NULL);pthread_join(tid2,NULL);return 0;
}

死锁的四个必要条件

  • 互斥条件： 一个资源每次只能被一个执行流使用
  • 请求与保持条件： 一个执行流因请求资源而阻塞时 对已获得的资源保持不放
  • 不剥夺条件： 一个执行流已获得的资源 在未使用完之前 不能强行剥夺
  • 循环等待条件： 若干执行流之间形成一种头尾相接的循环等待资源的关系

注意 这是四个必要条件 也就是说四个条件全部满足才能够形成死锁

避免死锁

  • 破坏死锁的四个必要条件。
  • 加锁顺序一致
  • 避免锁未释放的场景
  • 资源一次性分配

相关文章：

  • 记GitLab服务器迁移后SSH访问无法生效的问题解决过程
  • 解决docker运行elastic服务端启动不成功
  • 记一次线上bug排查-----SpringCloud Gateway组件 请求头accept-encoding导致响应结果乱码
  • Netty源码学习4——服务端是处理新连接的netty的reactor模式
  • Flink 运行架构和核心概念
  • 工具及方法 - 多邻国: Duolingo
  • pytho你-opencv划痕检测
  • 基础课6——开放领域对话系统架构
  • 【MySql】13- 实践篇(十一)
  • 常见树种（贵州省）：009楠木、樟木、桂木种类
  • shell 判断文件是否存在(csh bash)
  • 【算法】最优乘车——bfs（stringsteam的实际应用，getline实际应用）
  • 2023.11.17使用flask将多个图片文件上传至服务器
  • Android修行手册-POI操作中文API文档
  • STM32F4系列单片机GPIO概述和寄存器分析
  • 【140天】尚学堂高淇Java300集视频精华笔记（86-87）
  • 【译】理解JavaScript：new 关键字
  • 345-反转字符串中的元音字母
  • 77. Combinations
  • C++类中的特殊成员函数
  • const let
  • ES6系统学习----从Apollo Client看解构赋值
  • jdbc就是这么简单
  • Web设计流程优化：网页效果图设计新思路
  • 给Prometheus造假数据的方法
  • 缓存与缓冲
  • 基于Vue2全家桶的移动端AppDEMO实现
  • 精益 React 学习指南 （Lean React）- 1.5 React 与 DOM
  • 看图轻松理解数据结构与算法系列(基于数组的栈)
  • 类orAPI - 收藏集 - 掘金
  • 前端之Sass/Scss实战笔记
  • 我是如何设计 Upload 上传组件的
  • 用jquery写贪吃蛇
  • 终端用户监控：真实用户监控还是模拟监控？
  • 2017年360最后一道编程题
  • Play Store发现SimBad恶意软件，1.5亿Android用户成受害者 ...
  • 翻译 | The Principles of OOD 面向对象设计原则
  • 如何用纯 CSS 创作一个货车 loader
  • ​LeetCode解法汇总2182. 构造限制重复的字符串
  • $.ajax,axios,fetch三种ajax请求的区别
  • （9）目标检测_SSD的原理
  • （翻译）Entity Framework技巧系列之七 - Tip 26 – 28
  • (附源码)计算机毕业设计大学生兼职系统
  • （离散数学）逻辑连接词
  • （力扣记录）235. 二叉搜索树的最近公共祖先
  • (六)库存超卖案例实战——使用mysql分布式锁解决“超卖”问题
  • （提供数据集下载）基于大语言模型LangChain与ChatGLM3-6B本地知识库调优：数据集优化、参数调整、Prompt提示词优化实战
  • （一）使用IDEA创建Maven项目和Maven使用入门（配图详解）
  • (转)Oracle存储过程编写经验和优化措施
  • (转)从零实现3D图像引擎：(8)参数化直线与3D平面函数库
  • .bat批处理（八）：各种形式的变量%0、%i、%%i、var、%var%、!var!的含义和区别
  • .NET CF命令行调试器MDbg入门(一)
  • .net core 6 集成 elasticsearch 并 使用分词器
  • .net core IResultFilter 的 OnResultExecuted和OnResultExecuting的区别
  • .net wcf memory gates checking failed