std:: sécurité des threads PTR partagés

Ce que vous lisez ne signifie pas ce que vous pensez que cela signifie. Tout d'abord, essayez la page msdn pour shared_ptr lui-même.

Faites défiler vers le bas dans la section "Remarques" et vous arriverez à la viande de la question. Fondamentalement, un shared_ptr<> pointe vers un "bloc de contrôle" qui est la façon dont il garde la trace du nombre d'objets shared_ptr<> pointant réellement vers l'objet "réel". Donc, quand vous faites ceci:

shared_ptr<int> ptr1 = make_shared<int>();

Alors qu'il n'y a que 1 appel pour allouer de la mémoire ici via make_shared, Il y en a deux blocs "logiques" que vous ne devriez pas traiter de la même manière. L'un est le int, qui stocke la valeur réelle, et l'autre est le bloc de contrôle, qui stocke toutes les shared_ptr<> "magique" qui le fait fonctionner.

C'est seulement le bloc de contrôle lui-même qui est thread-safe.

Je mets cela sur sa propre ligne pour l'accent. Le contenu du shared_ptr ne sont pas thread-safe, ni écrit dans la même instance shared_ptr. Voici quelque chose pour démontrer ce que je moyenne:

// In main()
shared_ptr<myClass> global_instance = make_shared<myClass>();
// (launch all other threads AFTER global_instance is fully constructed)

//In thread 1
shared_ptr<myClass> local_instance = global_instance;

C'est bien, en fait vous pouvez le faire dans tous les threads autant que vous le souhaitez. Et puis quand local_instance est détruit (en sortant de la portée), il est également thread-safe. Quelqu'un peut accéder à global_instance et cela ne fera aucune différence. L'extrait que vous avez tiré de msdn signifie essentiellement que "l'accès au bloc de contrôle est sécurisé par les threads", de sorte que d'autres instances shared_ptr<> peuvent être créées et détruites sur différents threads autant que nécessaire.

//In thread 1
local_instance = make_shared<myClass>();

, Ce qui est correct. Il sera affecte l'objet global_instance, mais seulement indirectement. Le bloc de contrôle vers lequel il pointe sera décrémenté, mais fait de manière sûre pour les threads. local_instance ne pointera plus vers le même objet (ou bloc de contrôle) que global_instance.

//In thread 2
global_instance = make_shared<myClass>();

Ce n'est certainement pas bien si global_instance est accessible à partir d'autres threads (ce que vous dites faire). Il a besoin d'un verrou si vous faites cela parce que vous écrivez partout où global_instance vit, pas seulement en lisant. Donc, écrire sur un objet à partir de plusieurs threads est mauvais à moins que ce soit vous l'avez gardé à travers une serrure. Vous pouvez donc lire à partir de global_instance l'objet en lui attribuant de nouveaux objets shared_ptr<> mais vous ne pouvez pas y écrire.

// In thread 3
*global_instance = 3;
int a = *global_instance;

// In thread 4
*global_instance = 7;

, La valeur de a n'est pas défini. Il pourrait être 7, ou il pourrait être 3, ou il pourrait être autre chose ainsi. La sécurité des threads des instances shared_ptr<> ne s'applique qu'à la gestion des instances shared_ptr<> initialisées les unes par rapport aux autres, pas à ce qu'elles pointent.

Pour souligner ce que je veux dire, regardez ce:

shared_ptr<int> global_instance = make_shared<int>(0);

void thread_fcn();

int main(int argc, char** argv)
{
    thread thread1(thread_fcn);
    thread thread2(thread_fcn);
    ...
    thread thread10(thread_fcn);

    chrono::milliseconds duration(10000);
    this_thread::sleep_for(duration);

    return;
}

void thread_fcn()
{
    // This is thread-safe and will work fine, though it's useless.  Many
    // short-lived pointers will be created and destroyed.
    for(int i = 0; i < 10000; i++)
    {
        shared_ptr<int> temp = global_instance;
    }

    // This is not thread-safe.  While all the threads are the same, the
    // "final" value of this is almost certainly NOT going to be
    // number_of_threads*10000 = 100,000.  It'll be something else.
    for(int i = 0; i < 10000; i++)
    {
        *global_instance = *global_instance + 1;
    }
}

Un shared_ptr<> est un mécanisme pour assurer que plusieurs objet propriétaires de garantir que l'objet est détruit, pas un mécanisme pour s'assurer de multiples threads peut accéder à un objet correctement. Vous avez toujours besoin d'un mécanisme de synchronisation séparé pour l'utiliser en toute sécurité dans plusieurs threads (comme std:: mutex ).

La meilleure façon D'y penser IMO est que shared_ptr<> s'assure que plusieurs copies pointant vers la même mémoire n'ont pas de problèmes de synchronisation pour lui, mais ne fait rien pour l'objet pointé. Le traiter comme ça.