C++ 线程同步与互斥的四种方式：对比与场景应用

除了直接使用互斥量，C++ 还提供了 std::lock_guard 和 std::unique_lock 两种锁，用于自动管理互斥量的所有权。

#include <thread>
#include <mutex>

std::mutex mtx; // 全局互斥量
int shared_data = 0; // 共享数据

void thread_func() {
    for (int i = 0; i < 10000; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // 创建锁，自动获取互斥量的所有权
        ++shared_data; // 修改共享数据
        // 锁在离开作用域时自动释放互斥量的所有权
    }
}

int main() {
    std::thread t1(thread_func);
    std::thread t2(thread_func);
    t1.join();
    t2.join();
    std::cout << shared_data << std::endl; // 输出 20000
    return 0;
}

在上述代码中，我们使用 std::lock_guard 来自动管理互斥量的所有权。当创建 std::lock_guard 对象时，它会自动获取互斥量的所有权，当 std::lock_guard 对象离开作用域时，它会自动释放互斥量的所有权。这样，我们就不需要手动调用 mtx.lock() 和 mtx.unlock()，可以避免因忘记释放互斥量而导致的死锁。

3. 条件变量（Condition Variable）

条件变量是一种同步机制，用于在多个线程之间同步条件的变化。在 C++ 中，可以使用 std::condition_variable 类来创建条件变量。

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

std::mutex mtx; // 全局互斥量
std::condition_variable cv; // 全局条件变量
bool ready = false; // 共享条件

void print_id(int id) {
    std::unique_lock<std::mutex> lock(mtx); // 创建锁，自动获取互斥量的所有权
    while (!ready) { // 如果条件不满足
        cv.wait(lock); // 等待条件变量的通知
    }
    // 当收到条件变量的通知，且条件满足时，继续执行
    std::cout << "thread " << id << '\n';
}

void go() {
    std::unique_lock<std::mutex> lock(mtx); // 创建锁，自动获取互斥量的所有权
    ready = true; // 修改共享条件
    cv.notify_all(); // 通知所有等待的线程
}

int main() {
    std::thread threads[10];
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(print_id, i);
    std::cout << "10 threads ready to race...\n";
    go(); // 开始比赛
    for (auto& th : threads)
        th.join();
    return 0;
}

在上述代码中，我们创建了一个全局互斥量 mtx、一个全局条件变量 cv 和一个共享条件 ready。然后，我们在 print_id 函数中使用 cv.wait(lock) 来等待条件变量的通知，当收到条件变量的通知，且条件满足时，继续执行。在 go 函数中，我们修改共享条件，并使用 cv.notify_all() 来通知所有等待的线程。

4. 原子操作（Atomic Operation）

原子操作是一种特殊的操作，它可以在多线程环境中安全地对数据进行读写，而无需使用互斥量或锁。在 C++ 中，可以使用 std::atomic 模板类来创建原子类型。

#include <thread>
#include <atomic>

std::atomic<int> shared_data(0); // 共享数据

void thread_func() {
    for (int i = 0; i < 10000; ++i) {
        ++shared_data; // 原子操作
    }
}

int main() {
    std::thread t1(thread_func);
    std::thread t2(thread_func);
    t1.join();
    t2.join();
    std::cout << shared_data << std::endl; // 输出 20000
    return 0;
}

在上述代码中，我们创建了一个原子类型的共享数据 shared_data。然后，我们在 thread_func 函数中使用 ++shared_data 来进行原子操作，这样，我们就不需要使用互斥量或锁，也可以保证在任何时候只有一个线程可以修改 shared_data。

5. 对比

案例举例

假设我们正在开发一个在线聊天服务器，需要处理大量的并发连接。每个连接都有一个关联的用户对象，用户对象包含了用户的状态信息，如用户名、在线状态等。

在这种情况下，我们可以使用多个互斥量的策略。我们可以将用户对象划分为几个组，每个组有一个关联的互斥量。当一个线程需要访问一个用户对象时，它只需要锁定该用户对象所在组的互斥量，而不是所有的用户对象。这样，不同的线程可以同时访问不同的用户对象，从而提高并发性。

同时，我们也可以使用读写锁的策略。因为在大多数情况下，线程只需要读取用户的状态信息，而不需要修改。所以，我们可以使用读写锁，允许多个线程同时读取用户对象，但在修改用户对象时需要独占锁。

在实践中，我们可能需要结合使用这两种策略，以达到最佳的效果。

6. 更进一步：原子操作 + 锁

原子操作和锁是两种不同的线程同步机制，它们可以单独使用，也可以一起使用，具体取决于你的应用场景。

原子操作是一种低级的同步机制，它可以保证对单个内存位置的读写操作是原子的，即在任何时候只有一个线程可以对内存位置进行操作。原子操作通常用于实现高级的同步机制，如锁和条件变量。

锁是一种高级的同步机制，它可以保证对一段代码或多个内存位置的访问是原子的，即在任何时候只有一个线程可以执行被锁保护的代码或访问被锁保护的内存位置。

如果你在使用锁的同时还使用原子操作，那么你需要确保你的代码正确地理解和使用这两种同步机制。例如，如果你在一个被锁保护的代码段中使用原子操作，那么你需要确保原子操作不会违反锁的语义，即在任何时候只有一个线程可以执行被锁保护的代码。

以下是一个使用原子操作和锁的例子：

#include <thread>
#include <mutex>
#include <atomic>

std::mutex mtx; // 全局互斥量
std::atomic<int> counter(0); // 原子计数器

void thread_func() {
    for (int i = 0; i < 10000; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // 获取互斥量的所有权
        ++counter; // 原子操作
        // 锁在离开作用域时自动释放互斥量的所有权
    }
}

int main() {
    std::thread t1(thread_func);
    std::thread t2(thread_func);
    t1.join();
    t2.join();
    std::cout << counter << std::endl; // 输出 20000
    return 0;
}

在上述代码中，我们使用 std::lock_guard 来获取互斥量的所有权，然后使用 ++counter 来进行原子操作。这样，我们既保证了在任何时候只有一个线程可以执行被锁保护的代码，也保证了对 counter 的操作是原子的。

总的来说，原子操作和锁可以一起使用，但你需要确保你的代码正确地理解和使用这两种同步机制。

总结

在 C++ 中，当两个或更多的线程需要访问共享数据时，可以使用互斥量、锁、条件变量和原子操作等多种线程同步和互斥的机制来保证线程安全。选择哪种机制，取决于具体的应用场景和需求。

参考资料

1. C++ Reference: thread
2. C++ Reference: mutex
3. C++ Reference: condition_variable
4. C++ Reference: atomic