Programmation simultanée C++ : comment gérer la communication inter-thread ?

Les méthodes de communication inter-thread en C++ incluent : la mémoire partagée, les mécanismes de synchronisation (verrous mutex, variables de condition), les canaux et les files d'attente de messages. Par exemple, utilisez un verrou mutex pour protéger un compteur partagé : déclarez un verrou mutex (m) et une variable partagée (counter) ; chaque thread met à jour le compteur en verrouillant (lock_guard) ; pour éviter les conditions de course.

Programmation simultanée C++ : Comment gérer la communication inter-thread ?

Dans une application multithread, les threads doivent pouvoir communiquer entre eux pour coordonner les tâches et partager des données. C++ fournit une variété de mécanismes pour implémenter la communication entre les threads, notamment :

Mémoire partagée

En utilisant la mémoire partagée, plusieurs threads peuvent accéder à la même zone mémoire. Il s’agit d’une approche peu coûteuse, mais il faut veiller à éviter les conditions de concurrence.

int shared_data = 0;

void thread_1() {
  shared_data++; // 可能会被其他线程同时访问
}

void thread_2() {
  shared_data++; // 可能会同时导致不正确的结果
}

Mécanisme de synchronisation

Le mécanisme de synchronisation peut être utilisé pour coordonner les threads lors de l'accès aux ressources partagées.

Mutex (Mutex)

Mutex fournit un accès mutuellement exclusif, garantissant qu'un seul thread peut accéder aux ressources partagées à la fois.

std::mutex m;

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

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

Variable de condition

Les variables de condition permettent aux threads d'attendre que des conditions spécifiques soient remplies.

std::condition_variable cv;
std::mutex m;

void producer() {
  std::lock_guard<std::mutex> l(m); // 获取互斥锁
  while (!condition) {
    // 等待条件满足
    cv.wait(l);
  }
  // 生产数据
}

void consumer() {
  std::lock_guard<std::mutex> l(m); // 获取互斥锁
  condition = true;
  cv.notify_all(); // 唤醒所有等待线程
}

Pipe

Pipe est un mécanisme de communication unidirectionnel utilisé pour transférer des données entre deux threads.

std::pipe pipe;

void writer() {
  std::string message = "hello";
  std::write(pipe[1], message.c_str(), message.length());
}

void reader() {
  std::string message;
  std::read(pipe[0], message.data(), message.size());
}

Message Queue

Message Queue fournit un mécanisme de livraison de messages asynchrone.

key_t key = ftok("message_queue", 'a');

int message_queue = msgget(key, IPC_CREAT | 0666);

void sender() {
  Message msg;
  msg.mtext = "hello";
  msgsnd(message_queue, &msg, sizeof(msg.mtext), IPC_NOWAIT);
}

void receiver() {
  Message msg;
  msgrcv(message_queue, &msg, sizeof(msg.mtext), 0, 0);
}

Cas pratique : Utiliser un mutex pour protéger un compteur partagé

Supposons que nous ayons un compteur partagé qui doit être mis à jour simultanément par plusieurs threads. Nous pouvons protéger ce compteur à l'aide d'un mutex :

std::mutex m;
int counter = 0;

void thread_1() {
  for (int i = 0; i < 1000000; i++) {
    std::lock_guard<std::mutex> l(m);
    counter++;
  }
}

void thread_2() {
  for (int i = 0; i < 1000000; i++) {
    std::lock_guard<std::mutex> l(m);
    counter--;
  }
}

Cela garantit qu'un seul thread peut mettre à jour le compteur à un moment donné, évitant ainsi les conditions de concurrence.

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!