C++中线程同步与互斥的四种方式介绍及对比详解

引言

在C++中，当两个或更多的线程需要访问共享数据时，就会出现线程安全问题。这是因为，如果没有适当的同步机制，一个线程可能在另一个线程还没有完成对数据的修改就开始访问数据，这将导致数据的不一致性和程序的不可预测性。为了解决这个问题，C++提供了多种线程同步和互斥的机制。

1. 互斥量（Mutex）

互斥量是一种同步机制，用于防止多个线程同时访问共享资源。在C++中，可以使用std::mutex类来创建互斥量。

#include <thread>
#include <mutex>

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

void thread_func() {
     for (int i = 0; i < 10000; ++i) {
         mtx.lock(); // 获取互斥量的所有权
         ++shared_data; // 修改共享数据
         mtx.unlock(); // 释放互斥量的所有权
     }
}

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;
}

在上述代码中，我们创建了一个全局互斥量mtx和一个共享数据shared_data。然后，我们在thread_func函数中使用mtx.lock()和mtx.unlock()来保护对shared_data的访问，确保在任何时候只有一个线程可以修改shared_data。

1. 锁（Lock）

除了直接使用互斥量，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()，可以避免因忘记释放互斥量而导致的死锁。

1. 条件变量（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()来通知所有等待的线程。

1. 原子操作（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。

1. 对比
   
   策略 优点 缺点
   
   单一全局互斥量 简单 可能导致严重的性能问题，降低并发性
   
   多个互斥量 提高并发性 增加程序复杂性，需要避免死锁
   
   原子操作 提高并发性，避免互斥量开销 增加程序复杂性，需要理解和使用原子操作
   
   读写锁 提高并发性，特别是读操作多于写操作时 增加程序复杂性，需要管理读写锁，需要避免死锁

案例举例

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

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

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

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

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

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

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

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

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

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

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