【Linux】线程互斥

文章目录

    • 线程互斥
    • 互斥量 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;
}

死锁的四个必要条件

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

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

避免死锁

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

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

为关键信息基础设施安全助力！持安科技加入关保联盟

为关键信息基础设施安全助力！持安科技加入关保联盟

近日&#xff0c;中关村华安关键信息基础设施安全保护联盟发布了其新一批的会员单位&#xff0c;零信任办公安全代表企业持安科技成功加入&#xff0c;与联盟企业共同为关键信息基础设施提供各类支撑和保障。 中关村华安关键信息基础设施安全保护联盟由北京市科学技术委员会、中…
阅读更多...
深信服AC设备用户认证

深信服AC设备用户认证

拓扑图 目录 拓扑图 一. 无需认证 思路&#xff1a;创建用户和组&#xff0c;将无需认证策略和用户绑定 1.创建组&#xff0c;组里添加用户 2. 新建不需要认证策略&#xff0c;将不需要认证策略和用户关联 3.验证 二.密码认证 思路&#xff1a;创建用户和组&#xff0c;并…
阅读更多...
持续集成交付CICD：Jenkins Sharedlibrary 共享库

持续集成交付CICD：Jenkins Sharedlibrary 共享库

目录 一、理论 1.共享库 2.共享库配置 3.使用共享库 4.共享库扩展 二、实验 1.连接共享库 2.使用共享库 三、问题 1.路径报错 2.readJSON 报错 一、理论 1.共享库 &#xff08;1&#xff09;概念 1&#xff09;共享库这并不是一个全新的概念&#xff0c;其实在编…
阅读更多...
深度学习二维码识别 计算机竞赛

深度学习二维码识别 计算机竞赛

文章目录 0 前言2 二维码基础概念2.1 二维码介绍2.2 QRCode2.3 QRCode 特点 3 机器视觉二维码识别技术3.1 二维码的识别流程3.2 二维码定位3.3 常用的扫描方法 4 深度学习二维码识别4.1 部分关键代码 5 测试结果6 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天…
阅读更多...
ubuntu20.04.1网络图标突然消失，无法上网

ubuntu20.04.1网络图标突然消失，无法上网

故障&#xff1a;打开虚拟机进入Ubuntu系统后&#xff0c;打开火狐浏览器&#xff0c;发现无法连接网络。 解决办法&#xff1a;因为刚接触Linux系统&#xff0c;就在网上找各种资料&#xff0c;试了各种办法无果&#xff0c;最后发现有可能网络配置文件被更改。 打开控制台输…
阅读更多...
打不开github网页解决方法

打不开github网页解决方法

问题&#xff1a; 1、composer更新包总是失败 2、github打不开&#xff0c;访问不了 解决方法&#xff1a;下载一个Watt Toolkit工具&#xff0c;勾选上&#xff0c;一键加速就可以打开了。 下载步骤&#xff1a; 1、打开网址&#xff1a; Watt Toolkit 2、点击【下载wind…
阅读更多...
章鱼网络在 NEARCON23 发布 Octopus 2.0

章鱼网络在 NEARCON23 发布 Octopus 2.0

香港时间2023年11月8日12点&#xff0c;章鱼网络举行第15期 Community Call。 我们在10月8日庆祝了章鱼网络主网上线二周年&#xff0c;并参加了激动人心的 Cosmoverse2023 活动。最重要的是&#xff0c;我们在 Octopus 2.0 的开发中取得了重大进展。 11月8日 Community Call …
阅读更多...
PS学习笔记——图层

PS学习笔记——图层

文章目录 图层面板图层类型新建图层新建方式图层颜色 操作图层修改图层名称选中图层隐藏图层调整图层顺序复制图层 图层面板 按F7可打开/关闭图层面板 该面板就是图层面板了 对所有图层进行筛选的按钮&#xff0c;第一个搜索框可以选择按什么方式进行筛选&#xff0c;支持&am…
阅读更多...
idea显示pom.xml文件漂黄警告 Dependency maven:xxx:xxx is vulnerable

idea显示pom.xml文件漂黄警告 Dependency maven:xxx:xxx is vulnerable

场景&#xff1a; idea警告某些maven依赖包有漏洞或者依赖传递有易受攻击包&#xff0c;如下&#xff1a; 解决&#xff1a; 1、打开idea设置&#xff0c;找到 File | Settings | Editor | Inspections 2、取消上述两项勾选即可
阅读更多...
YOLO对象检测算法也这么卷了吗——基于YOLOv8的人体姿态检测

YOLO对象检测算法也这么卷了吗——基于YOLOv8的人体姿态检测

前期的文章我们介绍了很多关于YOLO系列的对象检测算法，虽然YOLO系列是应用在目标检测算法上，但是最近更新的YOLO系列算法都加入了对象分割，人体姿态检测等模型。 YOLOv8对象检测算法 2023年，Ultralytics再次发布YOLO更新模型，YOLOv8模型。Ultralytics YOLOv8是YOLO对象检…
阅读更多...
Python (十一) 迭代器与生成器

Python (十一) 迭代器与生成器

迭代器 迭代器是访问集合元素的一种方式&#xff0c;可以记住遍历的位置的对象 迭代器有两个基本的方法&#xff1a;iter() 和 next() 字符串&#xff0c;列表或元组对象都可用于创建迭代器 字符串迭代 str1 Python str_iter iter(str1) print(next(str_iter)) print(next(st…
阅读更多...
springboot引入redisson分布式锁及原理

springboot引入redisson分布式锁及原理

1.引入依赖 <dependency><groupId>org.redisson</groupId><artifactId>redisson</artifactId><version>3.13.6</version> </dependency>2.配置类创建bean /*** author qujingye* Classname RedissonConfig* Description TOD…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023