Comment la fonction C++ gère-t-elle l'état en programmation simultanée ?

Les techniques courantes de gestion de l'état des fonctions dans la programmation simultanée C++ incluent : Le stockage local des threads (TLS) permet à chaque thread de conserver sa propre copie indépendante des variables. Les variables atomiques permettent la lecture et l'écriture atomiques de variables partagées dans un environnement multithread. Les mutex garantissent la cohérence de l'état en empêchant plusieurs threads d'exécuter des sections critiques en même temps.

Les fonctions C++ effectuent la gestion de l'état dans la programmation simultanée

Dans la programmation multithread, les fonctions concurrentes doivent souvent gérer leur propre état. Pour garantir la cohérence et l’exactitude des données, la gestion de l’état est cruciale. Cet article explore les techniques courantes de gestion de l’état des fonctions dans la programmation simultanée C++.

Thread Local Storage (TLS)

TLS permet à chaque thread d'avoir sa propre copie indépendante des variables. Ceci est utile pour les fonctions qui doivent conserver un état spécifique pour chaque thread. Voici un exemple utilisant 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;
}

Variables atomiques

Les variables atomiques permettent la lecture et l'écriture atomiques de variables partagées dans un environnement multithread. Cela évite les conditions de concurrence et la corruption des données de l’État. Voici comment utiliser les variables atomiques std::atomicbd43222e33876353aff11e13a7dc75f6 :

#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 est utilisé pour contrôler l'accès aux ressources partagées. Ils garantissent la cohérence des états en empêchant plusieurs threads d’exécuter simultanément des sections critiques. Voici comment utiliser un mutex std::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;
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!