深入探讨多线程编程：从0-1为您解释多线程（下）

news2024/12/1 10:37:22

文章目录

  • 6. 死锁
    • 6.1 死锁
      • 原因
    • 6.2 避免死锁的方法
      • 加锁顺序一致性。
      • 超时机制。
      • 死锁检测和解除机制。

6. 死锁

6.1 死锁

原因

  1. 系统资源的竞争：（产生环路）当系统中供多个进程共享的资源数量不足以满足进程的需要时，会引起进程对2资源的竞争而产生死锁。例如，两个进程分别持有资源R1和R2，但进程1申请资源R2，进程2申请资源R1时，两者都会因为所需资源被占用而阻塞。
#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>

std::timed_mutex resourceR1, resourceR2;

bool acquireResource(std::timed_mutex& r, const std::string& name) {
    std::chrono::milliseconds timeout(5000);  // 5秒超时
    if (r.try_lock_for(timeout)) {
        std::cout << "Process " << name << " has acquired its resource." << std::endl;
        return true;
    }
    else {
        std::cout << "Process " << name << " failed to acquire the resource within 5 seconds. Terminating..." << std::endl;
        return false;
    }
}

void process1() {
    if (acquireResource(resourceR1, "1")) {
        // 如果成功获取资源R1，尝试获取资源R2
        if (!acquireResource(resourceR2, "1")) {
            // 若获取资源R2失败，解锁资源R1并终止线程
            resourceR1.unlock();
            return;
        }

        /********************************************************/
        //需要执行的业务逻辑(不会被执行)
        /********************************************************/

        resourceR1.unlock();
        resourceR2.unlock();
    }
}

void process2() {
    if (acquireResource(resourceR2, "2")) {
        if (!acquireResource(resourceR1, "2")) {
            resourceR2.unlock();
            return;
        }

        // 同样，此处的业务逻辑也不会被执行
        resourceR1.unlock();
        resourceR2.unlock();
    }
}

int main() {
    std::thread t1(process1);
    std::thread t2(process2);

    t1.join();
    t2.join();

    return 0;
}

在这里插入图片描述
在这里插入图片描述

  1. 逻辑错误：程序逻辑错误可能导致死锁，如死循环或无限等待的情况。例如，在数据交换中，如果一方发送的消息丢失，发送方会等待接收返回信息，而接收方会无限等待接收信息，导致死锁。
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>

std::mutex mtx;
std::condition_variable cv1, cv2;
bool messageReceived = false;
bool acknowledgmentSent = false;

// 发送线程
void senderThread() {
    std::cout << "Sender: Sending data...\n";
    // 假设发送数据（此处省略具体发送逻辑）

    std::unique_lock<std::mutex> lk(mtx);
    auto timeout = std::chrono::system_clock::now() + std::chrono::seconds(5);
    while (!acknowledgmentSent && std::cv_status::timeout == cv1.wait_until(lk, timeout)) {
        if (std::chrono::system_clock::now() >= timeout) {
            std::cout << "Sender: Timeout occurred, assuming no acknowledgement received and exiting.\n";
            break;  // 超时后退出循环，不再等待确认
        }
    }
    lk.unlock();
}

// 接收线程
void receiverThread() {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 假设在此期间消息丢失

    std::unique_lock<std::mutex> lk(mtx);
    std::cout << "Receiver: Received data...\n";
    messageReceived = true;
    cv2.notify_one();  // 假设这是接收方发送确认的方式

    // 接收方也会等待发送方确认收到确认信息（这是一个逻辑错误，实际应用中通常不需要）
    auto timeout = std::chrono::system_clock::now() + std::chrono::seconds(5);
    while (!messageReceived && std::cv_status::timeout == cv2.wait_until(lk, timeout)) {
        if (std::chrono::system_clock::now() >= timeout) {
            std::cout << "Receiver: Timeout occurred, assuming message not delivered and exiting.\n";
            break;  // 超时后退出循环，不再等待消息
        }
    }
    lk.unlock();
}

int main() {
    std::thread t1(senderThread);
    std::thread t2(receiverThread);

    t1.join();
    t2.join();

    return 0;
}

在这里插入图片描述
两秒后
在这里插入图片描述
五秒后
在这里插入图片描述

  1. 不恰当的同步：在并发编程中，不恰当的同步机制可能导致死锁。例如，多个线程在等待其他线程释放锁时，如果这些线程彼此都持有对方需要的锁，就会导致死锁。
