Linux C++ 编程死锁详解

PM简读馆2025-03-18 13:52

🎓作者简介：程序员转项目管理领域优质创作者

💌个人邮箱：[[email protected]]

🌐PMP资料导航：PM菜鸟（查阅PMP大纲考点）

💡座右铭：上善若水，水善利万物而不争。

🌐绿泡泡：PM简读馆（包含更多PM常用免费资料）

目录

概要

一、死锁的四个必要条件

二、常见死锁场景

三、代码解释

1、资源申请顺序不一致

问题描述

解决方案

[2. 优先级倒置](#2. 优先级倒置)

问题描述

解决方案

[3. 线程间循环等待](#3. 线程间循环等待)

问题描述

解决方案

[4. 锁嵌套（Lock Nesting）](#4. 锁嵌套（Lock Nesting）)

问题描述

解决方案

概要

在多线程编程的领域中，死锁是一个经典顽疾 。当多个线程因资源争夺陷入永久等待 ，所有线程都会集体 "冻住"。就像两人过桥面宽度 = 1 的独木桥：左行的 A 和右行的 B 在桥中相遇，谁都不退让，最终双双困在桥面 ------ 这正是循环等待条件的现实映射。

程序中的死锁常发生于交叉持锁场景：线程 A 已握互斥锁 1（pthread_mutex_lock (1)），试图获取锁 2；线程 B 正持有锁 2，同时等待锁 1。此时内核调度若恰好切换线程，双方将陷入 "你等我放锁，我等你松手" 的僵局，CPU 空转但任务停滞。

死锁的破坏力极具隐蔽性：服务器可能 100% CPU 空转却无业务响应，嵌入式系统突然 "死机" 却无报错日志。这类时序相关的逻辑错误，无法通过单步调试发现，必须依赖系统级排查工具。

一、死锁的四个必要条件

先认识一些死锁的发生需要满足哪几个条件：

  1. 互斥（Mutual Exclusion）：资源一次只能被一个线程使用。
  2. 持有并等待（Hold and Wait）：线程在持有资源的同时，请求其他资源。
  3. 不剥夺（No Preemption）：资源不能被强制剥夺，只能由持有者主动释放。
  4. 循环等待（Circular Wait）：线程之间形成一个环，每个线程都在等待下一个线程释放资源。

二、常见死锁场景

在Linux C++编程中，以下场景容易导致死锁：

  1. 资源申请顺序不一致：多个线程以不同的顺序申请相同的资源。
  2. 优先级倒置：高优先级线程被低优先级线程占用资源，导致阻塞。
  3. 线程间循环等待：线程A等待线程B释放资源，线程B又在等待线程A释放资源。
  4. 锁嵌套（Lock Nesting）：在一个锁的保护范围内申请另一个锁，导致锁顺序不一致。

三、代码解释

1、资源申请顺序不一致

问题描述

多个线程以不同的顺序申请相同的资源，导致死锁。

cpp 复制代码 
#include <mutex>
#include <thread>
#include <iostream>

std::mutex mutex1, mutex2;

void threadA() {
    std::lock_guard<std::mutex> lock1(mutex1);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::lock_guard<std::mutex> lock2(mutex2);
    // 临界区代码
}

void threadB() {
    std::lock_guard<std::mutex> lock2(mutex2);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::lock_guard<std::mutex> lock1(mutex1);
    // 临界区代码
}

int main() {
    std::thread t1(threadA);
    std::thread t2(threadB);
    t1.join();
    t2.join();
    return 0;
}
解决方案

确保所有线程以相同的顺序申请锁：

cpp 复制代码 
#include <mutex>
#include <thread>
#include <iostream>

std::mutex mutex1, mutex2;

void acquire_locks(std::mutex& lock1, std::mutex& lock2) {
    if (&lock1 > &lock2) {
        std::lock_guard<std::mutex> lock(lock1);
        std::lock_guard<std::mutex> lock2(lock2);
    } else {
        std::lock_guard<std::mutex> lock(lock2);
        std::lock_guard<std::mutex> lock1(lock1);
    }
}

void thread_function() {
    acquire_locks(mutex1, mutex2);
    // 临界区代码
}

int main() {
    std::thread t1(thread_function);
    std::thread t2(thread_function);
    t1.join();
    t2.join();
    return 0;
}

2. 优先级倒置

问题描述

高优先级线程被低优先级线程占用资源，导致阻塞。

cpp 复制代码 
#include <pthread.h>
#include <iostream>
#include <unistd.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* high_priority_thread(void* arg) {
    // 设置高优先级
    struct sched_param param;
    param.sched_priority = 50;
    pthread_setschedparam(pthread_self(), SCHED_FIFO, &param);

    // 尝试获取锁
    while (true) {
        pthread_mutex_lock(&mutex);
        std::cout << "High priority thread acquired lock." << std::endl;
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
}

void* low_priority_thread(void* arg) {
    // 设置低优先级
    struct sched_param param;
    param.sched_priority = 10;
    pthread_setschedparam(pthread_self(), SCHED_FIFO, &param);

    // 尝试获取锁
    while (true) {
        pthread_mutex_lock(&mutex);
        std::cout << "Low priority thread acquired lock." << std::endl;
        sleep(1);
        pthread_mutex_unlock(&mutex);
    }
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, high_priority_thread, NULL);
    pthread_create(&t2, NULL, low_priority_thread, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    return 0;
}
解决方案

使用优先级继承协议：

cpp 复制代码 
#include <pthread.h>
#include <iostream>
#include <unistd.h>

pthread_mutex_t mutex;
pthread_mutexattr_t attr;

void* high_priority_thread(void* arg) {
    // 设置高优先级
    struct sched_param param;
    param.sched_priority = 50;
    pthread_setschedparam(pthread_self(), SCHED_FIFO, &param);

    // 尝试获取锁
    while (true) {
        pthread_mutex_lock(&mutex);
        std::cout << "High priority thread acquired lock." << std::endl;
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
}

void* low_priority_thread(void* arg) {
    // 设置低优先级
    struct sched_param param;
    param.sched_priority = 10;
    pthread_setschedparam(pthread_self(), SCHED_FIFO, &param);

    // 尝试获取锁
    while (true) {
        pthread_mutex_lock(&mutex);
        std::cout << "Low priority thread acquired lock." << std::endl;
        sleep(1);
        pthread_mutex_unlock(&mutex);
    }
}

int main() {
    // 初始化mutex属性
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
    pthread_mutex_init(&mutex, &attr);

    pthread_t t1, t2;
    pthread_create(&t1, NULL, high_priority_thread, NULL);
    pthread_create(&t2, NULL, low_priority_thread, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

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

3. 线程间循环等待

问题描述

线程A等待线程B释放资源，线程B又在等待线程A释放资源。

cpp 复制代码 
#include <mutex>
#include <thread>
#include <iostream>

std::mutex mutex1, mutex2;

void threadA() {
    std::lock_guard<std::mutex> lock1(mutex1);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::lock_guard<std::mutex> lock2(mutex2);
    // 临界区代码
}

void threadB() {
    std::lock_guard<std::mutex> lock2(mutex2);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::lock_guard<std::mutex> lock1(mutex1);
    // 临界区代码
}

int main() {
    std::thread t1(threadA);
    std::thread t2(threadB);
    t1.join();
    t2.join();
    return 0;
}
解决方案

重新设计资源分配顺序，避免循环等待：

cpp 复制代码 
#include <mutex>
#include <thread>
#include <iostream>

std::mutex mutex1, mutex2;

void acquire_locks(std::mutex& lock1, std::mutex& lock2) {
    if (&lock1 > &lock2) {
        std::lock_guard<std::mutex> lock(lock1);
        std::lock_guard<std::mutex> lock2(lock2);
    } else {
        std::lock_guard<std::mutex> lock(lock2);
        std::lock_guard<std::mutex> lock1(lock1);
    }
}

void thread_function() {
    acquire_locks(mutex1, mutex2);
    // 临界区代码
}

int main() {
    std::thread t1(thread_function);
    std::thread t2(thread_function);
    t1.join();
    t2.join();
    return 0;
}

4. 锁嵌套（Lock Nesting）

问题描述

在一个锁的保护范围内申请另一个锁，导致锁顺序不一致。

cpp 复制代码 
#include <mutex>
#include <thread>
#include <iostream>

std::mutex mutex1, mutex2;

void nested_locks() {
    std::lock_guard<std::mutex> lock1(mutex1);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::lock_guard<std::mutex> lock2(mutex2);
    // 临界区代码
}

int main() {
    std::thread t(nested_locks);
    t.join();
    return 0;
}
解决方案

避免锁嵌套，确保所有锁以相同的顺序获取：

cpp 复制代码 
#include <mutex>
#include <thread>
#include <iostream>

std::mutex mutex1, mutex2;

void acquire_locks(std::mutex& lock1, std::mutex& lock2) {
    if (&lock1 > &lock2) {
        std::lock_guard<std::mutex> lock(lock1);
        std::lock_guard<std::mutex> lock2(lock2);
    } else {
        std::lock_guard<std::mutex> lock(lock2);
        std::lock_guard<std::mutex> lock1(lock1);
    }
}

void thread_function() {
    acquire_locks(mutex1, mutex2);
    // 临界区代码
}

int main() {
    std::thread t(thread_function);
    t.join();
    return 0;
}
相关推荐
码农不惑9 分钟前
Qt开发：QtWebEngine中操作选择文本
开发语言·javascript·qt·web
enyp8018 分钟前
C++抽象与类的核心概念解析
java·开发语言·c++
eqwaak021 分钟前
Pandas与PySpark混合计算实战：突破单机极限的智能数据处理方案
开发语言·python·科技·学习·pandas
byxdaz23 分钟前
QT编程之HTTP服务端与客户端技术
开发语言·qt·http
年轮不改31 分钟前
Ubuntu 配置 ffmpeg 开发环境
linux·ubuntu·ffmpeg
无名之逆32 分钟前
Hyperlane：轻量、高效、安全的 Rust Web 框架新选择
开发语言·前端·后端·安全·rust·github·ssl
wkj00138 分钟前
js给后端发送请求的方式有哪些
开发语言·前端·javascript
magic 2451 小时前
JavaScript运算符与流程控制详解
开发语言·前端·javascript
小诸葛的博客1 小时前
开发一个go模块并在其他项目中引入
开发语言·后端·golang
风无雨1 小时前
go语言学习教程推荐,零基础到做项目
开发语言·学习·golang
热门推荐
01命令行方式将mysql数据库迁移到达梦数据库（全步骤）02如何在WPS和Word/Excel中直接使用DeepSeek功能03DeepSeek各版本说明与优缺点分析04本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程05从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑06本地部署DeepSeek教程（Mac版本）07四大AI编程工具组合测评08DeepSeek RAGFlow构建本地知识库系统09DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具10USC-HAD数据集介绍及仿真实验