Bagaimana untuk menguruskan sumber yang dikongsi dengan cekap dalam pengaturcaraan berbilang benang C++?

Dalam pengaturcaraan berbilang benang C++, pembolehubah mutex dan keadaan boleh digunakan untuk mengurus sumber dikongsi dengan cekap dan mengelakkan persaingan data dan kebuntuan: Mutex (Mutex) membenarkan hanya satu utas untuk mengakses sumber pada satu masa, memastikan integriti data. Pembolehubah keadaan (Pembolehubah Keadaan) digunakan untuk menyelaraskan kerjasama utas, membenarkan satu utas menunggu untuk utas lain melakukan tindakan tertentu. Dalam kes sebenar, utas pengeluar menambah data pada penimbal dan memberitahu pengguna Urutan pengguna menunggu pemberitahuan pengeluar dan kemudian membaca data daripada penampan Mutex dan pembolehubah keadaan memastikan akses selamat kepada sumber yang dikongsi.

C++ Multi-threaded Programming: Cekap mengurus sumber kongsi

Dalam pengaturcaraan berbilang thread, kawalan akses sumber dikongsi adalah penting. Artikel ini akan menerangkan cara menggunakan primitif penyegerakan seperti mutex dan pembolehubah keadaan dalam C++ untuk mengurus sumber dikongsi dengan cekap dan mengelakkan perlumbaan data dan kebuntuan.

Mutex (Mutex)

Mutex ialah mekanisme utama untuk melindungi sumber kongsi daripada akses serentak. Ia membenarkan hanya satu utas untuk mengakses sumber pada satu masa, sekali gus memastikan integriti data.

std::mutex m;  // 创建一个互斥量

void access_resource() {
  std::lock_guard<std::mutex> lock(m);  // 加锁
  // 对共享资源执行操作
  lock.unlock();  // 解锁
}

Pembolehubah Keadaan

Pembolehubah keadaan digunakan untuk menyelaraskan kerjasama benang. Ia membenarkan satu utas menunggu untuk satu lagi utas untuk melakukan tindakan tertentu.

std::condition_variable cv;  // 创建一个条件变量
std::mutex m;  // 创建一个与条件变量关联的互斥量

void produce() {
  std::unique_lock<std::mutex> lock(m);
  // 生产数据
  lock.unlock();
  cv.notify_one();  // 通知消费者生产完成
}

void consume() {
  std::unique_lock<std::mutex> lock(m);
  // 等待生产者通知
  cv.wait(lock);
  // 消费数据
  lock.unlock();
}

Kes praktikal

Berikut ialah contoh mudah menggunakan pembolehubah mutex dan keadaan untuk mengurus sumber yang dikongsi. Ia menggunakan penimbal untuk menyimpan data, utas pengeluar menambah data pada penimbal, dan utas pengguna membaca data daripada penimbal.

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

std::mutex m;
std::condition_variable cv;

std::vector<int> buffer;  // 共享资源缓冲区

void produce() {
  while (true) {
    std::lock_guard<std::mutex> lock(m);
    buffer.push_back(rand());
    cv.notify_one();
  }
}

void consume() {
  while (true) {
    std::unique_lock<std::mutex> lock(m);
    cv.wait(lock, [] { return !buffer.empty(); });
    int data = buffer.back();
    buffer.pop_back();
  }
}

int main() {
  std::thread t1(produce);
  std::thread t2(consume);
  t1.join();
  t2.join();
  return 0;
}

Dengan menggunakan pembolehubah mutex dan keadaan, kami memastikan bahawa rangkaian pengeluar dan pengguna boleh mengakses penimbal pada masa yang sama, tetapi tidak akan ada perlumbaan data.

Atas ialah kandungan terperinci Bagaimana untuk menguruskan sumber yang dikongsi dengan cekap dalam pengaturcaraan berbilang benang C++?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!