Bagaimanakah fungsi C++ menguruskan keadaan dalam pengaturcaraan serentak?

Teknik biasa untuk mengurus keadaan fungsi dalam pengaturcaraan serentak C++ termasuk: Storan setempat-benang (TLS) membolehkan setiap utas mengekalkan salinan pembolehubah bebasnya sendiri. Pembolehubah atom membenarkan pembacaan dan penulisan atom pembolehubah yang dikongsi dalam persekitaran berbilang benang. Mutexes memastikan ketekalan keadaan dengan menghalang berbilang benang daripada melaksanakan bahagian kritikal pada masa yang sama.

Fungsi C++ melaksanakan pengurusan keadaan dalam pengaturcaraan serentak

Dalam pengaturcaraan berbilang benang, fungsi serentak selalunya perlu mengurus keadaannya sendiri. Untuk memastikan ketekalan dan ketepatan data, pengurusan negeri adalah penting. Artikel ini meneroka teknik biasa untuk mengurus keadaan fungsi dalam pengaturcaraan serentak C++.

Thread Local Storage (TLS)

TLS membenarkan setiap thread mempunyai salinan bebas pembolehubahnya sendiri. Ini berguna untuk fungsi yang perlu mengekalkan keadaan khusus untuk setiap utas. Berikut ialah contoh menggunakan TLS:

#include <thread>

// 定义线程局部变量
thread_local int thread_counter;

// 并发函数
void increment_counter() {
  ++thread_counter;
  std::cout << "Current counter: " << thread_counter << std::endl;
}

int main() {
  // 创建多个线程并执行并发函数
  std::vector<std::thread> threads;
  for (int i = 0; i < 10; ++i) {
    threads.emplace_back(increment_counter);
  }

  // 等待所有线程完成
  for (auto& thread : threads) {
    thread.join();
  }

  return 0;
}

Pembolehubah Atom

Pembolehubah atom membenarkan pembacaan dan penulisan atom pembolehubah dikongsi dalam persekitaran berbilang benang. Ini menghalang keadaan kaum dan rasuah data negeri. Begini cara menggunakan pembolehubah atom std::atomic:

#include <atomic>

// 定义原子变量
std::atomic<int> counter;

// 并发函数
void increment_counter() {
  ++counter;
  std::cout << "Current counter: " << counter << std::endl;
}

int main() {
  // 创建多个线程并执行并发函数
  std::vector<std::thread> threads;
  for (int i = 0; i < 10; ++i) {
    threads.emplace_back(increment_counter);
  }

  // 等待所有线程完成
  for (auto& thread : threads) {
    thread.join();
  }

  return 0;
}

Mutex

Mutex digunakan untuk mengawal akses kepada sumber yang dikongsi. Mereka memastikan ketekalan keadaan dengan menghalang berbilang utas daripada melaksanakan bahagian kritikal secara serentak. Begini cara menggunakan std::mutex mutex:

#include <mutex>

// 定义互斥锁
std::mutex counter_lock;

// 并发函数
void increment_counter() {
  // 获得锁
  std::lock_guard<std::mutex> lock(counter_lock);

  // 读写共享状态
  ++counter;
  std::cout << "Current counter: " << counter << std::endl;
}

int main() {
  // 创建多个线程并执行并发函数
  std::vector<std::thread> threads;
  for (int i = 0; i < 10; ++i) {
    threads.emplace_back(increment_counter);
  }

  // 等待所有线程完成
  for (auto& thread : threads) {
    thread.join();
  }

  return 0;
}

Atas ialah kandungan terperinci Bagaimanakah fungsi C++ menguruskan keadaan dalam pengaturcaraan serentak?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!