#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>

std::timed_mutex mtx1, mtx2;

void threadFunction1() {
    if (mtx1.try_lock_for(std::chrono::seconds(5))) {
        std::cout << "Thread 1: Acquired mtx1\n";

        // 尝试获取mtx2，如果5秒内未获取成功，则释放mtx1以防止死锁
        if (!mtx2.try_lock_for(std::chrono::seconds(5))) {
            mtx1.unlock();
            std::cout << "Thread 1: Could not acquire mtx2 within 5 seconds, releasing mtx1 to prevent deadlock.\n";
            return;
        }

        std::cout << "Thread 1: Acquired mtx2\n";
        mtx2.unlock();
        mtx1.unlock();
    }
    else {
        std::cout << "Thread 1: Could not acquire mtx1 within 5 seconds.\n";
    }
}

void threadFunction2() {
    if (mtx2.try_lock_for(std::chrono::seconds(5))) {
        std::cout << "Thread 2: Acquired mtx2\n";

        if (!mtx1.try_lock_for(std::chrono::seconds(5))) {
            mtx2.unlock();
            std::cout << "Thread 2: Could not acquire mtx1 within 5 seconds, releasing mtx2 to prevent deadlock.\n";
            return;
        }

        std::cout << "Thread 2: Acquired mtx1\n";
        mtx1.unlock();
        mtx2.unlock();
    }
    else {
        std::cout << "Thread 2: Could not acquire mtx2 within 5 seconds.\n";
    }
}

int main() {
    std::thread t1(threadFunction1);
    std::thread t2(threadFunction2);

    t1.join();
    t2.join();

    return 0;
}

在这里插入图片描述
在这里插入图片描述

6.2 避免死锁的方法

加锁顺序一致性。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx1, mtx2;

// 定义一个固定的全局锁顺序
const bool lockOrder[] = {true, false}; // 先锁mtx1，后锁mtx2

void worker(int id) {
    if (lockOrder[0]) {
        mtx1.lock();
        std::cout << "Thread " << id << ": Acquired mtx1\n";

        // 在拥有mtx1的情况下尝试获取mtx2
        mtx2.lock();
        std::cout << "Thread " << id << ": Acquired mtx2\n";
    } else {
        // 如果定义的顺序是先锁mtx2
        mtx2.lock();
        std::cout << "Thread " << id << ": Acquired mtx2\n";

        // 在拥有mtx2的情况下尝试获取mtx1
        mtx1.lock();
        std::cout << "Thread " << id << ": Acquired mtx1\n";
    }

    // 重要：解锁按照相反的顺序进行
    mtx2.unlock();
    mtx1.unlock();

    // 业务逻辑...
}

int main() {
    std::thread t1(worker, 1);
    std::thread t2(worker, 2);

    t1.join();
    t2.join();

    return 0;
}

在上述示例中，我们预定义了一个全局的锁获取顺序数组lockOrder，确保所有线程按照同样的顺序（本例中是先获取mtx1再获取mtx2）来获取互斥锁。这样可以防止如下情况：一个线程持有mtx1并等待mtx2，而另一个线程持有mtx2并等待mtx1，从而形成死锁。

请注意，为了避免死锁，不仅在获取锁时需遵循一致的顺序，而且在解锁时也应按照相反的顺序进行。在上面的代码中，无论哪种顺序，我们都是先解锁mtx2，然后再解锁mtx1。这样可以确保在任何时候，已经持有两个锁的线程都能顺利地按顺序释放它们，避免死锁的发生。

超时机制。

以下是一个使用std::timed_mutex的示例，当尝试获取互斥锁时设置一个超时时间，如果在规定时间内没能获取到锁，则线程放弃获取，从而可以避免死锁的发生：

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>

std::timed_mutex mtx1, mtx2;

