Comment gérer efficacement les ressources partagées dans la programmation multithread C++ ?

Dans la programmation multithread C++, les variables mutex et de condition peuvent être utilisées pour gérer efficacement les ressources partagées et éviter la concurrence et les blocages de données : Mutex (Mutex) permet à un seul thread d'accéder aux ressources à la fois, garantissant ainsi l'intégrité des données. Les variables de condition (Condition Variable) sont utilisées pour coordonner la coopération des threads, permettant à un thread d'attendre qu'un autre thread effectue une action spécifique. Dans le cas réel, le thread producteur ajoute des données au tampon et informe le consommateur. Le thread consommateur attend la notification du producteur, puis lit les données du tampon. Les mutex et les variables de condition garantissent un accès sécurisé aux ressources partagées.

Programmation multithread C++ : Gérer efficacement les ressources partagées

Dans la programmation multithread, le contrôle d'accès aux ressources partagées est crucial. Cet article explique comment utiliser les primitives de synchronisation telles que les mutex et les variables de condition en C++ pour gérer efficacement les ressources partagées et éviter les courses de données et les blocages.

Mutex (Mutex)

Mutex est un mécanisme clé pour protéger les ressources partagées contre les accès simultanés. Il permet à un seul thread d'accéder aux ressources à la fois, garantissant ainsi l'intégrité des données.

std::mutex m;  // 创建一个互斥量

void access_resource() {
  std::lock_guard<std::mutex> lock(m);  // 加锁
  // 对共享资源执行操作
  lock.unlock();  // 解锁
}

Variable de condition

Les variables de condition sont utilisées pour coordonner la coopération des threads. Il permet à un thread d'attendre qu'un autre thread effectue une action spécifique.

std::condition_variable cv;  // 创建一个条件变量
std::mutex m;  // 创建一个与条件变量关联的互斥量

void produce() {
  std::unique_lock<std::mutex> lock(m);
  // 生产数据
  lock.unlock();
  cv.notify_one();  // 通知消费者生产完成
}

void consume() {
  std::unique_lock<std::mutex> lock(m);
  // 等待生产者通知
  cv.wait(lock);
  // 消费数据
  lock.unlock();
}

Cas pratique

Ce qui suit est un exemple simple d'utilisation de mutex et de variables de condition pour gérer des ressources partagées. Il utilise un tampon pour stocker les données, le thread producteur ajoute des données au tampon et le thread consommateur lit les données du tampon.

#include <mutex>
#include <condition_variable>
#include <thread>
#include <vector>

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

std::vector<int> buffer;  // 共享资源缓冲区

void produce() {
  while (true) {
    std::lock_guard<std::mutex> lock(m);
    buffer.push_back(rand());
    cv.notify_one();
  }
}

void consume() {
  while (true) {
    std::unique_lock<std::mutex> lock(m);
    cv.wait(lock, [] { return !buffer.empty(); });
    int data = buffer.back();
    buffer.pop_back();
  }
}

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

En utilisant des variables mutex et de condition, nous garantissons que les threads producteur et consommateur peuvent accéder au tampon en même temps, mais il n'y aura pas de course aux données.

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!