C++并发编程Mutex、Condition Variable、future区别和特点

在C++中，互斥量（Mutex）、条件变量（Condition Variable）、期望（std::future 和 std::promise）是用于实现并发编程的三个关键工具。它们各自有不同的作用，下面是它们的详细解释和独特点：

1. 互斥量（Mutex）：

作用：
互斥量用于实现临界区的互斥访问，确保在同一时刻只有一个线程可以访问被互斥锁保护的共享资源。

特点和使用：
使用 std::mutex 或其变体（如 std::recursive_mutex）来创建互斥锁。
通过 std::lock_guard 或 std::unique_lock 来管理互斥锁的锁定和解锁。
适用于需要保护共享资源免受并发访问的场景。

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

std::mutex mtx;

void example_function() {
    std::lock_guard<std::mutex> lock(mtx);
    // 互斥区，对共享资源的访问受到保护
    // ...
}  // 锁在此处自动释放

2. 条件变量（Condition Variable）：

作用：
条件变量用于实现线程之间的协同操作，允许一个线程等待某个特定条件的发生，而其他线程可以在条件满足时通知等待的线程。

特点和使用：
使用 std::condition_variable 创建条件变量。
与互斥锁一起使用，通常需要 std::unique_lock 进行锁的管理。
适用于线程之间需要等待某个条件满足才能继续执行的情况。

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

std::mutex mtx;
std::condition_variable cv;
bool condition = false;

void producer() {
    std::lock_guard<std::mutex> lock(mtx);
    condition = true;
    cv.notify_one();
}

void consumer() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return condition; });
    // 条件满足后继续执行
}

int main() {
    std::thread producer_thread(producer);
    std::thread consumer_thread(consumer);

    producer_thread.join();
    consumer_thread.join();

    return 0;
}

3. 期望（std::future 和 std::promise）：

作用：
期望用于异步编程，允许一个线程获取另一个线程的异步任务的结果。

特点和使用：
使用 std::future 表示异步任务的未来结果，使用 std::promise 设置异步任务的值。
通过 std::async 或 std::packaged_task 创建异步任务。
适用于在一个线程中执行任务，而另一个线程等待任务的结果。

#include <iostream>
#include <future>

int add(int a, int b) {
    return a + b;
}

int main() {
    std::promise<int> promise_result;
    std::future<int> future_result = promise_result.get_future();

    std::thread([&](std::promise<int>& p) {
        p.set_value(add(1, 2));
    }, std::ref(promise_result)).detach();

    int result = future_result.get();
    std::cout << "Result: " << result << std::endl;

    return 0;
}

总结：
互斥量用于保护共享资源，防止并发访问。
条件变量用于线程之间的协同操作，等待某个条件满足后继续执行。
期望用于异步编程，允许一个线程获取另一个线程的异步任务的结果。