Obtener un std :: hilo para separar y terminar a sí mismo

Question

Actualmente estoy desarrollando un grupo de subprocesos básicos. Utilicé C++ 11's std::thread, junto con std::condition_variable y std::unique_lock. Parece que funciona, y ahora me gustaría poder matar algunos hilos cuando muchos de ellos están inactivos. Por ahora, sus trabajos se dan a través de std::queue de boost::function s. Estaba pensando en agregar un montón de boost::function s vacías para que los hilos sepan que tienen que salir de su ciclo. bucle de la rosca es de esta manera:

void ThreadPool::threadLoop() 
{ 
    boost::function<void()>  oThreadTask; 
    std::unique_lock<std::mutex> oLock(m_oTaskMutex); 

    while (1) 
    { 
     // m_oCV is a static std::condition_variable 
     // m_oTaskQueue is a static std::queue< boost::function<void()> > 
     m_oCV.wait(oLock, [](){ return m_oTaskQueue.size(); }); 
     oThreadTask = m_oTaskQueue.front(); 
     m_oTaskQueue.pop(); 
     m_oTaskMutex.unlock(); 
     if (oThreadTask.empty()) 
     break ; 
     oThreadTask(); 
    } 
    // ?? 
} 

La cosa es que no estoy seguro de cómo separar correctamente el hilo una vez que salía del bucle. ¿Sería limpia para buscar el identificador del hilo (no tengo acceso a una std::list<std::thread*>, y se puede comparar con sus identificadores de std::this_thread::get_id()), y es seguro para llamar detach() desde el mismo hilo, o incluso join()?

Answer 1

Sí, si usted tiene todos los objetos almacenados hilo, se puede encontrar la que thread::id es igual a this_thread::get_id(), y se le puede llamar detach() en él, y destruir el objeto hilo después de eso (el estándar de C++ 11 no lo hace prevenir eso, y creo que se basa en la práctica común). Asegúrese de que ningún otro subproceso de ejecución tenga acceso a la instancia de std::thread que se destruye.

Pero no se puede llamar join() Del mismo hilo: un intento de un hilo que se unan a sí resultaría en un punto muerto, y C++ 11 implementaciones deben reconocer que system_error y tirar con la condición de error de resource_deadlock_would_occur.

Como alternativa, puede dejar un mensaje (por ejemplo a través de un std :: variables atómica) para el hilo principal de que el hilo asociado a un caso particular de std::thread está a punto de completar su ejecución, y dejar que el hilo principal se unen con este instancia en un punto posterior.