Espaces de noms
Variantes
Affichages
Actions

std::notify_all_at_thread_exit

De cppreference.com
< cpp‎ | thread

 
 
Bibliothèque de support fil
Threads
Original:
Threads
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
thread (C++11)
this_thread espace de noms
Original:
this_thread namespace
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
get_id (C++11)
yield (C++11)
sleep_for (C++11)
sleep_until (C++11)
L'exclusion mutuelle
Original:
Mutual exclusion
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
mutex (C++11)
timed_mutex (C++11)
Gestion du verrouillage générique
Original:
Generic lock management
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
lock_guard (C++11)
unique_lock (C++11)
defer_lock_t
try_to_lock_t
adopt_lock_t
(C++11)
(C++11)
(C++11)
lock (C++11)
try_lock (C++11)
defer_lock
try_to_lock
adopt_lock
(C++11)
(C++11)
(C++11)
Les variables de condition
Original:
Condition variables
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
condition_variable (C++11)
condition_variable_any (C++11)
notify_all_at_thread_exit (C++11)
cv_status (C++11)
Futures
Original:
Futures
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
promise (C++11)
future (C++11)
shared_future (C++11)
packaged_task (C++11)
async (C++11)
launch (C++11)
future_status (C++11)
future_error (C++11)
future_category (C++11)
future_errc (C++11)
 
Defined in header <condition_variable>
void notify_all_at_thread_exit( std::condition_variable& cond,
                                std::unique_lock<std::mutex> lk );
(depuis C++11)
notify_all_at_thread_exit fournit un mécanisme pour informer les autres threads qu'un thread donné a complètement finis, y compris la destruction de tous les objets thread_local. Il fonctionne comme suit:
Original:
notify_all_at_thread_exit provides a mechanism to notify other threads that a given thread has completely finished, including destroying all thread_local objects. It operates as follows:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
  • La propriété de la serrure lk précédemment acquis est transféré dans la mémoire interne .
    Original:
    Ownership of the previously acquired lock lk is transferred to internal storage.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • L'environnement d'exécution est modifiée de telle sorte que lorsque le thread courant, après les destructeurs pour tous les objets sont appelés durée de stockage local des threads, la variable de condition est cond notifiée comme par:
    Original:
    The execution environment is modified such that when the current thread exits, after the destructors for all objects with durée de stockage local des threads are called, the condition variable cond is notified as if by:
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

lk.unlock();
cond.notify_all();

D'effet équivalent peut être réalisé avec des moyens prévus par std::promise ou std::packaged_task .
Original:
An equivalent effect may be achieved with the facilities provided by std::promise or std::packaged_task.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Sommaire

[modifier] Notes

L'appel de cette fonction si lock.mutex() n'est pas verrouillé par le thread courant est un comportement indéfini .
Original:
Calling this function if lock.mutex() is not locked by the current thread is undefined behavior.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
L'appel de cette fonction si lock.mutex() n'est pas le mutex même que celui utilisé par les autres threads qui sont actuellement en attente sur la variable de condition même comportement indéfini .
Original:
Calling this function if lock.mutex() is not the same mutex as the one used by all other threads that are currently waiting on the same condition variable is undefined behavior.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Le lk de verrouillage fourni est maintenu jusqu'à la sortie du thread. Une fois que cette fonction a été appelée, aucune discussion ne peut acquérir plus le même verrou afin d'attendre le cond. Si un thread est en attente sur la variable condition, il ne doit pas tenter de libérer et de réacquérir le verrou quand il se réveille faussement .
Original:
The supplied lock lk is held until the thread exits. Once this function has been called, no more threads may acquire the same lock in order to wait on cond. If some thread is waiting on this condition variable, it should not attempt to release and reacquire the lock when it wakes up spuriously.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Dans les cas typiques d'utilisation, cette fonction est la dernière chose appelée par un thread détaché .
Original:
In typical use cases, this function is the last thing called by a detached thread.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Paramètres

cond -
la variable de condition de notifier à la sortie du fil
Original:
the condition variable to notify at thread exit
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
lk -
le verrou associé à la variable de condition cond
Original:
the lock associated with the condition variable cond
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Retourne la valeur

(Aucun)
Original:
(none)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Exemple

Ce fragment de code illustre comment notify_all_at_thread_exit partielle peut être utilisée pour éviter accéder à des données qui dépend de fil tandis que les habitants locaux fils sont en train d'être détruit:
Original:
This partial code fragment illustrates how notify_all_at_thread_exit can be used to avoid accessing data that depends on thread locals while those thread locals are in the process of being destructed:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

#include <mutex>
#include <thread>
 
std::mutex m;
std::condition_variable cv;
 
bool ready = false;
ComplexType result;  // some arbitrary type
 
void thread_func()
{
    std::unique_lock<std::mutex> lk(m);
    // assign a value to result using thread_local data
    result = function_that_uses_thread_locals();
    ready = true;
    std::notify_all_at_thread_exit(cv, std::move(lk));
} // 1. destroy thread_locals, 2. unlock mutex, 3. notify cv
 
int main()
{
    std::thread t(thread_func);
    t.detach();
 
    // do other work
    // ...
 
    // wait for the detached thread
    std::unique_lock<std::mutex> lk(m);
    while(!ready) {
        cv.wait(lk);
    }
    process(result); // result is ready and thread_local destructors have finished
}


[modifier] Voir aussi

définit le résultat à la valeur spécifique, tout en offrant la seule notification à la sortie du fil
Original:
sets the result to specific value while delivering the notification only at thread exit
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction membre publique de std::promise) [edit]
exécute la fonction de faire en sorte que le résultat est prêt une fois que le thread courant
Original:
executes the function ensuring that the result is ready only once the current thread exits
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction membre publique de std::packaged_task) [edit]