Comment comprendre "std::future shared state" ?

Question

Selon la documentation( http://www.cplusplus.com/reference/future/future/get/ ), qui dit que : [c'est moi qui souligne]

Une fois que le état partagé est prêt, la fonction débloque et retourne (ou throws) en libérant son état partagé. Cela rend l'objet futur non plus valide : cette fonction membre sera appelée une fois au plus pour chaque futur état partagé .

Selon la documentation( http://www.cplusplus.com/reference/future/future/ ), qui dit que : [c'est moi qui souligne]

Les futures "valides" sont des objets futurs associés à un état partagé et sont construites en appelant l'une des fonctions suivantes

asynchrone

promise::get_future

packaged_task::get_future

Selon la documentation( http://www.cplusplus.com/reference/future/future/get/ ), qui dit que : [c'est moi qui souligne]

std::future::get

modèle générique (1) T get() ; référence

spécialisation (2) R& future::get() ; // quand T est une référence

type (R&) void spécialisation (3) void future::get() ; // quand T est void

Retour :

valeur généralement (1), std::move(x), où x est la valeur stockée dans l'état partagé .

Pour les références (2), une référence à la valeur mémorisée dans l'état partagé .

Pour les contrats à terme (3), rien.

Ma question est de savoir ce qu'est le " std::future état partagé" ? Comment puis-je comprendre "std::future shared state" ?

Je suis un novice en C++. Bien que j'y ai pensé et réfléchi, je n'arrive toujours pas à saisir l'idée. Je serais très reconnaissant d'avoir de l'aide pour cette question.

Answer 1

Selon le Référence cpp la documentation sur std::future :

Lorsque l'opération asynchrone est prête à envoyer un résultat au créateur, elle peut le faire en modifiant l'état partagé (par exemple std::promise::set_value) qui est lié au std::future du créateur.

L'état partagé fait ici référence à des éléments mutables lisibles/inscriptibles par plusieurs threads. Considérez l'exemple tiré directement de la documentation :

std::promise<int> p;
std::future<int> f = p.get_future();
std::thread([&p]{ p.set_value_at_thread_exit(9); }).detach();
f.wait();

Le fil principal et le fil créé partagent p (et comme p est stateful, ils partagent l'état !). Appeler std::promise::set_value_at_thread_exit à l'intérieur du corps de la lambda modifie effectivement l'état partagé entre ces deux threads. C'est essentiellement tout ce que cela signifie.

El std::future donnée par la promesse est une représentation de la partie "intéressante" de l'état partagé -- la valeur qui vous intéresse.