std::notify_all_at_thread_exit
Definido en el archivo de encabezado <condition_variable> | ||
void notify_all_at_thread_exit(std::condition_variable& cond, std::unique_lock<std::mutex> lk ); | (desde C++11) | |
notify_all_at_thread_exit proporciona un mecanismo para notificar a otros hilos que un hilo dado ha finalizado por completo, incluida la destrucción de todos los objetos thread_local. Funciona de la siguiente manera:
- La posesión del cerrojo adquirido anteriormente
lkse transfiere al almacenamiento interno.
- El entorno de ejecución se modifica de modo que cuando el hilo actual termina, a la variable de condición
condse le notifica como si:
lk.unlock();
cond.notify_all();
La operación lk.unlock implícita está secuenciada-después (como se define en std::memory_order) de la destrucción de todos los objetos con duración de almacenamiento local al hilo asociados con el hilo actual.
Un efecto equivalente puede conseguirse con los servicios proporcionados por std::promise o std::packaged_task.
Contenido |
[editar]Notas
Llamar a esta función si lock.mutex() no está bloqueado por el hilo actual resulta en un comportamiento no definido.
Llamar a esta función si lock.mutex() no es el mismo mutex que el utilizado por todos los demás hilos que actualmente están esperando en la misma variable de condición resulta en un comportamiento no definido.
El cerrojo proporcionado por lk se mantiene bloqueado hasta que el hilo termina. Una vez que se ha llamado a esta función, no más hilos pueden tomar posesión del mismo cerrojo para esperar en cond. Si algún hilo está esperando en esta variable de condición, no debe intentar liberar y volver a tomar posesión del cerrojo cuando se despierte de forma falsa (spuriously).
En casos de uso típicos, esta función es lo último que llama un hilo separado.
[editar]Parámetros
| cond | - | La variable de condición a notificar cuando el hilo termina. |
| lk | - | El cerrojo asociado con la variable de condición cond. |
[editar]Valor de retorno
(Ninguno)
[editar]Ejemplo
Este fragmento de código parcial ilustra cómo notify_all_at_thread_exit puede usarse para evitar acceder a datos que dependen de variables locales al hilo mientras que esas variables están siendo destruidas:
#include <mutex>#include <thread>#include <condition_variable> #include <cassert>#include <string> std::mutex m;std::condition_variable cv; bool ready =false;std::string result;// algún tipo arbitrario void thread_func(){ thread_local std::string thread_local_data ="42"; std::unique_lock<std::mutex> lk(m); // asigna un valor al resultado usando datos thread_local result = thread_local_data; ready =true; std::notify_all_at_thread_exit(cv, std::move(lk)); }// 1. destruir variables thread_local;// 2. desbloquear mutex;// 3. notificar a cv. int main(){std::thread t(thread_func); t.detach(); // hacer otro trabajo// ... // espera el hilo separadostd::unique_lock<std::mutex> lk(m); cv.wait(lk, []{return ready;}); // el resultado está listo y los destructores// locales al hilo han terminado, no hay comportamiento indefinidoassert(result =="42");}
[editar]Véase también
| Establece el resultado a un valor específico mientras notifica solamente cuando el hilo termina. (función miembro pública de std::promise) | |
| Ejecuta la función asegurándose de que el resultado esté listo solo una vez que el hilo actual termine. (función miembro pública de std::packaged_task) |
