Mekanisme penguncian dan penyegerakan fungsi C++ dalam pengaturcaraan serentak?

Mekanisme kunci fungsi dan penyegerakan dalam pengaturcaraan serentak C++ digunakan untuk mengurus akses serentak kepada data dalam persekitaran berbilang benang dan menghalang persaingan data. Mekanisme utama termasuk: Mutex (Mutex): primitif penyegerakan peringkat rendah yang memastikan bahawa hanya satu utas mengakses bahagian kritikal pada satu masa. Pembolehubah Keadaan: Membenarkan benang menunggu syarat dipenuhi dan menyediakan komunikasi antara benang. Operasi atom: Operasi arahan tunggal, memastikan kemas kini satu-benang pembolehubah atau data untuk mengelakkan konflik.

Kunci fungsi dan mekanisme penyegerakan dalam pengaturcaraan serentak C++

Apabila melaksanakan pengaturcaraan serentak dalam persekitaran berbilang benang, mengurus akses serentak kepada data adalah penting. C++ menyediakan beberapa mekanisme untuk melaksanakan penguncian dan penyegerakan fungsi, yang membantu menghalang perlumbaan data dan isu keselamatan benang yang lain.

Mutex (Mutex)

Mutex ialah primitif penyegerakan peringkat rendah yang membenarkan hanya satu urutan mengakses bahagian kritikal (data atau sumber yang dikongsi) pada satu masa. Sebelum memasuki bahagian kritikal, benang mesti memperoleh mutex dan melepaskannya selepas keluar dari bahagian kritikal.

std::mutex mu;
void critical_section() {
  // 获得互斥量
  std::lock_guard<std::mutex> lock(mu);

  // 临界区代码...

  // 释放互斥量（自动释放）
}

Pembolehubah Keadaan

Pembolehubah keadaan membolehkan benang menunggu untuk syarat tertentu dipenuhi. Benang boleh menunggu pada pembolehubah keadaan sehingga benang lain menghantar isyarat.

std::condition_variable cv;
std::mutex mu;

void waiting_thread() {
  // 获得互斥量
  std::unique_lock<std::mutex> lock(mu);

  // 在条件变量上等待
  cv.wait(lock);

  // 条件满足（可选），进行后续操作...

  // 释放互斥量
}

void signalling_thread() {
  // 获得互斥量
  std::lock_guard<std::mutex> lock(mu);

  // 条件得到满足，发送信号
  cv.notify_one();

  // 释放互斥量（自动释放）
}

Operasi atom

Operasi atom ialah arahan tunggal yang tidak boleh diganggu oleh benang lain semasa pelaksanaan. Ini boleh digunakan untuk memastikan kemas kini satu benang pembolehubah atau data.

std::atomic_flag busy_flag = ATOMIC_FLAG_INIT;

void set_busy_flag() {
  // 原子方式地设置 busy_flag
  busy_flag.test_and_set(std::memory_order_release);
}

bool is_busy() {
  // 原子方式地获取 busy_flag 的值
  return busy_flag.test(std::memory_order_acquire);
}

Kes Praktikal

Pertimbangkan aplikasi berbilang benang di mana urutan perlu mengakses pembolehubah kaunter kongsi. Untuk mengelakkan perlumbaan data, kami menggunakan mutex untuk menyegerakkan akses kepada kaunter.

std::mutex mu;
int counter = 0;

void increment_counter() {
  // 获得互斥量
  std::lock_guard<std::mutex> lock(mu);

  // 增加计数器
  ++counter;
}

Dengan menggunakan mekanisme penyegerakan ini, kami boleh memastikan akses dan perkongsian data yang selamat dan cekap dalam persekitaran berbilang benang.

Atas ialah kandungan terperinci Mekanisme penguncian dan penyegerakan fungsi C++ dalam pengaturcaraan serentak?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!