Lors du traitement de structures de données et d'objets accessibles simultanément par plusieurs threads, garantissant l'intégrité et la cohérence des données est primordial. Les verrous lecteur/écrivain constituent un mécanisme efficace à cet effet.
Dans ce scénario, vous souhaitez optimiser pour un cas d'utilisation spécifique : un seul écrivain peu fréquent et de nombreux lecteurs fréquents. En vous concentrant sur ce modèle, vous pouvez améliorer considérablement les performances et l'efficacité de votre code.
À partir de C 14, la bibliothèque standard offre une prise en charge complète pour les verrous de lecteur/enregistreur via le
#include <shared_mutex> typedef std::shared_mutex Lock; typedef std::unique_lock<Lock> WriteLock; // C++11 typedef std::shared_lock<Lock> ReadLock; // C++14 Lock myLock; void ReadFunction() { ReadLock r_lock(myLock); // Do reader stuff } void WriteFunction() { WriteLock w_lock(myLock); // Do writer stuff }
Pour les versions C antérieures, Boost fournit une implémentation alternative des verrous lecteur/enregistreur via les en-têtes boost::thread::lock et boost::thread::shared_mutex :
#include <boost/thread/locks.hpp> #include <boost/thread/shared_mutex.hpp> typedef boost::shared_mutex Lock; typedef boost::unique_lock<Lock> WriteLock; typedef boost::shared_lock<Lock> ReadLock;
En utilisant le standard C ou Avec l'approche Boost, vous pouvez mettre en œuvre des verrous de lecture/écriture efficaces adaptés à votre cas d'utilisation spécifique, garantissant ainsi des performances et une protection des données optimales dans vos applications multithread.
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!