Bandingkan dan Bezakan Mekanisme Penyegerakan Benang C++ dalam Seni Bina Pelayan

Untuk memastikan capaian teratur bagi benang kepada sumber yang dikongsi dalam persekitaran berbilang benang, C++ menyediakan mekanisme penyegerakan benang berikut: Mutex (Mutex): Menyediakan akses yang saling eksklusif kepada bahagian kritikal untuk memastikan hanya satu utas mengakses pada masa yang sama . Pembolehubah keadaan (Pembolehubah Keadaan): Digunakan bersama dengan kunci mutex untuk meneruskan pelaksanaan selepas menunggu syarat tertentu dipenuhi. Kunci Pembaca-Penulis: Membenarkan berbilang utas membaca sumber yang dikongsi pada masa yang sama, tetapi hanya membenarkan satu utas untuk menulis. Semaphore: Mengawal akses kepada sumber terhad dan menyediakan fungsi menunggu sumber tersedia dan melepaskannya. Dalam kes praktikal, kami boleh menggunakan kunci mutex untuk melindungi akses kepada baris gilir selamat benang dan memastikan keselamatan benang bagi operasi tolak dan pop. . Bahasa C++ menyediakan beberapa mekanisme untuk menyegerakkan benang, masing-masing mempunyai kelebihan dan keburukan tersendiri. Artikel ini akan membandingkan dan membezakan mekanisme penyegerakan benang yang paling biasa digunakan dalam C++ dan memberikan contoh praktikal.

Mutex (Mutex)

Mutex ialah mekanisme penyegerakan utas paling asas Ia menyediakan pengecualian bersama melalui akses kepada bahagian kritikal, memastikan hanya satu utas boleh mengakses bahagian kritikal pada bila-bila masa. Kunci Mutex boleh dibuat melalui kelas std::mutex.

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

// 加锁
m.lock();

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

// 解锁
m.unlock();

Condition Variable

Condition variable digunakan untuk menunggu syarat tertentu dipenuhi sebelum meneruskan pelaksanaan. Ia sering digunakan bersama dengan kunci mutex untuk menjamin keatomisan semakan keadaan dan kemas kini keadaan.

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

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

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

// 更新状态
// ... 

// 解锁
m.unlock();

Kunci Penulis-Pembacastd::mutex 类创建。

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

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

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

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

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

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

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

条件变量（Condition Variable）

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

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

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

// 使用资源
// ...

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

读写锁（Reader-Writer Lock）

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

// 线程安全队列类
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;
  }
};

信号量（Semaphore）

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

实战案例

线程安全队列

假设我们有一个用于管理任务的线程安全队列。队列的 push 和 pop

Kunci Penulis-Baca membenarkan berbilang urutan membaca sumber yang dikongsi pada masa yang sama, tetapi hanya satu utas boleh menulis kepada sumber yang dikongsi. Ini meningkatkan prestasi operasi baca sambil memastikan eksklusiviti operasi tulis. Dalam C++, anda boleh menggunakan kelas std::shared_mutex untuk mencipta kunci baca-tulis.

Atas ialah kandungan terperinci Bandingkan dan Bezakan Mekanisme Penyegerakan Benang C++ dalam Seni Bina Pelayan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!