Quel est le but des verrous en lecture-écriture dans la programmation multithread C++ ?

En multithreading, les verrous en lecture-écriture permettent à plusieurs threads de lire des données en même temps, mais n'autorisent qu'un seul thread à écrire des données pour améliorer la concurrence et la cohérence des données. La classe std::shared_mutex en C++ fournit les fonctions membres suivantes : lock() : obtient l'accès en écriture, réussit lorsqu'aucun autre thread ne détient le verrou en lecture ou en écriture. lock_read() : Obtenez une autorisation d'accès en lecture, qui peut être détenue simultanément avec d'autres verrous en lecture ou en écriture. unlock() : libère l'accès en écriture. unlock_shared() : libère l'accès en lecture.

Le but du verrouillage en lecture-écriture dans la programmation multithread C++

Vue d'ensemble

Dans la programmation multithread, le verrouillage en lecture-écriture est un mécanisme de synchronisation qui permet à plusieurs threads de lire des données partagées à en même temps, mais un seul thread peut écrire sur les données partagées. Cela permet d’améliorer la simultanéité tout en garantissant la cohérence des données.

Implementation

La classe std::shared_mutex en C++ implémente des verrous en lecture-écriture. Il fournit les fonctions membres suivantes : std::shared_mutex 类实现了读写锁。它提供以下成员函数：

• lock(): 获取锁定的写入访问权限。只有当没有其他线程持有读取或写入锁时，此函数才成功。
• lock_read(): 获取锁定的读取访问权限。可以与其他读取锁或写入锁同时持有。
• unlock(): 释放锁定的写入访问权限。
• unlock_shared()
  • lock() : Obtenez un accès en écriture au verrou. Cette fonction ne réussit que si aucun autre thread ne détient le verrou en lecture ou en écriture.
  • lock_read() : obtenez un accès en lecture au verrou. Peut être détenu simultanément avec d’autres verrous en lecture ou en écriture.
• unlock() : Libère l'accès en écriture verrouillé.

• unlock_shared() : libère l'accès en lecture au verrou.

  Exemple d'utilisation

  Considérez le code suivant, qui utilise un verrou en lecture-écriture pour protéger une variable partagée :

  #include <iostream>
  #include <shared_mutex>
  
  std::shared_mutex m;
  int shared_var = 0;
  
  void reader() {
      m.lock_read();
      std::cout << "Reading: " << shared_var << '\n';
      m.unlock_shared();
  }
  
  void writer() {
      m.lock();
      std::cout << "Writing: " << ++shared_var << '\n';
      m.unlock();
  }
  
  int main() {
      std::thread t1(reader);
      std::thread t2(writer);
      std::thread t3(reader);
      t1.join();
      t2.join();
      t3.join();
  }

  🎜Sortie : 🎜🎜

  Reading: 0
  Writing: 1
  Reading: 1

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!