Linux 线程同步与互斥深度解析：从锁机制到生产者消费者模型

运行结果：出现负数票

原因：

1. if (ticket > 0)判断后，线程可能被切换，其他线程继续修改ticket；
2. ticket--对应三条汇编指令（load→update→store），非原子操作，可能被打断。

解决思路：互斥保证同一时间只有一个线程访问临界资源，同步保证线程按合理顺序访问。

1.2 核心概念铺垫

• 共享资源：多个线程均可访问的资源（如全局变量、堆内存、文件描述符）；
• 临界资源：需要被保护的共享资源（如售票系统的ticket）；
• 临界区：访问临界资源的代码段（如if (ticket > 0)到ticket--的代码）；
• 互斥：任何时刻仅允许一个线程进入临界区，保证资源独占访问；
• 同步：在互斥基础上，保证线程按预期顺序访问资源（如生产者先生产，消费者后消费）；
• 原子操作：不可被打断的操作（如硬件提供的swap指令），是互斥的底层基础。

二、线程互斥：用互斥量（mutex）守护临界资源

互斥量（mutex）是 Linux 提供的核心互斥工具，本质是一把'锁'，通过原子操作实现锁的获取与释放，确保临界区的独占访问。

2.1 互斥的核心：临界资源与临界区

• 临界区必须是'最小粒度'：仅包含访问临界资源的必要代码，避免过度阻塞影响并发效率；
• 互斥的三大要求：
  1. 互斥性：同一时间仅一个线程进入临界区；
  2. 空闲让进：临界区空闲时，允许等待线程进入；
  3. 有限等待：线程等待锁的时间有限，避免饥饿。

2.2 互斥量接口与实战

POSIX 线程库提供互斥量相关接口，需包含<pthread.h>，链接时加-lpthread。

2.2.1 互斥量核心接口

2.2.2 实战：改进售票系统

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

int ticket = 100;
pthread_mutex_t mutex;

void* sell_ticket(void* arg) {
    char* id = (char*)arg;
    while(1) {
        int current_ticket = 0; // 临界区：只保护共享数据的读写
        pthread_mutex_lock(&mutex);
        if(ticket <= 0) {
            pthread_mutex_unlock(&mutex);
            break;
        }
        current_ticket = ticket;
        ticket--;
        pthread_mutex_unlock(&mutex);
        // 模拟耗时操作
        usleep(1000);
        printf("%s sells ticket:%d\n", id, current_ticket);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2, t3, t4;
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&t1, NULL, sell_ticket, (void*)"thread 1");
    pthread_create(&t2, NULL, sell_ticket, (void*)"thread 2");
    pthread_create(&t3, NULL, sell_ticket, (void*)"thread 3");
    pthread_create(&t4, NULL, sell_ticket, (void*)"thread 4");
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
    pthread_mutex_destroy(&mutex);
    return 0;
}

运行结果：无负数票，每个线程独占临界区，数据一致。

2.3 RAII 风格锁封装：避免锁泄漏

手动加锁/解锁容易出现'忘记解锁'或'异常时未解锁'的问题，采用 RAII（资源获取即初始化）风格封装锁，利用 C++ 析构函数自动释放锁：

// Lock.hpp
#pragma once
#include <pthread.h>

namespace LockModule {
class Mutex {
public:
    Mutex() { pthread_mutex_init(&_mutex, NULL); }
    ~Mutex() { pthread_mutex_destroy(&_mutex); }
    void Lock() { pthread_mutex_lock(&_mutex); }
    void Unlock() { pthread_mutex_unlock(&_mutex); }
    pthread_mutex_t* GetRawMutex() { return &_mutex; }
private:
    Mutex(const Mutex&) = delete; // 禁止拷贝
    Mutex& operator=(const Mutex&) = delete;
    pthread_mutex_t _mutex;
};

// RAII 锁，构造加锁，析构解锁
class LockGuard {
public:
    LockGuard(Mutex& mutex) : _mutex(mutex) { _mutex.Lock(); }
    ~LockGuard() { _mutex.Unlock(); }
private:
    LockGuard(const LockGuard&) = delete;
    LockGuard& operator=(const LockGuard&) = delete;
    Mutex& _mutex;
};
}

使用改进：