void worker(int id) {
    if (id == 1) {
        // 线程1尝试获取mtx1
        if (mtx1.try_lock_for(std::chrono::seconds(5))) {
            std::cout << "Thread " << id << ": Acquired mtx1\n";

            // 在持有mtx1的前提下尝试获取mtx2，超时时间为5秒
            if (mtx2.try_lock_for(std::chrono::seconds(5))) {
                std::cout << "Thread " << id << ": Acquired mtx2\n";
                mtx2.unlock();
            } else {
                std::cout << "Thread " << id << ": Could not acquire mtx2 within 5 seconds, releasing mtx1.\n";
            }
            mtx1.unlock();
        } else {
            std::cout << "Thread " << id << ": Could not acquire mtx1 within 5 seconds.\n";
        }
    } else if (id == 2) {
        // 线程2尝试获取mtx2，同样设置5秒超时
        if (mtx2.try_lock_for(std::chrono::seconds(5))) {
            std::cout << "Thread " << id << ": Acquired mtx2\n";

            // 在持有mtx2的前提下尝试获取mtx1，同样设置5秒超时
            if (mtx1.try_lock_for(std::chrono::seconds(5))) {
                std::cout << "Thread " << id << ": Acquired mtx1\n";
                mtx1.unlock();
            } else {
                std::cout << "Thread " << id << ": Could not acquire mtx1 within 5 seconds, releasing mtx2.\n";
            }
            mtx2.unlock();
        } else {
            std::cout << "Thread " << id << ": Could not acquire mtx2 within 5 seconds.\n";
        }
    }
}

int main() {
    std::thread t1(worker, 1);
    std::thread t2(worker, 2);

    t1.join();
    t2.join();

    return 0;
}

在这个示例中，两个线程都试图按顺序获取互斥锁，但是如果在5秒钟内无法获取所需的下一个锁，它们都会释放已经持有的锁并退出相应的操作，从而避免了死锁的发生。

死锁检测和解除机制。

在C++标准库中并没有内置的死锁检测和解除机制，但我们可以通过设计良好的程序逻辑和利用特定的同步原语（如条件变量、互斥量等）来实施自己的死锁检测和解除策略。

// 假设有以下结构表示资源和进程的状态
struct Process {
    int pid; // 进程ID
    std::vector<int> holdingResources; // 当前持有的资源ID集合
    std::vector<int> requestingResources; // 正在请求的资源ID集合
};

struct Resource {
    int rid; // 资源ID
    int available; // 当前可用的数量
    std::map<int, int> allocated; // 已分配给各个进程的资源数量
};

// 假设有个全局的数据结构存储所有进程和资源的状态
std::vector<Process> processes;
std::vector<Resource> resources;

// 自定义的死锁检测函数（伪代码）
bool detectAndResolveDeadlocks() {
    // 初始化资源分配图（Resource Allocation Graph, RAG）
    // ...

    // 检查是否有循环等待
    for (auto& p : processes) {
        // 使用拓扑排序或其他方法检查是否存在环路
        if (isCycleDetectedInRAG(p)) {
            // 死锁检测出环，现在需要解除死锁
            resolveDeadlock(p.pid);
            return true;
        }
    }

    return false; // 没有发现死锁
}

// 解除死锁的策略有很多种，以下是一个简化的版本（仅作示例）
void resolveDeadlock(int pid) {
    // 可以选择一个进程撤销其部分请求或者抢占它的资源
    // 例如，选择持有最多资源但请求未满足最多的进程，释放其最少的一个资源
    Process& victim = getVictimProcess(pid);
    int resourceToRelease = getResourceToRelease(victim);
    
    // 释放资源并重新开始检测
    releaseResource(victim, resourceToRelease);
    victim.requestingResources.erase(
        std::find(victim.requestingResources.begin(), victim.requestingResources.end(), resourceToRelease));
}

// ... 其他辅助函数（getVictimProcess, getResourceToRelease, releaseResource等）

在实践中，死锁检测和解除往往涉及到复杂的算法和策略，比如银行家算法等。在C++程序中实现这样的功能通常需要自定义数据结构和算法，并且考虑到并发环境下的安全性，还需要适当使用锁来保护共享数据。

由于C++标准库提供的互斥量和条件变量等工具不具备自动死锁检测和解除功能，开发者需要自行设计和实现适合项目需求的死锁预防、检测及解除方案。在某些高级并发库中，可能提供了更高级别的抽象帮助处理这类问题，但C++标准库本身不直接提供这样的机制。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

文章解读与仿真程序复现思路——电网技术EI\CSCD\北大核心《基于纳什谈判的电氢能源系统多时间尺度协同运行优化》

文章解读与仿真程序复现思路——电网技术EI\CSCD\北大核心《基于纳什谈判的电氢能源系统多时间尺度协同运行优化》

本专栏栏目提供文章与程序复现思路&#xff0c;具体已有的论文与论文源程序可翻阅本博主免费的专栏栏目《论文与完整程序》 论文与完整源程序_电网论文源程序的博客-CSDN博客https://blog.csdn.net/liang674027206/category_12531414.html 电网论文源程序-CSDN博客电网论文源…
阅读更多...
harbor api v2.0

