Maison > développement back-end > C++ > le corps du texte

Comment gérer l'accès simultané lors de l'utilisation de C++ STL ?

王林
Libérer: 2024-06-04 18:20:00
original
665 Les gens l'ont consulté

Dans l'accès simultané aux structures de données partagées, C++ STL fournit un mécanisme pour gérer la concurrence entre les données : mutex : permet à un seul thread d'accéder aux données partagées en même temps ; verrouillage en lecture-écriture : permet à plusieurs threads de lire en même temps mais uniquement un thread à écrire ; opérations atomiques : des opérations simples comme l’incrémentation d’un compteur peuvent être effectuées sans verrous.

使用 C++ STL 时如何处理并发访问?

Comment gérer l'accès simultané à l'aide de C++ STL

En programmation simultanée, l'accès simultané aux structures de données partagées peut conduire à des courses de données et à des plantages de programmes. La bibliothèque de modèles standard C++ (STL) fournit des mécanismes puissants pour gérer de tels scénarios.

Mutex (verrouillage mutex)

Un mutex est un verrou léger qui permet à un seul thread d'accéder aux données partagées en même temps. Voici un exemple d'utilisation d'un mutex pour protéger 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,知道不会被其他线程并发访问
}
Copier après la connexion

读写锁

读写锁允许多个线程同时读取共享数据,但仅允许一个线程写入。以下是使用读写锁保护 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
}
Copier après la connexion

原子操作

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

#include <atomic>

std::atomic<int> shared_counter;

void thread_function() {
  shared_counter.fetch_add(1);
}
Copier après la connexion

实战案例

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

Web 服务并发访问共享缓存

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

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

🎜Verrouillage en lecture-écriture🎜🎜🎜Le verrouillage en lecture-écriture permet à plusieurs threads de lire simultanément des données partagées, mais n'en autorise qu'un seul. fil pour écrire, entrez. Voici un exemple d'utilisation d'un verrou en lecture-écriture pour protéger std::map : 🎜rrreee🎜🎜Opérations atomiques🎜🎜🎜Pour des opérations simples comme incrémenter ou décrémenter un compteur, nous pouvons utiliser des opérations atomiques sans en utilisant le verrouillage. Voici un exemple de mise à jour de int à l'aide d'opérations atomiques : 🎜rrreee🎜🎜Cas pratique🎜🎜🎜Ce qui suit est un cas réel utilisant la concurrence STL C++ : 🎜🎜🎜Accès simultané du service Web au cache partagé🎜 🎜🎜🎜 Problème : 🎜Un service Web utilise std::unordered_map comme cache, et plusieurs threads accèdent au cache en même temps. 🎜🎜🎜Solution : 🎜Utilisez le verrouillage en lecture-écriture pour protéger std::unordered_map. Cela permet à plusieurs threads de lire le cache simultanément, tout en autorisant un seul thread à mettre à jour le cache, évitant ainsi les courses de données. 🎜

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!

Étiquettes associées:
source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal
À propos de nous Clause de non-responsabilité Sitemap
Site Web PHP chinois:Formation PHP en ligne sur le bien-être public,Aidez les apprenants PHP à grandir rapidement!