Gleichzeitige C++-Programmierung: Wie führt man Thread-Synchronisation und gegenseitigen Ausschluss durch?

Thread-Synchronisierung ist von entscheidender Bedeutung, wenn mehrere Threads gleichzeitig auf gemeinsame Ressourcen zugreifen. C++ bietet Mutexe, Bedingungsvariablen und atomare Operationen, um eine Synchronisierung zu erreichen. Mutexe stellen sicher, dass jeweils nur ein Thread auf eine Ressource zugreifen kann; Bedingungsvariablen werden für die Kommunikation zwischen Threads verwendet, und atomare Operationen stellen sicher, dass eine einzelne Operation ununterbrochen ausgeführt werden kann. Verwenden Sie beispielsweise Mutexe, um den Zugriff auf gemeinsam genutzte Warteschlangen zu synchronisieren und so Datenbeschädigungen zu verhindern.

C++ Concurrent Programming: Thread-Synchronisation und gegenseitiger Ausschluss

Übersicht

Thread-Synchronisation ist der Schlüssel zur Gewährleistung der Datenintegrität, wenn mehrere Threads gleichzeitig auf gemeinsame Ressourcen zugreifen. C++ bietet eine Vielzahl von Mechanismen zur Thread-Synchronisierung, darunter Mutexe, Bedingungsvariablen und atomare Operationen.

Mutex (Mutex)

Ein Mutex ist ein Objekt, das jeweils nur einem Thread den Zugriff auf eine gemeinsam genutzte Ressource ermöglicht. Der Mutex wird wie folgt verwendet:

std::mutex m;

void func() {
  std::lock_guard<std::mutex> lock(m);  // 获取互斥体锁
  // 访问共享资源
  // ...
}

std::lock_guard ist ein RAII-Typ, der die Sperre für den Mutex darstellt. Wenn die Ausführung der Funktion func() abgeschlossen ist, wird die Sperre automatisch aufgehoben. std::lock_guard是一种 RAII 类型，表示对互斥体的锁定。当func() 函数执行完时，锁将自动释放。

条件变量 (Condition Variable)

条件变量用于线程之间的通信。它允许一个线程等待，直到另一个线程满足某些条件。使用方法如下：

std::condition_variable cv;

void wait() {
  std::unique_lock<std::mutex> lock(m);
  cv.wait(lock);  // 等待条件变量
}

void notify() {
  std::unique_lock<std::mutex> lock(m);
  cv.notify_one();  // 通知等待的线程
}

std::unique_lock表示对互斥体的独占锁定。当wait()函数被调用时，线程将被阻塞，直到notify_one()

Bedingungsvariable

Bedingungsvariablen werden für die Kommunikation zwischen Threads verwendet. Dadurch kann ein Thread warten, bis ein anderer Thread bestimmte Bedingungen erfüllt. Die Verwendung ist wie folgt:

std::atomic<int> counter;

void increment() {
  counter++;  // 原子地递增计数器
}

std::unique_lock stellt eine exklusive Sperre für den Mutex dar. Wenn die Funktion wait() aufgerufen wird, wird der Thread blockiert, bis die Funktion notify_one() aufgerufen wird.

Atomic Operations

Atomic Operations sind ein Synchronisationsmechanismus auf niedriger Ebene, der sicherstellt, dass eine einzelne Operation ohne Unterbrechung ausgeführt werden kann. Die Verwendung ist wie folgt: 🎜

std::mutex m;
std::queue<int> queue;
const int MAX_SIZE = 10;  // 队列最大容量

void producer() {
  while (true) {
    std::lock_guard<std::mutex> lock(m);
    if (queue.size() < MAX_SIZE) {
      queue.push(rand());
    }
  }
}

void consumer() {
  while (true) {
    std::lock_guard<std::mutex> lock(m);
    if (!queue.empty()) {
      std::cout << queue.front() << std::endl;
      queue.pop();
    }
  }
}

🎜🎜Praktischer Fall🎜🎜🎜Stellen Sie sich ein Szenario vor, in dem mehrere Threads auf eine gemeinsam genutzte Warteschlange zugreifen und die Warteschlangengröße an der Obergrenze liegt. Um zu verhindern, dass Threads gleichzeitig auf die Warteschlange zugreifen und Datenbeschädigungen verursachen, können wir einen Mutex verwenden, um den Zugriff auf die Warteschlange zu synchronisieren: 🎜rrreee

Das obige ist der detaillierte Inhalt vonGleichzeitige C++-Programmierung: Wie führt man Thread-Synchronisation und gegenseitigen Ausschluss durch?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!