Wie gehe ich mit gleichzeitigem Zugriff um, wenn ich C++ STL verwende?

Beim gleichzeitigen Zugriff auf gemeinsam genutzte Datenstrukturen bietet C++ STL einen Mechanismus zur Handhabung von Datenkonkurrenz: Mutex: Ermöglicht nur einem Thread den gleichzeitigen Zugriff auf gemeinsam genutzte Daten. Lese-/Schreibsperre: Ermöglicht mehreren Threads das gleichzeitige Lesen, jedoch nur ein Thread zum Schreiben; Atomare Operationen: Einfache Operationen wie das Erhöhen eines Zählers können ohne Sperren ausgeführt werden.

So handhaben Sie gleichzeitigen Zugriff mit C++ STL

Bei der gleichzeitigen Programmierung kann der gleichzeitige Zugriff auf gemeinsam genutzte Datenstrukturen zu Datenwettläufen und Programmabstürzen führen. Die C++ Standard Template Library (STL) bietet leistungsstarke Mechanismen zur Handhabung solcher Szenarien.

Mutex (Mutex-Sperre)

Ein Mutex ist eine leichte Sperre, die nur einem Thread gleichzeitig den Zugriff auf gemeinsam genutzte Daten ermöglicht. Hier ist ein Beispiel für die Verwendung eines Mutex zum Schutz von std::vector: std::vector 的示例：

#include <iostream>
#include <mutex>
#include <vector>

std::mutex vector_mutex;
std::vector<int> shared_vector;

void thread_function() {
  std::lock_guard<std::mutex> lock(vector_mutex);
  // 访问 shared_vector，知道不会被其他线程并发访问
}

读写锁

读写锁允许多个线程同时读取共享数据，但仅允许一个线程写入。以下是使用读写锁保护 std::map 的示例：

#include <iostream>
#include <shared_mutex>
#include <map>

std::shared_mutex map_mutex;
std::map<std::string, int> shared_map;

void reader_thread_function() {
  std::shared_lock<std::shared_mutex> lock(map_mutex);
  // 读取 shared_map
}

void writer_thread_function() {
  std::unique_lock<std::shared_mutex> lock(map_mutex);
  // 写入 shared_map
}

原子操作

对于简单的操作（如递增或递减计数器），我们可以使用原子操作，无需使用锁。以下是使用原子操作更新 int 的示例：

#include <atomic>

std::atomic<int> shared_counter;

void thread_function() {
  shared_counter.fetch_add(1);
}

实战案例

以下是一个使用 C++ STL 并发的真实案例：

Web 服务并发访问共享缓存

问题：一个 Web 服务使用 std::unordered_map 作为缓存，多个线程同时访问缓存。

解决方案：使用读写锁保护 std::unordered_maprrreee

🎜Lese-/Schreibsperre🎜🎜🎜Die Lese-/Schreibsperre ermöglicht es mehreren Threads, gemeinsam genutzte Daten gleichzeitig zu lesen, erlaubt jedoch nur einem Thread zum Schreiben eingeben. Hier ist ein Beispiel für die Verwendung einer Lese-/Schreibsperre zum Schutz von std::map: 🎜rrreee🎜🎜Atomere Operationen🎜🎜🎜Für einfache Operationen wie das Erhöhen oder Verringern eines Zählers können wir atomare Operationen ohne verwenden mit Lock. Das Folgende ist ein Beispiel für die Aktualisierung von int mit atomaren Operationen: 🎜rrreee🎜🎜Praktischer Fall🎜🎜🎜Das Folgende ist ein realer Fall mit C++-STL-Parallelität: 🎜🎜🎜Gleichzeitiger Webdienst-Zugriff auf gemeinsam genutzten Cache🎜 🎜🎜🎜 Problem: 🎜Ein Webdienst verwendet std::unordered_map als Cache und mehrere Threads greifen gleichzeitig auf den Cache zu. 🎜🎜🎜Lösung: 🎜Verwenden Sie eine Lese-/Schreibsperre, um std::unordered_map zu schützen. Dadurch können mehrere Threads den Cache gleichzeitig lesen, während nur ein Thread den Cache aktualisieren kann, wodurch Datenwettläufe vermieden werden. 🎜

Das obige ist der detaillierte Inhalt vonWie gehe ich mit gleichzeitigem Zugriff um, wenn ich C++ STL verwende?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!