多线程互斥量进阶

已于 2024-03-17 15:47:48 修改
阅读量384 收藏 4
点赞数 3
分类专栏： Linux系统编程 文章标签： linux
于 2024-02-02 10:29:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52484093/article/details/135987115
版权
文章探讨了不同类型的互斥量（如正常、定时、递归和错误检查）在并发编程中的行为，重点分析了死锁的概念和常见问题，包括死锁条件、循环等待以及如何通过按序获取和设置等待超时避免死锁。
摘要由CSDN通过智能技术生成

问题

一个线程多次尝试获取同一个互斥量，会发生什么？

不同类型的互斥量

Linux 上的示例程序

互斥锁类型实验

test-1.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>

int main()
{
    printf("PTHREAD_MUTEX_NORMAL = %d\n", PTHREAD_MUTEX_NORMAL);
    printf("PTHREAD_MUTEX_TIMED_NP = %d\n", PTHREAD_MUTEX_TIMED_NP);
    
    printf("PTHREAD_MUTEX_RECURSIVE = %d\n", PTHREAD_MUTEX_RECURSIVE);
    printf("PTHREAD_MUTEX_RECURSIVE_NP = %d\n", PTHREAD_MUTEX_RECURSIVE_NP);
    
    printf("PTHREAD_MUTEX_ERRORCHECK = %d\n", PTHREAD_MUTEX_ERRORCHECK);
    printf("PTHREAD_MUTEX_ERRORCHECK_NP = %d\n", PTHREAD_MUTEX_ERRORCHECK_NP);
    
    printf("PTHREAD_MUTEX_DEFAULT = %d\n", PTHREAD_MUTEX_DEFAULT);
    
    return 0;
}

程序运行结果如下图所示：

可以看出互斥锁有不同的类型

死锁的概念

等待关系

  • 线程所需资源被其他线程所持有，进而必须等待 (无法继续执行)

循环等待

  • 当线程之间出现循环等待关系时，即：发生死锁

下面的程序有问题吗？为什么？

普通互斥锁重复上锁实验

test-2.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>

int main()
{
    int r = 0;
    pthread_mutex_t mutex;
    pthread_mutexattr_t mattr;
    
    pthread_mutexattr_init(&mattr);
    pthread_mutex_init(&mutex, &mattr);
    
    r = pthread_mutex_lock(&mutex);
    printf("r = %d\n", r);
    r = pthread_mutex_lock(&mutex);
    printf("r = %d\n", r);
    
    printf("Hello World!\n");
    
    pthread_mutex_unlock(&mutex);
    pthread_mutex_unlock(&mutex);

    pthread_mutexattr_destroy(&mattr);
    pthread_mutex_destroy(&mutex);
    
    return 0;
}

该程序没有显示的指定互斥锁类型，所以是普通的互斥锁，对普通互斥锁进行两次上锁

程序运行结果如下图所示：

通过打印可以看出，第一次上锁的时候成功了，第二次上锁的时候卡死了，说明普通互斥锁如果重复进行上锁的话，会导致死锁

互斥量的类型设置

不同类型的互斥量示例

PTHREAD_MUTEX_RECURSIVE 实验

test-3.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>

void* thread_entry(void* arg)
{  
    pthread_mutex_t* pm = arg;
    
    sleep(1);
    
    pthread_mutex_lock(pm);

    printf("%s\n", __FUNCTION__);
        
    pthread_mutex_unlock(pm);
    
    pthread_detach(pthread_self());
    
    return NULL;
}

int main()
{
    int r = 0;
    pthread_t t;
    pthread_mutex_t mutex;
    pthread_mutexattr_t mattr;
    
    pthread_mutexattr_init(&mattr);
    
    pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
    
    pthread_mutex_init(&mutex, &mattr);
    
    pthread_create(&t, NULL, thread_entry, &mutex);
    
    r = pthread_mutex_lock(&mutex);
    printf("r = %d\n", r);
    r = pthread_mutex_lock(&mutex);
    printf("r = %d\n", r);
    
    printf("Hello World!\n");
    
    pthread_mutex_unlock(&mutex);
    
    while( 1 )
    {
        sleep(1);
    }
    
    return 0;
}

第 35 行，将互斥锁的类型设置为递归锁，然后主线程会创建一个子线程，子线程会先 sleep 1s，确保主线程上锁两次、解锁一次的操作执行完成后，子线程才能上锁、解锁

程序运行结果如下图所示：

可以看出主线程两次重复上锁的操作均已成功，并且成功打印出来，而子线程却没有打印出来，子线程出现死锁

