C++多线程示例

示例

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

using namespace std;

queue<int> q; //共享队列，给生产者和消费者同时操作
bool is_done;  //共享变量：判断是否完成
mutex mtx;    //互斥量：保护共享队列
condition_variable cv; //条件变量：同步用


//生产者
void producer() {
    for (int i = 1; i <= 20; ++i) {
        this_thread::sleep_for(std::chrono::milliseconds(10)); // 模拟生产时间：生产比消费快
        unique_lock<std::mutex> lock(mtx); // 加锁：如果不加锁，q可能被消费者，然后这里再生产破坏q
        q.push(i+100);                              // 生产一个任务
        lock.unlock();                          // 解锁
        cv.notify_one();                        // 通知其中一个消费者，具体哪个消费者由调度器决定
    }
    //全部生产完之后，设置标志完成，并通知所有消费者
    unique_lock<std::mutex> lock(mtx);
    is_done = true;                              
    lock.unlock();
    cv.notify_all();                            // 通知所有消费者
}

//消费者：5个
void consumer(int id) {
    while (true) {
        unique_lock<mutex> lock(mtx);
        cv.wait(lock, []{ return !q.empty() || is_done; }); // 等待队列非空或生产者完成
        if (is_done && q.empty())       // 如果队列为空且生产者完成，退出
            break;                    
        int item = q.front();                            // 消费一个任务
        q.pop();
        lock.unlock();
        cout << "Consumer " << id << " consumed item " << item << endl;
        this_thread::sleep_for(chrono::milliseconds(50)); // 模拟消费时间
    }
}

int main() {
    const int num_consumers = 3; // 消费者数量
    thread producer_thread(producer); // 创建生产者线程
    thread consumer_threads[num_consumers]; // 创建消费者线程数组

    // 启动消费者线程
    for (int i = 0; i < num_consumers; ++i) {
        consumer_threads[i] = thread(consumer, i + 1);
    }

    // 等待生产者线程结束
    producer_thread.join();

    // 等待所有消费者线程结束
    for (auto& th : consumer_threads) {
        th.join();
    }

    cout << "All threads finished." << endl;
    return 0;
}

producer() 函数
std::unique_lockstd::mutex lock(mtx);
• 进入临界区，把队列锁住。
• 相比 lock_guard，unique_lock 可以在后面 手动 unlock()，因此更灵活。

lock.unlock();
• 提前解锁的好处：
– 减少锁的粒度，让消费者尽早拿到锁。
– 避免在 notify_one() 时仍然持有锁（某些实现下会导致唤醒线程立即再次阻塞）。

consumer() 函数
cv.wait(lock, predicate)
• wait 会原子地释放 lock 并挂起线程；
• 被唤醒后先重新拿到锁，再检查谓词：
[]{ return !q.empty() || done; }
只要“队列里有东西”或“生产者已经结束”就继续，否则继续睡。
• 这是 防止虚假唤醒 (spurious wakeup) 的标准写法。
while (!q.empty()) { … }
• 生产者可能一次放入多个任务，或通知时队列里已有多条数据，所以用 内层 while 一次性处理干净。
• 注意：仍要在临界区内操作队列。

行退出条件
• 必须同时满足：done == true 且 q.empty()，确保所有数据都被消费完。

常见疑问 & 易错点

为什么用 unique_lock 而不是 lock_guard？
因为 lock_guard 不能中途 unlock()，而 unique_lock 可以，所以更适合配合条件变量。
如果忘记 notify_one() 会怎样？
消费者可能永远阻塞在 cv.wait()，程序卡死。
如果把 done 设成 atomic<bool> 不加锁行不行？
不行。虽然 done 本身是原子，但队列状态仍要互斥，否则会出现“看到 done=true 但队列却非空” 的竞态。
为什么消费者里还要再检查一次 q.empty()？
因为唤醒后可能有多个线程同时被唤醒（如果使用 notify_all()），或者生产者一次 push 了多条数据。

一句话总结
条件变量 + 互斥量 = 线程安全的“等待-通知”机制；
核心套路：
• 修改共享数据 → 加锁
• 修改完 → 先解锁再 notify_*
• 等待方 → while(!predicate) cv.wait(…)

相关函数

1. 线程管理

2. 互斥量

3. 锁管理

4. 条件变量

5. 异步任务

6. 原子操作

7. 线程工具