Programmation simultanée C++ : comment utiliser un processeur multicœur pour obtenir la concurrence ?

La programmation simultanée C++ tire pleinement parti des processeurs multicœurs en créant des threads, des mutex et des variables de condition. La création de threads permet d'exécuter des tâches en parallèle. Un mutex agit comme un verrou pour garantir que les données partagées ne sont pas accessibles simultanément par plusieurs threads, évitant ainsi la corruption des données. Les variables de condition sont utilisées pour informer un thread qu'une condition spécifique a été remplie et sont utilisées avec des verrous mutex pour empêcher un thread de continuer à s'exécuter jusqu'à ce que la condition soit remplie.

Programmation simultanée en C++ : débloquer des processeurs multicœurs

Préface

Les processeurs modernes ont souvent plusieurs cœurs, et en utilisant pleinement ces cœurs, nous pouvons améliorer considérablement l'efficacité du code lors de l'exécution de tâches en parallèle. C++ fournit une variété d'outils de programmation simultanée qui permettent aux programmeurs de créer facilement des applications capables d'effectuer plusieurs tâches simultanément.

Créer des fils de discussion

Créer des fils de discussion sont les éléments de base pour représenter la concurrence. En C++, vous pouvez créer de nouveaux threads à l'aide de la classe std::thread. Il accepte comme argument un objet appelable qui spécifie la tâche à effectuer dans un thread séparé. std::thread 类创建新线程。它接受一个可调用对象作为参数，该对象指定在单独的线程中执行的任务。

#include <iostream>
#include <thread>

void hello_world() {
  std::cout << "Hello, world!" << std::endl;
}

int main() {
  std::thread thread1(hello_world);
  thread1.join();

  return 0;
}

在上面的代码中，hello_world() 函数是一个可调用对象，它只需向控制台打印一条消息。std::thread 构造函数创建一个新线程并执行可调用对象。thread1.join() 阻塞主线程，直到新线程完成。

互斥锁

线程并发访问共享数据时，互斥锁非常重要。它们充当锁，防止多个线程同时访问关键部分，从而避免数据损坏。在 C++ 中，可以使用 std::mutex 类创建互斥锁。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex m;  // 全局互斥锁

void increment(int& counter) {
  std::lock_guard<std::mutex> lock(m);  // 获取互斥锁
  ++counter;
}

int main() {
  int counter = 0;

  std::thread thread1(increment, std::ref(counter));
  std::thread thread2(increment, std::ref(counter));

  thread1.join();
  thread2.join();

  std::cout << "Final counter value: " << counter << std::endl;

  return 0;
}

在这个示例中，increment() 函数对共享变量 counter 进行递增。我们使用 std::lock_guard 来获取互斥锁，确保只有一个线程可以同时执行关键部分。这种机制确保两个线程不会同时递增 counter，从而避免数据竞争。

条件变量

条件变量用于通知线程特定条件已满足。它们与互斥锁一起使用，以确保线程在满足条件之前不会继续执行。在 C++ 中，可以使用 std::condition_variable 类创建条件变量。

#include <iostream>
#include <thread>
#include <condition_variable>
#include <mutex>

std::mutex m;  // 全局互斥锁
std::condition_variable cv;  // 全局条件变量
bool ready = false;  // 共享布尔标志

void producer() {
  std::lock_guard<std::mutex> lock(m);  // 获取互斥锁
  ready = true;                       // 设置共享标志为 true
  cv.notify_one();                   // 通知一个等待的线程
}

void consumer() {
  std::unique_lock<std::mutex> lock(m);  // 获取互斥锁（并锁定它）
  while (!ready)                        // 等待共享标志为 true
    cv.wait(lock);                     // 释放互斥锁并等待
}

int main() {
  std::thread producer_thread(producer);
  std::thread consumer_thread(consumer);

  producer_thread.join();
  consumer_thread.join();

  return 0;
}

在此示例中，我们使用条件变量来协调生产者和消费者线程之间的交互。producer() 函数设置共享标志 ready 为 true 并通知消费者线程。consumer()rrreee

Dans le code ci-dessus, la fonction hello_world() est un objet appelable qui imprime simplement un message sur la console. Le constructeur std::thread crée un nouveau thread et exécute l'objet appelable. thread1.join() bloque le thread principal jusqu'à ce que le nouveau thread soit terminé. 🎜🎜🎜Verrouillage Mutex🎜🎜🎜Le verrouillage Mutex est très important lorsque les threads accèdent simultanément aux données partagées. Ils agissent comme des verrous pour empêcher plusieurs threads d'accéder simultanément aux sections critiques, évitant ainsi la corruption des données. En C++, vous pouvez créer un verrou mutex à l'aide de la classe std::mutex. 🎜rrreee🎜Dans cet exemple, la fonction increment() incrémente la variable partagée counter. Nous utilisons std::lock_guard pour obtenir un verrou mutex, garantissant qu'un seul thread peut exécuter la section critique en même temps. Ce mécanisme garantit que deux threads n'incrémentent pas counter en même temps, évitant ainsi les courses de données. 🎜🎜🎜Variables conditionnelles🎜🎜🎜Les variables conditionnelles sont utilisées pour informer les threads qu'une condition spécifique a été remplie. Ils sont utilisés avec des verrous mutex pour garantir que les threads ne poursuivent pas leur exécution tant qu'une condition n'est pas remplie. En C++, les variables de condition peuvent être créées à l'aide de la classe std::condition_variable. 🎜rrreee🎜Dans cet exemple, nous utilisons des variables de condition pour coordonner l'interaction entre les threads producteur et consommateur. La fonction producter() définit l'indicateur partagé ready sur true et informe le thread consommateur. La fonction consumer() attend que l'indicateur partagé soit vrai en attendant une variable de condition avant de poursuivre l'exécution. 🎜

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!