std::shared_ptr fil de sécurité

Ce que vous êtes en train de lire n'est 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 aurez de la viande de la question. Fondamentalement, un shared_ptr<> points à un "bloc de contrôle" qui est la façon dont il garde la trace de combien de shared_ptr<> objets sont réellement pointant vers la "Vraie" objet. Donc, quand vous faites cela:

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

Alors qu'il est à seulement 1 appel à allouer de la mémoire ici via make_shared, il y a deux "logiques" de blocs que vous ne devriez pas traiter le même. 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.

Il n'est que le bloc de contrôle de lui-même qui est thread-safe.

Je l'ai mis sur sa propre ligne pour mettre l'accent. Le contenu de la shared_ptr ne sont pas thread-safe, ni est écrit à la même shared_ptr instance. Voici quelque chose à démontrer ce que je veux dire:

//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 très bien, en fait, vous pouvez le faire dans toutes les discussions comme beaucoup que vous le souhaitez. Et puis quand local_instance est détruite (par sortir du champ d'application), il est également thread-safe. Quelqu'un peut accéder à global_instance et il ne fera pas une différence. L'extrait de code que vous avez retirées à partir de msdn signifie fondamentalement "l'accès au bloc de contrôle est thread-safe" de sorte que les autres shared_ptr<> instances peuvent être créés et détruits sur différents threads autant que nécessaire.

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

C'est très bien. Il sera affecter la global_instance objet, mais seulement indirectement. Le bloc de contrôle de pointe pour sera décrémenté, mais fait dans un thread-safe façon. local_instance n'aura plus de point pour le même objet (ou d'un bloc de contrôle) comme global_instance n'.

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

Ce n'est presque certainement pas très bien si global_instance est accessible à partir de tous les autres threads (qui vous dites que vous êtes en train de faire). Il a besoin d'un verrou si vous faites cela parce que vous écrivez là où global_instance vie, pas seulement de la lecture. Donc, l'écriture à un objet à partir de plusieurs threads est mauvais, sauf que vous avez gardé par un verrou. De sorte que vous pouvez lire à partir de global_instance l'objet par l'attribution de shared_ptr<> objets, mais vous ne pouvez pas écrire.

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

//In thread 4
*global_instance = 7;

La valeur de a est pas défini. Il pourrait être de 7, ou il peut être de 3, ou il pourrait être quelque chose d'autre aussi. Le fil de sécurité de la shared_ptr<> cas s'applique uniquement à la gestion de shared_ptr<> les instances qui ont été initialisé les uns des autres, et non pas ce qu'ils sont en pointe.

De souligner ce que je veux dire, regardez ceci:

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 fils peut accéder à un objet correctement. Vous avez encore le besoin d'un mécanisme de synchronisation pour l'utiliser en toute sécurité dans plusieurs threads (comme std::mutex).

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

Il signifie que vous aurez un valide shared_ptr, et une pièce de comptage de référence.

Vous décrivez une situation de concurrence entre les 2 fils qui sont d'essayer de lire/d'attribuer à la même variable.

Parce que c'est un comportement indéfini en général (il n'a de sens que dans le contexte et le calendrier du programme individuel) shared_ptr ne gère pas que.

Je pense que pour l'instant les réponses à cette question sont trompeuses à l'égard de scénario décrit. J'ai un scénario semblable à celle décrite dans la question. Tous les autres threads ont (besoin) juste un accès en lecture seule à la configuration actuelle qui est réalisé à travers:

//In thread n
shared_ptr<MyConfig> sp_local = sp_global;

Aucun de ces threads à modifier le contenu de la MyConfig objet. Ref nombre de sp_global est incrémenté pour chaque exécution de la ligne ci-dessus.

Thread 1, périodiquement réinitialise le sp_global pour certains une autre instance de la configuration:

//In thread 1
shared_ptr<MyConfig> sp_global = make_shared<MyConfig>(new MyConfig);

Ce devrait être aussi sûr. Il définit la ref nombre de sp_global à 1, et le sp_global maintenant les points à la dernière configuration, tout comme avec toutes les nouvelles copies locales. Donc, si je ne suis pas manque quelque chose ici, ce devrait être totalement thread-safe.

#include <iostream>
#include <memory>
using namespace std;
shared_ptr<int> sp1(new int(10));
int main()
{
cout<<"Hello World! \n";
cout << "sp1 use count: " << sp1.use_count() << ", sp1: " << *sp1 << "\n";
cout << "---------\n";
shared_ptr<int> sp2 = sp1;
shared_ptr<int>* psp3 = new shared_ptr<int>;
*psp3 = sp1;
cout << "sp1 use count: " << sp1.use_count() << ", sp1: " << *sp1 << "\n";
cout << "sp2 use count: " << sp2.use_count() << ", sp2: " << *sp2 << "\n";
cout << "sp3 use count: " << psp3->use_count() << ", sp3: " << *(*psp3) << "\n";
cout << "---------\n";
sp1.reset(new int(20));
cout << "sp1 use count: " << sp1.use_count() << ", sp1: " << *sp1 << "\n";
cout << "sp2 use count: " << sp2.use_count() << ", sp2: " << *sp2 << "\n";
cout << "sp3 use count: " << psp3->use_count() << ", sp3: " << *(*psp3) << "\n";
cout << "---------\n";
delete psp3;
cout << "sp1 use count: " << sp1.use_count() << ", sp1: " << *sp1 << "\n";
cout << "sp2 use count: " << sp2.use_count() << ", sp2: " << *sp2 << "\n";
cout << "---------\n";
sp1 = nullptr;
cout << "sp1 use count: " << sp1.use_count() << "\n";
cout << "sp2 use count: " << sp2.use_count() << ", sp2: " << *sp2 << "\n";
return 0;
}

et la sortie

Hello World!
sp1 use count: 1, sp1: 10
---------
sp1 use count: 3, sp1: 10
sp2 use count: 3, sp2: 10
sp3 use count: 3, sp3: 10
---------
sp1 use count: 1, sp1: 20
sp2 use count: 2, sp2: 10
sp3 use count: 2, sp3: 10
---------
sp1 use count: 1, sp1: 20
sp2 use count: 1, sp2: 10
---------
sp1 use count: 0
sp2 use count: 1, sp2: 10