Programmation simultanée C++ : Comment gérer l'allocation des ressources dans les threads parallèles ?

Dans les programmes multithread, C++ utilise des verrous mutex et des types atomiques pour garantir un accès correct des threads aux ressources partagées. Verrouillage mutex : La classe std::mutex crée un verrou mutex, permettant à un seul thread d'accéder aux ressources partagées à la fois, empêchant ainsi les courses de données. Type atomique : std::atomic fournit des opérations atomiques pour empêcher plusieurs threads de modifier la même variable en même temps, garantissant ainsi la sécurité des threads.

Programmation simultanée C++ : gestion de l'allocation des ressources dans des threads parallèles

Dans la programmation multithread, la gestion de l'allocation des ressources est cruciale pour éviter les courses de données et garantir l'exactitude du programme. C++ fournit plusieurs mécanismes de synchronisation pour implémenter l'allocation de ressources, notamment les verrous mutex et les types atomiques.

1. Verrouillage mutex

Un verrouillage mutex est un mécanisme de synchronisation qui permet à un seul thread d'accéder aux ressources partagées à la fois. En C++, vous pouvez utiliser la classe std::mutex pour créer un verrou mutex. std::mutex类来创建互斥锁。

代码范例：

std::mutex mtx;

void thread_function() {
  std::lock_guard<std::mutex> guard(mtx);
  // 对共享资源进行操作
}

在这个示例中，std::lock_guard是一个RAII（资源获取即初始化）包装器，它在函数作用域的生存期内锁定互斥锁。

2. 原子类型

原子类型是线程安全的内置类型，可以执行原子操作。它们防止多个线程同时修改同一个变量，从而避免数据竞争。C++标准库提供了一些原子类型，如std::atomic<T>

Exemple de code :

std::atomic<int> counter;

void thread_function() {
  counter++; // 执行原子增量操作
}

Dans cet exemple, std::lock_guard est un wrapper RAII (Resource Acquisition, c'est-à-dire Initialisation) qui verrouille le mutex pendant la durée de vie du verrouillage de la portée de la fonction.

2. Types atomiques

Les types atomiques sont des types intégrés thread-safe qui peuvent effectuer des opérations atomiques. Ils empêchent plusieurs threads de modifier la même variable en même temps, évitant ainsi les courses aux données. La bibliothèque standard C++ fournit certains types atomiques, tels que std::atomic<T>.

Exemple de code :

std::mutex mtx;
std::queue<int> queue;

void producer_thread() {
  while (true) {
    std::lock_guard<std::mutex> guard(mtx);
    queue.push(rand());
  }
}

void consumer_thread() {
  while (true) {
    std::lock_guard<std::mutex> guard(mtx);
    if (!queue.empty()) {
      std::cout << queue.front() << std::endl;
      queue.pop();
    }
  }
}

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

🎜Cas pratique🎜🎜🎜Considérons un problème producteur-consommateur dans lequel le thread producteur génère des données et le thread consommateur consomme des données. La ressource est une file d'attente partagée qui doit être protégée par un mutex pour éviter les courses de données. 🎜🎜🎜Exemple de code : 🎜🎜rrreee🎜Dans cet exemple, un mutex est utilisé pour protéger une file d'attente partagée afin d'empêcher les threads producteur et consommateur d'accéder à la file d'attente en même temps. 🎜

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!