C++如何进行多线程同步_C++互斥锁(mutex)与条件变量(condition_variable)

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

C++如何进行多线程同步_C++互斥锁(mutex)与条件变量(condition_variable)

2025-11-22

浏览次数：次

返回列表

互斥锁和条件变量是C++多线程同步的核心工具。1. 互斥锁（std::mutex）通过加锁保护共享资源，防止数据竞争，常用RAII封装如std::lock_guard和std::unique_lock确保异常安全；2. 条件变量（std::condition_variable）配合std::unique_lock实现线程间通信，允许线程等待特定条件成立，典型用于生产者-消费者模型；3. 使用wait()时需循环检查谓词以避免虚假唤醒，notify_one()或notify_all()在状态改变后唤醒等待线程。正确组合二者可解决大多数线程同步问题。

c++如何进行多线程同步_c++互斥锁(mutex)与条件变量(condition_variable)

在C++多线程编程中，多个线程同时访问共享资源容易引发数据竞争和不一致问题。为保证线程安全，必须使用同步机制。最常用的两种工具是互斥锁（mutex）和条件变量（condition_variable）。它们通常配合使用，实现对共享资源的安全访问和线程间通信。

互斥锁（std::mutex）保护共享资源

互斥锁用于确保同一时间只有一个线程能访问临界区。通过加锁和解锁操作，防止多个线程同时修改共享数据。

常用类型包括：

std::mutex：最基本的互斥锁
std::lock_guard：RAII风格的锁管理，构造时加锁，析构时自动解锁
std::unique_lock：更灵活的锁，支持延迟加锁、手动释放，常与条件变量配合使用

示例：使用 lock_guard 保护共享计数器

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

std::mutex mtx;
int counter = 0;

void increment() {
    for (int i = 0; i < 1000; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        ++counter;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

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

    std::cout << "Final counter value: " << counter << std::endl; // 输出 2000
    return 0;
}

条件变量（std::condition_variable）实现线程等待与唤醒

条件变量允许线程在某个条件不满足时进入等待状态，直到其他线程通知条件已达成。它不能单独使用，必须配合 std::unique_lock。

CA.LA

第一款时尚产品在线设计平台，服装设计系统

94 查看详情 CA.LA

核心方法：

wait(lock, predicate)：释放锁并阻塞线程，直到被唤醒且谓词为真
notify_one()：唤醒一个等待中的线程
notify_all()：唤醒所有等待中的线程

典型应用场景：生产者-消费者模型

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

std::queue<int> data_queue;
std::mutex mtx;
std::condition_variable cv;
bool finished = false;

void producer() {
    for (int i = 0; i < 5; ++i) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        std::unique_lock<std::mutex> lock(mtx);
        data_queue.push(i);
        std::cout << "Produced: " << i << std::endl;
        lock.unlock();
        cv.notify_one(); // 唤醒消费者
    }
    {
        std::unique_lock<std::mutex> lock(mtx);
        finished = true;
    }
    cv.notify_all(); // 通知所有消费者结束
}

void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [] { 
            return !data_queue.empty() || finished; 
        });

        if (finished && data_queue.empty()) {
            break;
        }

        int value = data_queue.front();
        data_queue.pop();
        lock.unlock();

        std::cout << "Consumed: " << value << std::endl;
    }
}

int main() {
    std::thread p(producer);
    std::thread c1(consumer);
    std::thread c2(consumer);

    p.join();
    c1.join();
    c2.join();

    return 0;
}