// test.cpp
#include "Lock.hpp"
#include <stdio.h>
#include <unistd.h>

using namespace LockModule;

int ticket = 100;
Mutex mutex;

void* sell_ticket(void* arg) {
    char* id = (char*)arg;
    while(1) {
        // 先获取数据，尽快释放锁
        int current_ticket = 0;
        {
            LockGuard lock(mutex);
            if(ticket <= 0) break;
            current_ticket = ticket;
            ticket--;
        }
        // 锁在这里就释放了
        // 模拟耗时操作
        usleep(1000);
        printf("%s sells ticket:%d\n", id, current_ticket);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2, t3, t4;
    pthread_create(&t1, NULL, sell_ticket, (void*)"thread 1");
    pthread_create(&t2, NULL, sell_ticket, (void*)"thread 2");
    pthread_create(&t3, NULL, sell_ticket, (void*)"thread 3");
    pthread_create(&t4, NULL, sell_ticket, (void*)"thread 4");
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
    return 0;
}

三、线程同步：条件变量（cond）实现有序协作

互斥量解决了'同一时间只有一个线程访问资源'，但无法解决'线程按顺序访问'的问题。例如上面的售票系统输出顺序我们是无法控制的，此时需要条件变量。

3.1 同步的意义：解决'竞态条件'

• 竞态条件：因线程执行时序不确定导致程序异常（如消费者先消费空队列）；
• 同步：在保证互斥的基础上，让线程按预期顺序执行，避免竞态条件。

3.2 条件变量接口与核心原理

条件变量允许线程在某个条件不满足时主动等待，当条件满足时被其他线程唤醒。它本身不保证互斥，需与互斥量配合使用，核心接口如下：

为什么 pthread_cond_wait 需要互斥量？

1. 条件的判断和修改依赖共享资源（如队列是否为空），需互斥保护；
2. 解锁和等待必须是原子操作：若先解锁再等待，可能错过其他线程的信号，导致永久阻塞。pthread_cond_wait内部自动完成'解锁→等待→唤醒后加锁'的原子流程。

3.3 条件变量使用规范

等待条件：必须用 while 循环，而非 if，避免伪唤醒（线程被唤醒但条件未满足）：

pthread_mutex_lock(&mutex);
while(条件不满足) { // 如队列空、队列满
    pthread_cond_wait(&cond, &mutex);
}
// 处理临界资源
pthread_mutex_unlock(&mutex);

发送信号：修改条件后发送信号，且需在互斥量保护内：

pthread_mutex_lock(&mutex);
// 修改条件 // 如向队列添加元素、移除元素
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);

3.4 条件变量封装

// Cond.hpp
#pragma once
#include "Lock.hpp"
#include <pthread.h>

namespace CondModule {
using namespace LockModule;

class Cond {
public:
    Cond() { pthread_cond_init(&_cond, NULL); }
    ~Cond() { pthread_cond_destroy(&_cond); }
    void Wait(Mutex& mutex) { // 传入互斥量，解耦
        pthread_cond_wait(&_cond, mutex.GetRawMutex());
    }
    void Signal() { pthread_cond_signal(&_cond); }
    void Broadcast() { pthread_cond_broadcast(&_cond); }
private:
    Cond(const Cond&) = delete;
    Cond& operator=(const Cond&) = delete;
    pthread_cond_t _cond;
};
}

// test.cpp
#include "Cond.hpp"
#include <stdio.h>
#include <unistd.h>

using namespace LockModule;
using namespace CondModule;

int ticket = 100;
Mutex mutex;
Cond cond; // 当前应该执行的线程 ID（1,2,3,4）
int current_thread_id = 1;

