为了在多线程环境中确保线程对共享资源的有序访问，c++++ 提供了以下线程同步机制：互斥锁（mutex）：提供对临界区的互斥访问，确保同一时间仅有一个线程访问。条件变量（condition variable）：与互斥锁配合使用，等待特定条件满足后继续执行。读写锁（reader-writer lock）：允许多个线程同时读取共享资源，但仅允许单个线程写入。信号量（semaphore）：控制对有限资源的访问，提供等待资源可用并释放资源的功能。实战案例中，我们可以使用互斥锁来保护线程安全队列的访问，确保 push 和 pop 操作的线程安全性。

C++ 线程同步机制的比较和对比

在多线程环境中，线程同步机制至关重要，它确保了线程之间的有序访问共享资源，防止数据竞争和死锁。C++ 语言提供了多种用于同步线程的机制，每种机制都有其独特的优点和缺点。本文将比较和对比 C++ 中最常用的线程同步机制，并提供实战案例。

互斥锁（Mutex）

互斥锁是最基本的线程同步机制，它通过对临界区的访问提供互斥，确保任何时刻只有一个线程可以访问临界区。互斥锁可以通过 std::mutex 类创建。

// 创建互斥锁
std::mutex m;

// 加锁
m.lock();

// 访问临界区
// ...

// 解锁
m.unlock();

条件变量（Condition Variable）

条件变量用于等待特定条件满足后才继续执行。它通常与互斥锁配合使用，以保证条件检查和状态更新的原子性。

// 创建条件变量
std::condition_variable cv;

// 获取锁
std::mutex m;
m.lock();

// 等待条件满足
while (!condition) {
  cv.wait(m);
}

// 更新状态
// ... 

// 解锁
m.unlock();

读写锁（Reader-Writer Lock）

读写锁允许多个线程同时读取共享资源，但只有单个线程可以写入共享资源。这提高了读取操作的性能，同时保证了写入操作的排他性。C++ 中可以使用 std::shared_mutex 类创建读写锁。

// 创建读写锁
std::shared_mutex rw;

// 获取读锁
rw.lock_shared();

// 读取共享资源
// ...

// 解锁读锁
rw.unlock_shared();

// 获取写锁
rw.lock();

// 写入共享资源
// ...

// 解锁写锁
rw.unlock();

信号量（Semaphore）

信号量是一个同步原语，用于控制对有限资源的访问。它提供了等待资源可用并释放资源的功能。

// 创建信号量，初始值为 3
std::counting_semaphore<3> sem(3);

// 等待资源可用
sem.acquire();

// 使用资源
// ...

// 释放资源
sem.release();

实战案例

线程安全队列

假设我们有一个用于管理任务的线程安全队列。队列的 push 和 pop 操作必须是线程安全的，以防止数据竞争。

我们可以使用互斥锁来保护队列的访问，如下所示：

// 线程安全队列类
struct Queue {
  std::mutex m;
  std::queue<int> q;
  
  void push(int value) {
    std::lock_guard<std::mutex> lock(m); // 自动获取和释放锁
    q.push(value);
  }
  
  int pop() {
    std::lock_guard<std::mutex> lock(m);
    if (q.empty()) {
      throw std::runtime_error("队列为空");
    }
    int value = q.front();
    q.pop();
    return value;
  }
};

通过使用互斥锁，我们确保了任何时刻只有一个线程可以访问队列，从而保证了线程安全性。