Multithread-Sperren in C++ und deren Verwendung

Multithread-Sperren in C++ und wie man sie verwendet

Um die Datensicherheit zu gewährleisten und Race Conditions zu vermeiden, müssen wir beim Schreiben von Multithread-Programmen Sperren verwenden. Eine Sperre ist ein Synchronisationsmechanismus, der es ermöglicht, dass ein bestimmter Codeblock gleichzeitig nur von einem Thread ausgeführt wird. In C++ stehen viele Arten von Sperren zur Auswahl. Die am häufigsten verwendeten sind Mutex-Sperren, Lese-/Schreibsperren und Bedingungsvariablen. In diesem Artikel werden die grundlegenden Konzepte, Verwendung und Vorsichtsmaßnahmen dieser Schlösser vorgestellt.

Mutex (Mutex)

Mutex-Sperren werden häufig verwendet, um gemeinsam genutzte Ressourcen zu schützen und nur einem Thread gleichzeitig den Zugriff darauf zu ermöglichen. Wenn ein Thread eine Sperre hält, müssen andere Threads, die die Sperre halten möchten, warten. Wenn der Thread die Sperre aufhebt, können andere Threads beginnen, auf die gemeinsam genutzte Ressource zuzugreifen.

In C++ lautet die Definition einer Mutex-Sperre wie folgt:

#include <mutex>

std::mutex mutex;

Die Methode zur Verwendung einer Mutex-Sperre lautet normalerweise wie folgt:

// 线程1
mutex.lock();
// 访问共享资源
mutex.unlock();

// 线程2
mutex.lock();
// 访问共享资源
mutex.unlock();

Es ist zu beachten, dass Sie bei Verwendung einer Mutex-Sperre immer Sperre und verwenden sollten Entsperren, andernfalls kann es zu einem Deadlock kommen. Darüber hinaus sollten Sie vermeiden, die Sperre über einen längeren Zeitraum zu belegen, um die Ausführung anderer Threads nicht zu beeinträchtigen.

Reader-Writer-Sperre

Read-Writer-Sperre ist eine spezielle Sperre, die es mehreren Threads ermöglicht, gemeinsam genutzte Ressourcen gleichzeitig zu lesen, aber nur einem Thread erlaubt, auf gemeinsam genutzte Ressourcen zu schreiben. Wenn ein Thread auf eine gemeinsam genutzte Ressource schreibt, können andere Threads nicht lesen oder schreiben, bis der Schreibvorgang abgeschlossen ist, und der lesende Thread kann nicht mit dem Lesen fortfahren. Die Definition einer Lese-/Schreibsperre lautet wie folgt:

#include <shared_mutex>

std::shared_mutex rw_mutex;

Die Methode zur Verwendung einer Lese-/Schreibsperre lautet wie folgt:

// 写入线程
rw_mutex.lock();
// 写入共享资源
rw_mutex.unlock();

// 读取线程
rw_mutex.lock_shared();
// 读取共享资源
rw_mutex.unlock_shared();

Es ist zu beachten, dass bei Verwendung einer Lese-/Schreibsperre den Threads Priorität eingeräumt werden sollte die gemeinsam genutzte Ressourcen lesen, um zu verhindern, dass Schreibvorgänge die Sperre für längere Zeit belegen.

Bedingungsvariable

Bedingungsvariablen werden normalerweise für die Synchronisierung und Kommunikation zwischen Threads verwendet. Es handelt sich um einen auf Mutex-Sperren basierenden Synchronisationsmechanismus, der durch Warte- und Benachrichtigungsmechanismen eine Koordination zwischen Threads erreichen kann.

Die Definition von Bedingungsvariablen lautet wie folgt:

#include <condition_variable>

std::condition_variable cond_var;

Bedingungsvariablen werden normalerweise zusammen mit Mutex-Sperren verwendet. Der Warte- und Aufwachvorgang ist wie folgt:

// 线程1
std::unique_lock<std::mutex> lock(mutex);
cond_var.wait(lock);
// 唤醒后执行的代码

// 线程2
std::unique_lock<std::mutex> lock(mutex);
// 执行唤醒操作
cond_var.notify_one();

Es ist zu beachten, dass Sie zuerst Bedingungsvariablen verwenden müssen Sperren Sie sie, sonst kann es zu einem Deadlock kommen.

Zusammenfassung

In der Multithread-Programmierung sind Sperren ein wesentlicher Synchronisationsmechanismus. Bei der Auswahl einer Sperre sollten Sie die Eigenschaften und Verwendungsszenarien verschiedener Sperren berücksichtigen, um die Datensicherheit und Thread-Koordination besser zu gewährleisten. Denken Sie an die Grundprinzipien der Verwendung von Sperren: granulare Kontrolle und Vermeidung von Deadlocks.

Das obige ist der detaillierte Inhalt vonMultithread-Sperren in C++ und deren Verwendung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!