Pengaturcaraan serentak C++: bagaimana untuk melakukan penyegerakan benang dan pengecualian bersama?

Penyegerakan utas adalah penting apabila beberapa utas mengakses sumber yang dikongsi secara serentak. C++ menyediakan mutex, pembolehubah keadaan dan operasi atom untuk mencapai penyegerakan. Mutexes memastikan bahawa hanya satu utas boleh mengakses sumber pada satu masa yang digunakan untuk komunikasi antara utas dan operasi atom memastikan bahawa satu operasi boleh dilaksanakan tanpa gangguan; Contohnya, gunakan mutexes untuk menyegerakkan akses kepada baris gilir yang dikongsi untuk mengelakkan rasuah data.

Pengaturcaraan Serentak C++: Penyegerakan Benang dan Pengecualian Bersama

Gambaran Keseluruhan

Penyegerakan benang ialah kunci untuk memastikan integriti data yang dikongsi pada masa yang sama dikekalkan apabila sumber berbilang rangkaian yang sama diakses. C++ menyediakan beberapa mekanisme untuk mencapai penyegerakan benang, termasuk mutex, pembolehubah keadaan dan operasi atom.

Mutex (Mutex)

Mutex ialah objek yang membenarkan hanya satu utas mengakses sumber yang dikongsi pada satu masa. Mutex digunakan seperti berikut:

std::mutex m;

void func() {
  std::lock_guard<std::mutex> lock(m);  // 获取互斥体锁
  // 访问共享资源
  // ...
}

std::lock_guard ialah jenis RAII yang mewakili kunci pada mutex. Apabila fungsi func() menyelesaikan pelaksanaan, kunci akan dilepaskan secara automatik. std::lock_guard是一种 RAII 类型，表示对互斥体的锁定。当func() 函数执行完时，锁将自动释放。

条件变量 (Condition Variable)

条件变量用于线程之间的通信。它允许一个线程等待，直到另一个线程满足某些条件。使用方法如下：

std::condition_variable cv;

void wait() {
  std::unique_lock<std::mutex> lock(m);
  cv.wait(lock);  // 等待条件变量
}

void notify() {
  std::unique_lock<std::mutex> lock(m);
  cv.notify_one();  // 通知等待的线程
}

std::unique_lock表示对互斥体的独占锁定。当wait()函数被调用时，线程将被阻塞，直到notify_one()

Pembolehubah Keadaan

Pembolehubah keadaan digunakan untuk komunikasi antara benang. Ia membenarkan satu utas menunggu sehingga satu utas lain memenuhi syarat tertentu. Penggunaannya adalah seperti berikut:

std::atomic<int> counter;

void increment() {
  counter++;  // 原子地递增计数器
}

std::unique_lock mewakili kunci eksklusif pada mutex. Apabila fungsi wait() dipanggil, urutan akan disekat sehingga fungsi notify_one() dipanggil.

Operasi atom

Operasi atom ialah mekanisme penyegerakan peringkat rendah yang memastikan satu operasi boleh dilaksanakan tanpa gangguan. Penggunaannya adalah seperti berikut: 🎜

std::mutex m;
std::queue<int> queue;
const int MAX_SIZE = 10;  // 队列最大容量

void producer() {
  while (true) {
    std::lock_guard<std::mutex> lock(m);
    if (queue.size() < MAX_SIZE) {
      queue.push(rand());
    }
  }
}

void consumer() {
  while (true) {
    std::lock_guard<std::mutex> lock(m);
    if (!queue.empty()) {
      std::cout << queue.front() << std::endl;
      queue.pop();
    }
  }
}

🎜🎜Kes praktikal🎜🎜🎜Pertimbangkan senario di mana berbilang urutan mengakses baris gilir dikongsi, dan saiz baris gilir adalah sempadan atas. Untuk menghalang urutan daripada mengakses baris gilir pada masa yang sama dan menyebabkan kerosakan data, kami boleh menggunakan mutex untuk menyegerakkan akses kepada baris gilir: 🎜rrreee

Atas ialah kandungan terperinci Pengaturcaraan serentak C++: bagaimana untuk melakukan penyegerakan benang dan pengecualian bersama?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!