Quels sont les mécanismes courants de synchronisation des threads dans la programmation multithread C++ ?

En programmation multithread C++, les mécanismes de synchronisation des threads sont essentiels. Il en existe trois types principaux : Mutex (Mutex) : utilisé pour protéger l'accès exclusif aux ressources partagées. Variable de condition : utilisée pour informer le thread qu'une condition spécifique a été remplie. Verrouillage lecture-écriture : permet à plusieurs threads de lire des données partagées en même temps, mais un seul thread peut écrire à la fois.

Mécanisme de synchronisation des threads dans la programmation multithread C++

Dans la programmation multithread, le mécanisme de synchronisation est crucial pour éviter les courses de données et garantir la sécurité des threads. Voici quelques mécanismes de synchronisation de threads courants en C++ :

Mutex (Mutex)

Mutex est un mécanisme de synchronisation de bas niveau utilisé pour protéger l'accès exclusif aux ressources partagées. Il permet à un seul thread d'accéder aux sections critiques (blocs de code nécessitant une synchronisation) à la fois.

std::mutex m;

void critical_section() {
  std::lock_guard<std::mutex> lock(m);
  // 临界区代码
}

Variable de condition

La variable de condition est utilisée pour avertir un thread qu'un autre thread remplit une condition spécifique. Un thread peut attendre une condition en utilisant la méthode wait(), tandis qu'un autre thread peut la signaler en utilisant notify_one() ou notify_all() méthode. wait() 方法等待条件，而另一个线程可以使用 notify_one() 或notify_all() 方法发出信号。

std::condition_variable cv;
bool condition_met = false;

void wait_for_condition() {
  std::unique_lock<std::mutex> lock(m);
  cv.wait(lock, []() { return condition_met; });
}

void signal_condition() {
  std::lock_guard<std::mutex> lock(m);
  condition_met = true;
  cv.notify_one();
}

读写锁 (Read-Write Lock)

读写锁允许多个线程同时读取共享数据，但一次只能有一个线程写入共享数据。

std::shared_lock<std::shared_mutex> lock(m, std::shared_lock<std::shared_mutex>::defer_lock);

实战案例：共享计数器

考虑一个共享计数器，需要同时支持多个线程的增量和获取操作：

class SharedCounter {
  std::mutex mutex_;
  int count_;

public:
  void increment() {
    std::lock_guard<std::mutex> lock(mutex_);
    ++count_;
  }

  int get() {
    std::lock_guard<std::mutex> lock(mutex_);
    return count_;
  }
};

在这个例子中，mutex_ 互斥锁用于保护 count_ 变量。每个线程都可以通过 increment() 方法独立增量计数器，并且可以通过 get()rrreee

🎜Read-Write Lock (Read-Write Lock)🎜🎜🎜Read-Write Lock permet à plusieurs threads de lire des données partagées en même temps, mais un seul thread peut écrire des données partagées à la fois. 🎜rrreee🎜🎜Cas pratique : Compteur partagé🎜🎜🎜Considérons un compteur partagé qui doit prendre en charge les opérations d'incrémentation et d'acquisition de plusieurs threads en même temps : 🎜rrreee🎜Dans cet exemple, le verrou mutex mutex_ est utilisé pour protéger la variable count_. Chaque thread peut incrémenter indépendamment le compteur via la méthode increment(), et peut lire la valeur actuelle via la méthode get(). 🎜

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!