Was ist der Zweck von Lese-/Schreibsperren in der C++-Multithread-Programmierung?

Beim Multithreading ermöglichen Lese-/Schreibsperren mehreren Threads das gleichzeitige Lesen von Daten, erlauben jedoch nur einem Thread das Schreiben von Daten, um die Parallelität und Datenkonsistenz zu verbessern. Die Klasse std::shared_mutex in C++ stellt die folgenden Mitgliedsfunktionen bereit: lock(): Erhält Schreibzugriff, ist erfolgreich, wenn kein anderer Thread die Lese- oder Schreibsperre hält. lock_read(): Erhalten Sie die Lesezugriffsberechtigung, die gleichzeitig mit anderen Lesesperren oder Schreibsperren gehalten werden kann. unlock(): Gibt den Schreibzugriff frei. unlock_shared(): Gibt Lesezugriff frei.

Verwendung der Lese-/Schreibsperre in der C++-Multithread-Programmierung

Übersicht

Bei der Multithread-Programmierung ist die Lese-/Schreibsperre ein Synchronisationsmechanismus, der es mehreren Threads ermöglicht, gemeinsam genutzte Daten gleichzeitig zu lesen Gleichzeitig kann jedoch nur ein Thread in die gemeinsam genutzten Daten schreiben. Dies trägt dazu bei, die Parallelität zu verbessern und gleichzeitig die Datenkonsistenz sicherzustellen.

Implementierung

Die Klasse std::shared_mutex in C++ implementiert Lese-/Schreibsperren. Es stellt die folgenden Mitgliedsfunktionen bereit: std::shared_mutex 类实现了读写锁。它提供以下成员函数：

• lock(): 获取锁定的写入访问权限。只有当没有其他线程持有读取或写入锁时，此函数才成功。
• lock_read(): 获取锁定的读取访问权限。可以与其他读取锁或写入锁同时持有。
• unlock(): 释放锁定的写入访问权限。
• unlock_shared()
  • lock(): Schreibzugriff auf die Sperre erhalten. Diese Funktion ist nur dann erfolgreich, wenn kein anderer Thread die Lese- oder Schreibsperre hält.
  • lock_read(): Lesezugriff auf die Sperre erhalten. Kann gleichzeitig mit anderen Lese- oder Schreibsperren gehalten werden.
• unlock(): Gesperrten Schreibzugriff freigeben.

• unlock_shared(): Gibt den Lesezugriff auf die Sperre frei.

  Beispielverwendung

  Betrachten Sie den folgenden Code, der eine Lese-/Schreibsperre verwendet, um eine gemeinsam genutzte Variable zu schützen:

  #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();
  }

  🎜Ausgabe: 🎜🎜

  Reading: 0
  Writing: 1
  Reading: 1

Das obige ist der detaillierte Inhalt vonWas ist der Zweck von Lese-/Schreibsperren in der C++-Multithread-Programmierung?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!