Maison > développement back-end > C++ > std::shared_ptr est-il Thread-Safe lors de la modification d'objets partagés ?

std::shared_ptr est-il Thread-Safe lors de la modification d'objets partagés ?

Patricia Arquette
Libérer: 2024-11-09 22:55:02
original
270 Les gens l'ont consulté

Is std::shared_ptr Thread-Safe When Modifying Shared Objects?

Comprendre la sécurité des threads std::shared_ptr

La documentation fait référence à la sécurité des threads du bloc de contrôle, qui gère la propriété partagée de l'objet. Plusieurs threads peuvent accéder simultanément à différents objets shared_ptr, car ils partagent la propriété de la ressource sous-jacente sans conflits. Cependant, cela ne garantit pas la sécurité de la modification de l'objet partagé lui-même.

Shared_ptr et modifications d'objet

Dans votre exemple de code, le thread 1 crée une copie privée de global en utilisant shared_ptr, tandis que le thread 2 modifie global lui-même. Ce qui suit explique le comportement :

  • Le privé du thread 1 est initialement défini sur la valeur d'origine de global.
  • Lorsque le thread 2 modifie global, cela n'affecte pas le pointeur de privé, car les points privés vers un bloc de contrôle différent.
  • Cependant, private sera finalement détruit, décrémentant le nombre de références dans le bloc de contrôle qui a été modifié par le thread 2.
  • Bien que private reste un shared_ptr valide, sa durée de vie est indépendante du global modifié.

Considérations sur la sécurité des threads

Pour modifier en toute sécurité un objet partagé par plusieurs threads, vous devez utiliser un mécanisme de synchronisation tel que std::mutex. L'exemple suivant illustre une mise à jour de configuration thread-safe à l'aide d'un mutex :

// Shared pointer to the configuration object
std::shared_ptr<Configuration> global_config = make_shared<Configuration>();

// Mutex to protect the configuration object
std::mutex config_mutex;

void thread_fcn() {
    // Lock the mutex before accessing the configuration
    std::lock_guard<std::mutex> lock(config_mutex);

    // Update the configuration from global_config
    // ...

    // Unlock the mutex after finishing the update
}
Copier après la connexion

En acquérant le mutex avant de modifier global_config, vous évitez toute interférence d'autres threads. Cela garantit que la configuration est toujours mise à jour de manière cohérente et sécurisée pour les threads.

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!

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
Derniers articles par auteur
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal