Programmation simultanée C++ : comment effectuer la synchronisation des threads et l'exclusion mutuelle ?

La synchronisation des threads est cruciale lorsque plusieurs threads accèdent simultanément aux ressources partagées. C++ fournit des mutex, des variables de condition et des opérations atomiques pour réaliser la synchronisation. Les mutex garantissent qu'un seul thread peut accéder à une ressource à la fois ; les variables de condition sont utilisées pour la communication entre les threads et les opérations atomiques garantissent qu'une seule opération peut être exécutée sans interruption. Par exemple, utilisez des mutex pour synchroniser l'accès aux files d'attente partagées afin d'éviter la corruption des données.

Programmation simultanée C++ : synchronisation des threads et exclusion mutuelle

Vue d'ensemble

La synchronisation des threads est la clé pour garantir le maintien de l'intégrité des données lorsque plusieurs threads accèdent à des ressources partagées en même temps. C++ fournit une variété de mécanismes pour réaliser la synchronisation des threads, notamment des mutex, des variables de condition et des opérations atomiques.

Mutex (Mutex)

Un mutex est un objet qui permet à un seul thread d'accéder à une ressource partagée à la fois. Le mutex est utilisé comme suit :

std::mutex m;

void func() {
  std::lock_guard<std::mutex> lock(m);  // 获取互斥体锁
  // 访问共享资源
  // ...
}

std::lock_guard est un type RAII qui représente le verrou sur le mutex. Lorsque la fonction func() termine son exécution, le verrou sera automatiquement libéré. std::lock_guard是一种 RAII 类型，表示对互斥体的锁定。当func() 函数执行完时，锁将自动释放。

条件变量 (Condition Variable)

条件变量用于线程之间的通信。它允许一个线程等待，直到另一个线程满足某些条件。使用方法如下：

std::condition_variable cv;

void wait() {
  std::unique_lock<std::mutex> lock(m);
  cv.wait(lock);  // 等待条件变量
}

void notify() {
  std::unique_lock<std::mutex> lock(m);
  cv.notify_one();  // 通知等待的线程
}

std::unique_lock表示对互斥体的独占锁定。当wait()函数被调用时，线程将被阻塞，直到notify_one()

Variable de condition

Les variables de condition sont utilisées pour la communication entre les threads. Il permet à un thread d'attendre qu'un autre thread remplisse certaines conditions. L'utilisation est la suivante :

std::atomic<int> counter;

void increment() {
  counter++;  // 原子地递增计数器
}

std::unique_lock représente un verrou exclusif sur le mutex. Lorsque la fonction wait() est appelée, le thread sera bloqué jusqu'à ce que la fonction notify_one() soit appelée.

Opérations atomiques

Les opérations atomiques sont un mécanisme de synchronisation de bas niveau qui garantit qu'une seule opération peut être exécutée sans interruption. L'utilisation est la suivante : 🎜

std::mutex m;
std::queue<int> queue;
const int MAX_SIZE = 10;  // 队列最大容量

void producer() {
  while (true) {
    std::lock_guard<std::mutex> lock(m);
    if (queue.size() < MAX_SIZE) {
      queue.push(rand());
    }
  }
}

void consumer() {
  while (true) {
    std::lock_guard<std::mutex> lock(m);
    if (!queue.empty()) {
      std::cout << queue.front() << std::endl;
      queue.pop();
    }
  }
}

🎜🎜Cas pratique🎜🎜🎜Considérons un scénario dans lequel plusieurs threads accèdent à une file d'attente partagée et la taille de la file d'attente est limite supérieure. Pour empêcher les threads d'accéder à la file d'attente en même temps et de provoquer une corruption des données, nous pouvons utiliser un mutex pour synchroniser l'accès à la file d'attente : 🎜rrreee

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!