这是因为递归锁允许同一个线程多次获取互斥锁，但是获取了多少次递归锁，就要释放多少次，由于主线程获取了两次递归锁，只释放了一次，导致子线程永远无法获取递归锁，从而导致子线程出现死锁

PTHREAD_MUTEX_ERRORCHECK 实验

test-4.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>

int main()
{
    int r = 0;
    pthread_t t;
    pthread_mutex_t mutex;
    pthread_mutexattr_t mattr;
    
    pthread_mutexattr_init(&mattr);
    
    pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_ERRORCHECK);
    
    pthread_mutex_init(&mutex, &mattr);
    
    r = pthread_mutex_lock(&mutex);
    printf("r = %d\n", r);
    r = pthread_mutex_lock(&mutex);
    printf("r = %d\n", r);
    
    printf("Hello World!\n");
    
    pthread_mutex_unlock(&mutex);
	pthread_mutex_unlock(&mutex);
    
    
    return 0;
}

第 18 行，将互斥锁的类型设置为 PTHREAD_MUTEX_ERRORCHECK，然后重复进行上锁

程序运行结果如下图所示：

通过打印可以看出，第一次获取锁的时候成功了，第二次获取锁的时候失败了，返回值不等于 0，但也没有发生死锁

所以，PTHREAD_MUTEX_ERRORCHECK 这个锁类型，会在同一个线程重复获取互斥锁的时候返回失败

互斥量小结

PTHREAD_MUTEX_NORMAL

  • 一旦互斥量上锁 "上锁"，任何线程均无法再次获取互斥量

PTHREAD_MUTEX_RECURSIVE

  • 同一个线程可多次获取互斥量，同时需要相同次数的释放互斥量

PTHREAD_MUTEX_ERRORCHECK

  • 同一个线程再次获取互斥量时，将错误返回

下面的程序执行后会发生什么？

互斥锁必须成对的获取和释放，并且不允许没上锁就解锁，这个程序的行为是未定义的

死锁的 4 大条件

存在互斥资源

  • 代码中存在临界区 => 即：多个线程可能同时进入临界区

持有资源并等待资源

  • 线程可能需要同时获取多个互斥量才能进入临界区

资源不可剥夺

  • 线程获取的互斥量不能被其他线程再次获取

存在循环等待

  • 线程与资源之间的等待关系存在环路

如何避免死锁？

破坏死锁条件中的任意一个！

死锁模型

循环等待死锁实验

test-5.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>

pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;

int g_count = 0;

void* thread_1(void* arg)
{  
    while(1)
    {
        pthread_mutex_lock(&m1);
        pthread_mutex_lock(&m2);

        printf("%s : %d\n", __FUNCTION__, g_count++);
        
        usleep(100);
            
        pthread_mutex_unlock(&m1);
        pthread_mutex_unlock(&m2);
    }
    
    pthread_detach(pthread_self());
    
    return NULL;
}

void* thread_2(void* arg)
{  
    while(1)
    {
        pthread_mutex_lock(&m2);
        pthread_mutex_lock(&m1);

        printf("%s : %d\n", __FUNCTION__, g_count++);
        
        usleep(100);
            
        pthread_mutex_unlock(&m1);
        pthread_mutex_unlock(&m2);
    }
    
    pthread_detach(pthread_self());
    
    return NULL;
}

int main()
{
    int r = 0;
    pthread_t t;
    
    pthread_create(&t, NULL, thread_1, NULL);
    pthread_create(&t, NULL, thread_2, NULL);
    
    printf("Hello World!\n");
    
    while( 1 )
    {
        sleep(1);
    }
    
    return 0;
}

主线程中创建了两个子线程，子线程1 先获取互斥锁 m1，再获取互斥锁 m2；而子线程2 先获取互斥锁 m2，再获取互斥锁 m1，子线程1 和 子线程2 的资源竞争存在一个环路关系，可能会导致死锁

程序运行结果如下图所示：

打印出 thread_2 : 2011 后，就再无打印

两个子线程由于资源竞争存在一个环路关系，就有可能导致死锁的发生；当子线程1 获取互斥锁 m1，子线程2 获取互斥锁 m2 的时候就会导致死锁，两个子线程永远都获取不到另一个互斥锁

要想解决这个程序可能导致死锁的问题，可以让子线程1 和子线程2 按照相同的顺序来获取互斥锁，比如都是先获取到互斥锁 m1，才能获取互斥锁 m2，这样就能解决死锁问题

避免死锁的经验方法

按序获取

  • 如果存在多个互斥量，必须按序获取互斥量

设置等待超时

  • 若超时未能获取互斥量，则释放已获取的互斥量

全局唯一互斥量

  • 仅使用一个全局互斥量对所有临界区进行访问 (不建议！)

