std:: notify_all_at_thread_exit

notify_all_at_thread_exit proporciona un mecanismo para notificar a otros hilos que un hilo determinado ha finalizado completamente, incluyendo la destrucción de todos los objetos thread_local . Opera de la siguiente manera:

• La propiedad del bloqueo previamente adquirido lk es transferida al almacenamiento interno.

• El entorno de ejecución se modifica de tal manera que cuando el hilo actual finaliza, la variable de condición cond es notificada como si fuera mediante lk. unlock ( ) ;
  cond. notify_all ( ) ; .

El desbloqueo implícito lk. unlock ( ) está secuenciado después de la destrucción de todos los objetos con duración de almacenamiento local del hilo asociados con el hilo actual.

Si se satisface cualquiera de las siguientes condiciones, el comportamiento es indefinido:

• lk no está bloqueado por el hilo que realiza la llamada.
• Si otros hilos también están esperando en cond , lk. mutex ( ) es diferente del mutex desbloqueado por las funciones de espera ( wait , wait_for y wait_until ) llamadas en cond por esos hilos.

Notas

Un efecto equivalente puede lograrse con las facilidades proporcionadas por std::promise o std::packaged_task .

El candel suministrado lk se mantiene hasta que el hilo finalice. Una vez que se ha llamado a esta función, ningún hilo adicional puede adquirir el mismo candel para esperar en cond . Si algunos hilos están esperando en esta variable de condición, asegúrese de que la condición por la que se espera se cumple mientras se mantiene el candel sobre lk , y que este candel no se libera y se readquiere antes de llamar a notify_all_at_thread_exit para evitar confusiones por despertamientos espurios en otros hilos.

En casos de uso típicos, esta función es lo último que llama un hilo separado.

Parámetros

Valor de retorno

(ninguno)

Ejemplo

#include <cassert>
#include <condition_variable>
#include <mutex>
#include <string>
#include <thread>
std::mutex m;
std::condition_variable cv;
bool ready = false;
std::string result; // some arbitrary type
void thread_func()
{
    thread_local std::string thread_local_data = "42";
    std::unique_lock<std::mutex> lk(m);
    // assign a value to result using thread_local data
    result = thread_local_data;
    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);
    cv.wait(lk, []{ return ready; });
    // result is ready and thread_local destructors have finished, no UB
    assert(result == "42");
}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también