harbor api v2.0

harbor api v2.0 v2.0 v2.0 “harbor api v2.0”与原来区别较大&#xff0c;此处harbor也做了https。另外&#xff0c;通过接口拿到的数据也是只能默认1页10个&#xff0c;所以脚本根据实际情况一页页的抓取数据 脚本主要用于统计repo、image&#xff0c;以及所有镜像的tag数&…
阅读更多...
ubuntu18.04 pycharm

ubuntu18.04 pycharm

一、下载pycharm &#xff08;1&#xff09;进入官网下载Download PyCharm: The Python IDE for data science and web development by JetBrains 选择专业版&#xff08;professional&#xff09;直接点击下载&#xff08;download&#xff09;&#xff0c;我下载的是2023.3…
阅读更多...
PCA+DBO+DBSCN聚类，蜣螂优化算法DBO优化DBSCN聚类，适合学习，也适合发paper！

PCA+DBO+DBSCN聚类，蜣螂优化算法DBO优化DBSCN聚类，适合学习，也适合发paper！

PCADBODBSCN聚类&#xff0c;蜣螂优化算法DBO优化DBSCN聚类&#xff0c;适合学习&#xff0c;也适合发paper&#xff01; 一、蜣螂优化算法 摘要&#xff1a;受蜣螂滚球、跳舞、觅食、偷窃和繁殖等行为的启发&#xff0c;提出了一种新的基于种群的优化算法(Dung Beetle Optim…
阅读更多...
Rust使用原始字符串字面量实现Regex双引号嵌套双引号正则匹配

Rust使用原始字符串字面量实现Regex双引号嵌套双引号正则匹配

rust使用Regex实现正则匹配的时候&#xff0c;如果想实现匹配双引号&#xff0c;就需要使用原始字符串字面量&#xff0c;不然无法使用双引号嵌套的。r#"..."# 就表示原始字符串字面量。 比如使用双引号匹配&#xff1a; use regex::Regex;fn main() {println!(&qu…
阅读更多...
PCB行业企业运营管理应如何优化进阶？

PCB行业企业运营管理应如何优化进阶？

随着印制电路板产业的快速繁荣发展&#xff0c;下游企业对其生产制造、质量、工艺等方面也提出了更高的要求&#xff0c;印制电路板产业不再野蛮生长&#xff0c;企业逐步进入从规模到质量、从制造到智造的数字化转型升级新阶段。 每家PCB企业的业务流程、客户要求、企业文化、…
阅读更多...
（day 23）JavaScript学习笔记（内置对象2之JSON、Set、Map）

（day 23）JavaScript学习笔记（内置对象2之JSON、Set、Map）

概述 这是我的学习笔记&#xff0c;记录了JavaScript的学习过程。在写博客的时候我会尽量详尽的记录每个知识点。如果你完全没接触过JavaScript&#xff0c;那么这一系列的学习笔记可能会对你有所帮助。 今天继续学习JavaScript内置的对象&#xff0c;主要是Json、Set、Map。 …
阅读更多...
02正式学习第一天

02正式学习第一天

1、windows上加载socket库 链接输入ws2_32.lib 代码code&#xff1a; #ifdef _WIN32 #include<windows.h> #else #include <sys/socket.h> #include<sys/types.h> #include<unistd.h> #include<cstring> #include<arpa/inet.h> #include…
阅读更多...
在jupyter notebook中使用conda环境

在jupyter notebook中使用conda环境

在jupyter notebook中使用conda环境 1. 环境配置 conda activate my-conda-env # this is the environment for your project and code conda install ipykernel conda deactivateconda activate base # could be also some other environment conda install nb_cond…
阅读更多...
Java集成E签宝实现签署

Java集成E签宝实现签署

完整代码&#xff1a;java-boot-highpin-background: 背调服务 (gitee.com) 【暂不开源】 1.在application.yml中配置appid、密钥信息&#xff0c;包含沙箱环境javaesign:host: https://smlopenapi.esign.cnappId: your appIdappSecret: your secret 2.实现电子签的主要流程在…
阅读更多...
主干网络篇 | YOLOv8更换主干网络之EfficientNet

主干网络篇 | YOLOv8更换主干网络之EfficientNet