死锁判断示例

假设有 三个线程 (A，B，C) 和三个互斥量 (R，S，T)，三个线程对互斥量的获取及释放如下，问：是否可能发生死锁？

有可能发生死锁，当线程A 获取到 R，线程B 获取到 S，线程C 获取到 T的时候就会发生死锁

qq_52484093
关注
专栏目录
python 协程 多线程_python进阶之多线程（简单介绍协程）
weixin_39738152的博客
12-15 139
多线程线程:实现多任务的另一种方式一个进程中，也经常需要同时做多件事，就需要同时运行多个‘子任务’，这些子任务，就是线程线程又被称为轻量级进程(lightweight process)，是更小的执行单元一个进程可拥有多个并行的(concurrent)线程，当中每一个线程，共享当前进程的资源一个进程中的线程共享相同的内存单元/内存地址空间可以访问相同的变量和对象，而且它们从同一堆中分配对象通信、数据...
Java之多线程进阶
qq_64580912的博客
05-18 5056
此时线程1调离CPU,线程2调入CPU,此时线程2工作内存中var5=0(expectValue),进入到CAS操作中,此时将&(var1+var2)=1与var5=0(expectValue)进行对比,发现不相同,返回false,之后重新将主内存中的value值加载到工作内存中,此时var5=1,进入到CAS操作中,此时将&(var1+var2)=1与var5=0(expectValue)进行对比,发现相同,将主内存中的值赋值为swapValue(var5+1=2)返回true,线程2操作结束.
多线程进阶
qq_39537400的博客
03-21 581
一：线程池 1.线程池的由来 本来多进程就是为了解决并发编程的方案，但是进程有点太重量了（创建和销毁，开销比较大） 因此引入了线程，线程比进程要轻量很多。 即便如此，如果某些场景中，需要频繁的创建销毁线程，此时，线程的创建和销毁的开销，也就无法被忽视了。线程池就是为了解决这样的问题而来。 2.线程池的使用 使用线程的时候，不是说用的时候才创建，而是提前创建好，放到一个“池子里”（和字符串常量池是类似的东西） 当我们需要使用线程的时候，直接从池子里取一个线程过来。 当我们不需要这个线程的时候，就把这个线程还回
多线程进阶——JUC并发
zhaozhao_1的博客
06-13 1746
JUC是Java中的三个包，java.util.concurrent，业务：普通的线程代码 Thread 调用Runnable没有返回值，效率较Callable低，所以企业中Runnable使用少，大多情况下使用Callable。
多线程-进阶
weixin_61196535的博客
08-30 875
常见锁策略，CAS，JUC，线程安全的集合类，多线程环境下使用ArrayList，队列，哈希表
多线程高级进阶
weixin_49161209的博客
09-11 189
多线程 一、volatile jmm存储三大特性 可见性，有序性，原子性 volatile 解决了可见性和有序性 package com.thread.study.volatiles; /** * @ClassName * @Description TODO * @Author ZQS * @Date 2020/9/8 0008 16:22 * @Version 1.0 **/ public class Singleton { private static Singleton
Java多线程进阶(JUC)
black_pp的博客
09-27 773
Java多线程进阶，锁，JUC，并发安全问题
Java EE多线程进阶
m0_57180439的博客
04-08 800
文章目录前言一、常见锁策略1.1乐观锁vs悲观锁1.2读写锁vs普通互斥锁1.3重量级锁vs轻量级锁1.4挂起等待锁vs自旋锁1.5公平锁vs非公平锁1.6可重入锁vs不可重入锁二、CAS2.1什么是CAS2.2CAS是如何实现的2.3CAS有哪些应用三、Synchronized 原理四、Callable接口五、JUC(java.util.concurrent) 的常见类六、线程安全的集合类七、死锁八、其他常见面试问题总结 前言 java ee多线程进阶常用于面试（堪称八股文），实际工作生活用的比较少。如
3.多线程(进阶)
xinhang10的博客
08-10 1254
本文章为多线程操作的进阶内容，建议读者们先看完多线程初阶再来看本次的知识哦！我们本次主要为大家讲解了锁的一些常见的策略，乐观锁、悲观锁、互斥锁、读写锁、重量级锁、轻量级锁等等...... 在讲解完锁后我们为大家引入了CAS、synchroniezd、Callable、JUC、线程安全的集合类等等知识，并在文章的末尾讲解了何为死锁，以及死锁如何避免！
Qt多线程编程（二）进阶篇
晴天的博客
06-20 1974
目录 一、前言 二、自定义一个线程 三、线程锁简介 四、线程数据同步 五、实战演练 一、前言 二、自定义一个线程 三、线程锁简介 四、线程数据同步 五、实战演练
多线程、许可证、互斥量、信号量 API的使用-易语言
06-12
在《多线程、许可证、互斥量、信号量 API的使用》的进阶教程源码中，可能包含了易语言实现的示例代码，用于演示如何有效地使用这些API来解决并发编程中的问题。例如，通过创建多线程实现并行计算，使用许可证或互斥...
python进阶之多线程对同一个全局变量的处理方法
12-24
在标题提到的“python进阶之多线程对同一个全局变量的处理方法”中，我们将探讨如何解决这个问题。 首先，让我们回顾一下例子中的问题。在描述中，我们看到有两个函数`func1()`和`func2()`，它们都在增加全局变量`...
浪潮云启操作系统（InLinux） bcache宕机问题分析
jackknight的专栏
11-20 989
本文以一次真实的内核宕机问题为切入点，结合实际操作案例，详细展示了如何利用工具 `crash`对内核转储（kdump）进行深入分析和调试的方法。通过对崩溃日志的解读、函数调用栈的梳理、关键地址的定位以及代码逻辑的排查，本文提供了一套系统化的内核问题分析思路和实用技巧。本指南基于 InLinux2312-LTS-SP1 版本，旨在帮助读者快速掌握内核 kdump 问题的排查方法，提升故障处理效率。
Linux 系统管理
2301_78183285的博客
11-21 284
很多shell脚本里面需要打印不同格式的时间或日期，以及要根据时间和日期执行操作。日期可以以多种格式去打印，也可以使用命令设置固定的格式。在类UNIX系统中，日期被存储为一个整数，其大小为自世界标准时间（UTC）1970年1月1日0时0分0秒起流逝的秒数。若是不以加号作为开头，则表示要设定时间，而时间格式MMDDhhmm[[CC]YY][.ss]，其中 MM 为月份，DD 为日，hh 为小时，mm 为分钟，CC 为年份前两位数字，YY 为年份后两位数字，ss 为秒数。补充： 查看 CPU 信息 - 使用。
『 Linux 』文件与网络套接字的内部关系
小侯宝的博客
11-18 860
假设使用浏览器在线观看视频,网速突然变慢或者是视频数据没有到达时,浏览器将希望从套接字收取更多的数据来显示视频,但由于数据尚未到达,浏览器操作数据的进程可能需要等待,对应的这个浏览器进程将会被添加到该套接字。对应的方法集则是特定于网络协议套接字操作的方法,对应结构体中包含了一系列的函数指针,这些函数指针定义了网络套接字在不同协议栈(如TCP,UDP等)下的行为,包括套接字的创建。方法集在文件指向网络时,主要的操作作用域是对上的,通常情况下在进行网络通信时,数据的生产位置是位于用户层/应用层的,而。
【Linux】WG-Easy：基于 Docker 和 Web 面板的异地组网
2303_80346267的博客
11-19 1041
本教程将指导您使用 WireGuard Easy在具有公网 IP 的云服务器上搭建一个基于 Docker 的 WireGuard VPN 服务。通过此服务，不同设备可以通过该云服务器加入同一个虚拟内网，实现异地组网。项目提供了一个简单的 Web 管理界面，方便管理和配置。
linux从0到1——shell编程7
最新发布
sucker的博客
11-22 666
接着，通过（(i++））这一语句对变量i进行自增操作。每次循环结束后、的值就会比上一次循环时增加1，以便在下次循开始时进行新的条件判断。先是通过i=1初始化变量i，然后通过，while((Si
43加密技术在Linux上的应用
大风吹PP凉
11-21 641
通过今天的课程，你学习了如何在Linux系统中使用加密技术来保护数据的安全。掌握了这些基本技能后，你可以更有效地保护你的数据，确保敏感信息不会被未经授权的访问，并提高系统的整体安全性。如果你有任何问题或需要进一步的帮助，请随时留言。我们下节课将继续带你深入了解Linux的更多知识。再见！这篇文章旨在帮助读者了解如何在Linux中使用加密技术，并通过具体的示例演示加密技术的基本操作。通过学习这些基本操作，即使是非IT专业的读者也能轻松上手，并为进一步的实战和工作打下坚实的基础。
Linux tcpdump 详解教程
广阔天地，大有作为
11-21 415
tcpdump是一款在 Linux 平台上广泛使用的网络抓包工具。它可以捕获整个 TCP/IP 协议族的数据包，并支持对网络层、协议、主机、端口等进行过滤。tcpdump提供了强大的过滤功能，允许使用 and、or、not 等逻辑语句来筛选数据包，非常适合用于网络故障分析和安全监控。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值