void* sell_ticket(void* arg) {
    int my_id = *(int*)arg;
    char id_str[20];
    sprintf(id_str, "thread %d", my_id);
    while(1) {
        {
            LockGuard lock(mutex);
            // 等待轮到自己执行
            while(current_thread_id != my_id && ticket > 0) {
                cond.Wait(mutex);
            }
            // 检查票是否卖完
            if(ticket <= 0) {
                // 通知下一个线程，让它也退出
                current_thread_id = (current_thread_id % 4) + 1;
                cond.Broadcast(); // 唤醒所有等待的线程
                break;
            }
            // 卖票
            int current_ticket = ticket;
            ticket--;
            // 更新下一个应该执行的线程
            current_thread_id = (current_thread_id % 4) + 1;
            // 打印售票信息（在锁内打印确保顺序）
            printf("%s sells ticket:%d\n", id_str, current_ticket);
            // 通知下一个线程
            cond.Broadcast(); // 唤醒所有等待的线程
        }
        // 在锁外模拟耗时操作
        usleep(1000);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2, t3, t4;
    int thread_ids[4] = {1, 2, 3, 4};
    pthread_create(&t1, NULL, sell_ticket, (void*)&thread_ids[0]);
    pthread_create(&t2, NULL, sell_ticket, (void*)&thread_ids[1]);
    pthread_create(&t3, NULL, sell_ticket, (void*)&thread_ids[2]);
    pthread_create(&t4, NULL, sell_ticket, (void*)&thread_ids[3]);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
    return 0;
}

这样我们就利用了条件变量实现了售票的同步。

四、生产者消费者模型：同步互斥的经典实战

生产者消费者模型是同步互斥的典型应用，核心是'解耦生产者和消费者，平衡处理能力'，遵循321 原则：

• 3 种关系：生产者与生产者（互斥）、消费者与消费者（互斥）、生产者与消费者（同步 + 互斥）；
• 2 个角色：生产者（生产数据）、消费者（消费数据）；
• 1 个容器：阻塞队列/环形队列（存储数据，解耦角色）。

4.1 模型核心价值

1. 解耦：生产者和消费者无需知道对方存在，仅通过容器交互；
2. 支持并发：多个生产者/消费者可同时工作；
3. 平衡负载：生产者生产快时，容器缓存数据；消费者消费快时，容器空则阻塞等待。

4.2 实现一：基于阻塞队列（动态大小）

阻塞队列是动态大小的容器，特点：

• 队列为空时，消费者阻塞；
• 队列满时（可选限制），生产者阻塞；

基于 std::queue+ 互斥量 + 条件变量实现。

完整代码（BlockQueue.hpp）

#pragma once
#include <queue>
#include "Lock.hpp"
#include "Cond.hpp"

namespace Model {
using namespace LockModule;
using namespace CondModule;

template<typename T>
class BlockQueue {
public:
    BlockQueue(int cap = 10) : _cap(cap), _stop(false) {}
    ~BlockQueue() {
        // 析构时停止队列，唤醒所有阻塞线程
        Stop();
    }

    // 停止队列
    void Stop() {
        LockGuard lock(_mutex);
        _stop = true;
        // 广播所有条件变量，唤醒所有阻塞线程
        _prod_cond.Broadcast();
        _cons_cond.Broadcast();
    }

    // 生产者入队：返回是否成功（如果队列已停止，返回 false）
    bool Enqueue(const T& data) {
        LockGuard lock(_mutex);
        // 队列满且未停止时，阻塞等待
        while(_queue.size() >= _cap && !_stop) {
            _prod_cond.Wait(_mutex);
        }
        // 如果队列已停止，直接返回失败
        if(_stop) {
            return false;
        }
        // 生产数据
        _queue.push(data);
        // 唤醒一个等待的消费者（队列非空了）
        _cons_cond.Signal();
        return true;
    }

    // 消费者出队：返回是否成功（如果队列已停止且为空，返回 false）
    bool Dequeue(T& data) {
        LockGuard lock(_mutex);
        // 队列为空且未停止时，阻塞等待
        while(_queue.empty() && !_stop) {
            _cons_cond.Wait(_mutex);
        }
        // 如果队列已停止且为空，返回失败
        if(_stop && _queue.empty()) {
            return false;
        }
        // 消费数据
        data = _queue.front();
        _queue.pop();
        // 唤醒一个等待的生产者（队列未满了）
        _prod_cond.Signal();
        return true;
    }

    // 判断队列是否已停止（可选接口）
    bool IsStopped() const {
        LockGuard lock(_mutex);
        return _stop;
    }
    size_t Size() {
        LockGuard lock(_mutex);
        return _queue.size();
    }

private:
    std::queue<T> _queue; // 任务队列
    int _cap; // 队列最大容量
    Mutex _mutex; // 保护队列的互斥量
    Cond _prod_cond; // 生产者条件变量（队列不满）
    Cond _cons_cond; // 消费者条件变量（队列不空）
    bool _stop; // 退出标志（是否停止队列）
};
}

测试代码

#include "BlockQueue.hpp" // 包含修复后的阻塞队列实现
#include <pthread.h>
#include <iostream>
#include <unistd.h>
#include <string>

using namespace Model;
using namespace std;

// 全局阻塞队列（容量设为 3，方便观察阻塞效果）
BlockQueue<string> g_task_queue(3);

// 生产者线程函数：生成 10 个任务，之后退出
void* ProducerThread(void* arg) {
    const char* producer_name = static_cast<const char*>(arg);
    cout << "[" << producer_name << "] 启动，开始生产任务..." << endl;
    for(int i = 0; i < 10; ++i) {
        // 生成任务（模拟任务数据）
        string task = "任务 -" + to_string(i);
        // 入队（队列满时会阻塞）
        bool ret = g_task_queue.Enqueue(task);
        if(!ret) {
            cout << "[" << producer_name << "] 队列已停止，停止生产" << endl;
            break;
        }
        cout << "[" << producer_name << "] 生产任务：" << task << " | 队列当前大小：" << g_task_queue.Size() << endl;
        // 模拟生产耗时（1 秒/个）
        sleep(1);
    }
    cout << "[" << producer_name << "] 生产完毕，退出线程" << endl;
    return nullptr;
}

// 消费者线程函数：持续消费任务，直到队列停止且为空
void* ConsumerThread(void* arg) {
    const char* consumer_name = static_cast<const char*>(arg);
    cout << "[" << consumer_name << "] 启动，开始消费任务..." << endl;
    while(true) {
        string task;
        // 出队（队列为空时会阻塞）
        bool ret = g_task_queue.Dequeue(task);
        if(!ret) {
            cout << "[" << consumer_name << "] 队列已停止且无任务，退出消费" << endl;
            break;
        }
        cout << "[" << consumer_name << "] 消费任务：" << task << " | 队列当前大小：" << g_task_queue.Size() << endl;
        // 模拟消费耗时（2 秒/个，故意比生产慢，触发队列满阻塞生产者）
        sleep(2);
    }
    cout << "[" << consumer_name << "] 消费完毕，退出线程" << endl;
    return nullptr;
}

int main() {
    pthread_t producer, consumer;
    const char* prod_name = "生产者";
    const char* cons_name = "消费者";

    // 创建生产者和消费者线程
    pthread_create(&producer, nullptr, ProducerThread, (void*)prod_name);
    pthread_create(&consumer, nullptr, ConsumerThread, (void*)cons_name);

    // 主线程等待 20 秒（确保生产者完成所有任务，消费者消费完毕）
    cout << "主线程：等待 20 秒后停止队列..." << endl;
    sleep(20);

    // 停止队列（优雅唤醒阻塞的线程）
    cout << "主线程：停止队列" << endl;
    g_task_queue.Stop();

    // 等待线程退出（回收资源）
    pthread_join(producer, nullptr);
    pthread_join(consumer, nullptr);
    cout << "主线程：所有线程退出，程序结束" << endl;
    return 0;
}

4.3 实现二：基于环形队列（固定大小）

环形队列是固定大小的数组，用模运算实现'环形'，特点：

• 无需动态扩容，性能更优；
• 用信号量实现同步，互斥量实现生产者/消费者内部互斥；
• 适合对性能要求高、数据量可预估的场景。

核心思路

• 信号量 _empty：表示空闲空间数，初始为队列容量；
• 信号量 _full：表示已用空间数，初始为 0；
• 生产者：P(_empty)→生产→V(_full)；
• 消费者：P(_full)→消费→V(_empty)；

互斥量 _prod_mutex/_cons_mutex：保证多个生产者/消费者的互斥访问。

完整代码（RingQueue.hpp）

#pragma once
#include <vector>
#include <pthread.h>
#include <semaphore.h>

namespace Model {
template<typename T>
class RingQueue {
public:
    RingQueue(int cap = 10) : _cap(cap), _prod_idx(0), _cons_idx(0) {
        _queue.resize(_cap);
        // 初始化信号量
        sem_init(&_empty, 0, _cap); // 0 表示线程间共享
        sem_init(&_full, 0, 0);
        // 初始化互斥量
        pthread_mutex_init(&_prod_mutex, NULL);
        pthread_mutex_init(&_cons_mutex, NULL);
    }

    ~RingQueue() {
        sem_destroy(&_empty);
        sem_destroy(&_full);
        pthread_mutex_destroy(&_prod_mutex);
        pthread_mutex_destroy(&_cons_mutex);
    }

    // 生产者入队
    void Enqueue(const T& data) {
        sem_wait(&_empty); // P 操作：空闲空间 -1，无空间则阻塞
        pthread_mutex_lock(&_prod_mutex); // 多个生产者互斥
        // 生产数据
        _queue[_prod_idx] = data;
        _prod_idx = (_prod_idx + 1) % _cap; // 环形索引
        pthread_mutex_unlock(&_prod_mutex);
        sem_post(&_full); // V 操作：已用空间 +1，唤醒消费者
    }

    // 消费者出队
    bool Dequeue(T& data) {
        sem_wait(&_full); // P 操作：已用空间 -1，无数据则阻塞
        pthread_mutex_lock(&_cons_mutex); // 多个消费者互斥
        // 消费数据
        data = _queue[_cons_idx];
        _cons_idx = (_cons_idx + 1) % _cap;
        pthread_mutex_unlock(&_cons_mutex);
        sem_post(&_empty); // V 操作：空闲空间 +1，唤醒生产者
        return true;
    }

private:
    std::vector<T> _queue; // 环形队列数组
    int _cap; // 固定容量
    int _prod_idx; // 生产者索引
    int _cons_idx; // 消费者索引
    sem_t _empty; // 空闲空间信号量
    sem_t _full; // 已用空间信号量
    pthread_mutex_t _prod_mutex; // 生产者互斥量
    pthread_mutex_t _cons_mutex; // 消费者互斥量
};
}

测试代码：

#include <iostream>
#include <unistd.h> // 用于 sleep
#include <cstdlib> // 用于 rand、srand
#include <ctime> // 用于 time（设置随机数种子）
#include "RingQueue.hpp" // 你的环形队列头文件
#include "Lock.hpp" // 你的互斥锁头文件
#include "Cond.hpp" // 你的条件变量头文件

using namespace std;
using namespace Model;

// 测试数据量（可调整）
const int TEST_DATA_COUNT = 20;

// 生产者线程函数：向环形队列中写入数据
void* ProducerThread(void* arg) {
    RingQueue<int>* rq = static_cast<RingQueue<int>*>(arg);
    srand(time(nullptr)); // 设置随机数种子（仅生产者设置一次即可）
    for(int i = 0; i < TEST_DATA_COUNT; ++i) {
        // 生成 1~100 的随机数作为测试数据
        int data = rand() % 100 + 1;
        // 入队
        rq->Enqueue(data);
        cout << "[生产者] 写入数据：" << data << endl;
        // 模拟生产耗时（100~300 毫秒），让测试更直观
        usleep(rand() % 200000 + 100000);
    }
    cout << "[生产者] 数据写入完成，退出线程" << endl;
    pthread_exit(nullptr);
}

// 消费者线程函数：从环形队列中读取数据
void* ConsumerThread(void* arg) {
    RingQueue<int>* rq = static_cast<RingQueue<int>*>(arg);
    int data = 0;
    for(int i = 0; i < TEST_DATA_COUNT; ++i) {
        // 出队
        bool ret = rq->Dequeue(data);
        if(ret) {
            cout << "[消费者] 读取数据：" << data << endl;
        } else {
            cout << "[消费者] 出队失败！" << endl;
        }
        // 模拟消费耗时（150~400 毫秒），与生产耗时错开，体现同步
        usleep(rand() % 250000 + 150000);
    }
    cout << "[消费者] 数据读取完成，退出线程" << endl;
    pthread_exit(nullptr);
}

int main() {
    // 创建环形队列（容量设为 5，测试环形特性）
    RingQueue<int> ring_queue(5);
    pthread_t prod_tid, cons_tid;
    int ret = 0;

    // 创建生产者线程
    ret = pthread_create(&prod_tid, nullptr, ProducerThread, &ring_queue);
    if(ret != 0) {
        cerr << "创建生产者线程失败！错误码：" << ret << endl;
        return -1;
    }

    // 创建消费者线程
    ret = pthread_create(&cons_tid, nullptr, ConsumerThread, &ring_queue);
    if(ret != 0) {
        cerr << "创建消费者线程失败！错误码：" << ret << endl;
        return -1;
    }

    // 等待两个线程结束
    ret = pthread_join(prod_tid, nullptr);
    if(ret != 0) {
        cerr << "等待生产者线程失败！错误码：" << ret << endl;
        return -1;
    }
    ret = pthread_join(cons_tid, nullptr);
    if(ret != 0) {
        cerr << "等待消费者线程失败！错误码：" << ret << endl;
        return -1;
    }
    cout << "\n===== 单生产者单消费者测试完成 =====" << endl;
    return 0;
}

4.4 两种模型对比与选型

五、线程安全与可重入问题

线程安全和可重入是多线程编程中容易混淆的概念，需明确区分：

5.1 线程安全：多线程访问的一致性保障

• 定义：多个线程并发访问同一资源时，结果始终符合预期，无数据竞争；
• 线程安全的场景：
  • 仅访问局部变量（每个线程有独立栈空间）；
  • 访问共享资源但有互斥保护（如加锁）；
  • 仅读取共享资源（无写入操作）；
• 线程不安全的场景：
  • 无保护地修改全局变量/静态变量；
  • 函数状态随调用变化（如返回静态变量指针）；
  • 调用线程不安全的函数（如 strtok）。

5.2 可重入函数：重入场景下的正确性

• 定义：同一函数被多个执行流（线程/信号处理函数）重入时，运行结果正确；
• 可重入的场景：
  • 不使用全局变量/静态变量；
  • 不调用 malloc/free（依赖全局堆管理）；
  • 不调用标准 I/O 库函数（依赖全局缓冲区）；
  • 所有数据来自参数或局部变量；
• 不可重入的场景：
  • 使用全局变量/静态变量；
  • 调用不可重入函数（如 malloc、printf）；
  • 返回静态变量指针（如 char* get_str() { static char buf[1024]; return buf; }）。

5.3 核心区别与联系

六、死锁

死锁是多线程编程的常见问题，指多个线程互相持有对方需要的锁，且均不释放，导致永久阻塞。

6.1 死锁的四个必要条件

1. 互斥条件：资源只能被一个线程持有；
2. 请求与保持条件：线程持有部分资源，同时请求其他线程的资源；
3. 不剥夺条件：资源不能被强行剥夺，只能由持有者主动释放；
4. 循环等待条件：线程间形成'线程 A（持 lock1，等 lock2）→ 线程 B（持 lock2，等 lock3）→ 线程 C（持 lock3，等 lock1）→ 线程 A'的循环。

6.2 避免死锁的实战方法

方法 1：破坏循环等待条件（最常用）

• 给锁编号，所有线程按统一顺序加锁；
• 示例：线程 A 和 B 都需要锁 1 和锁 2，约定先加锁 1，再加锁 2：

// 正确：按顺序加锁
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
// 操作资源
pthread_mutex_unlock(&lock2);
pthread_mutex_unlock(&lock1);

方法 2：破坏请求与保持条件

• 一次性申请所有需要的资源，申请失败则释放已申请的资源；
• 示例：使用 pthread_mutex_trylock 尝试加锁，失败则回滚：

if(pthread_mutex_lock(&lock1)!=0){
    return -1;
}
if(pthread_mutex_trylock(&lock2)!=0){
    pthread_mutex_unlock(&lock1); // 回滚已加的锁
    return -1;
}

方法 3：设置锁超时

• 使用 pthread_mutex_timedlock，超时则释放锁并重试；
• 避免线程永久阻塞。

方法 4：破坏不剥夺条件

• 允许线程在超时后释放已持有的锁（需配合业务逻辑设计）。

七、总结

1. 互斥：用互斥量（mutex）保护临界区，RAII 封装避免锁泄漏；
2. 同步：用条件变量（cond）实现线程有序协作，必须配合互斥量；
3. 生产者消费者模型：阻塞队列（灵活）和环形队列（高性能），解耦并发角色；
4. 线程池：预创建线程，避免线程频繁创建销毁，提升高并发性能；
5. 避坑：区分线程安全与可重入，避免死锁。