前言：Hello大家好，我是小哥谈。EfficientNet是一种高效的卷积神经网络架构，由Mingxing Tan和Quoc V. Le在2019年提出，其设计思想是在不增加计算复杂度的情况下提高模型的准确性。它引入了一个称为"复合系数"的概念，该系数用于同时缩放网络的深度、宽度和分辨率。…
阅读更多...
C++类继承基础2——虚函数和纯虚函数

C++类继承基础2——虚函数和纯虚函数

虚函数 如前所述&#xff0c;在C语言中&#xff0c;当我们使用基类的引用或指针调用一个虚成员函数时会执行动态绑定。 因为我们直到运行时才能知道到底调用了哪个版本的虚函数&#xff0c;所以所有虚函数都必须有定义。 通常情况下&#xff0c;如果我们不使用某个函数&…
阅读更多...
C++：继承的介绍和深度解析

C++：继承的介绍和深度解析

一、继承的概念和定义 1.什么是继承&#xff1f; 继承&#xff0c;顾名思义&#xff1a;就和现实生活中&#xff0c;孩子继承父母的东西有点类似。比如&#xff0c;你父亲的财产&#xff0c;你可以继承下来&#xff0c;你就可以使用父亲的钱。 官方一点的介绍&#xff1a; 继承…
阅读更多...
代码随想录阅读笔记-二叉树【对称二叉树】

代码随想录阅读笔记-二叉树【对称二叉树】

题目 给定一个二叉树&#xff0c;检查它是否是镜像对称的。 思路 首先想清楚&#xff0c;判断对称二叉树要比较的是哪两个节点&#xff0c;要比较的可不是左右节点&#xff01; 对于二叉树是否对称&#xff0c;要比较的是根节点的左子树与右子树是不是相互翻转的&#xff0…
阅读更多...
2024 ccfcsp认证打卡 2021 12 01 序列查询

2024 ccfcsp认证打卡 2021 12 01 序列查询

2021 12-1 序列查询 题解1题解2区别第一种算法&#xff1a;第二种算法&#xff1a; 题解1 import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner sc new Scanner(System.in);// 输入n表示商品数目&#xff0c;N表示总数int n sc.n…
阅读更多...
使用Vite安装TailwindCSS

使用Vite安装TailwindCSS

一、认识TailwindCSS Tailwind CSS 是一个基于原子类的 CSS 框架&#xff0c;它提供了一种不同于传统 CSS 框架的方式来构建用户界面。下面是关于 Tailwind CSS 的优缺点以及它适合应用的情况&#xff1a; 优点&#xff1a; 灵活性&#xff1a; Tailwind CSS 提供了大量的原…
阅读更多...
Portal Particle

Portal Particle

Unity3D Portal Particle 2.2传送门粒子效果 链接&#xff1a;https://pan.baidu.com/s/1TCMXIif5d288lXHgixnDPw?pwd1234 下载&#xff1a;资源下载链接 效果图&#xff1a;
阅读更多...
Java虚拟机（JVM）知识点总结

Java虚拟机（JVM）知识点总结

一. Java内存区域 1. JVM的内存区域划分&#xff0c;以及各部分的作用 可分为运行时数据区域和本地内存&#xff0c;按照线程私有和线程共享分类&#xff1a; 线程私有&#xff1a;程序计数器、虚拟机栈、本地方法栈。 线程共享&#xff1a;堆、方法区、直接内存。 JDK1.7…
阅读更多...
V R虚拟现实元宇宙的前景|虚拟现实体验店加 盟合作|V R设备在线购买

V R虚拟现实元宇宙的前景|虚拟现实体验店加 盟合作|V R设备在线购买

VR&#xff08;虚拟现实&#xff09;技术作为一种新兴的技术&#xff0c;正在逐渐改变人们的生活和工作方式。随着技术的不断进步&#xff0c;人们对于元宇宙的概念也越来越感兴趣。元宇宙是一个虚拟世界&#xff0c;通过VR技术可以实现人们在其中进行各种活动和交互。 元宇宙的…
阅读更多...
(C++17) std算法之执行策略 execution

(C++17) std算法之执行策略 execution

文章目录 前言Code测试Code运行效果 msvc源码描述源码std::sequenced_policy seqstd::parallel_policy parstd::parallel_unsequenced_policy par_unseqstd::unsequenced_policy unseq END 前言 ref:算法库-执行策略 - cppreference.com 利用多核cpu加速算法在目前看来已经不是…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023