¿Cuál es la mejor manera de cerrar un subproceso Boost administrado por una clase de C ++ cuando llega el momento de destruir un objeto de esa clase? Tengo una clase que crea e inicia un subproceso en la construcción y proporciona un públicoWake() método que despierta el hilo cuando es hora de hacer algún trabajo. losWake() el método utiliza un mutex Boost y una variable de condición Boost para señalar el hilo; el procedimiento de hilo espera en la variable de condición, luego hace el trabajo y vuelve a esperar.

En este momento, cierro este hilo en el destructor de la clase, usando una variable miembro booleana como un indicador "en ejecución"; Borro la bandera y luego llamo a notificar_one () en la variable de condición. El procedimiento de subproceso se activa, advierte que "en ejecución" es falso y se devuelve. Aquí está el código:

class Worker
{
public:
    Worker();
    ~Worker();
    void Wake();
private:
    Worker(Worker const& rhs);             // prevent copying
    Worker& operator=(Worker const& rhs);  // prevent assignment
    void ThreadProc();
    bool m_Running;
    boost::mutex               m_Mutex;
    boost::condition_variable  m_Condition;
    boost::scoped_ptr<boost::thread> m_pThread;
};

Worker::Worker()
    : m_Running(true)
    , m_Mutex()
    , m_Condition()
    , m_pThread()
{
    m_pThread.reset(new boost::thread(boost::bind(&Worker::ThreadProc, this)));
}

Worker::~Worker()
{
    m_Running = false;
    m_Condition.notify_one();
    m_pThread->join();
}

void Worker::Wake()
{
    boost::lock_guard<boost::mutex> lock(m_Mutex);
    m_Condition.notify_one();
}

void Worker::ThreadProc()
{
    for (;;)
    {
        boost::unique_lock<boost::mutex> lock(m_Mutex);
        m_Condition.wait(lock);
        if (! m_Running) break;
        // do some work here
    }
}

¿Es una buena idea cerrar el hilo en el destructor de la clase de esta manera, o debo proporcionar un método público que permita al usuario hacer esto antes de que se destruya el objeto, cuando existe un mayor potencial para el manejo de errores y / o la destrucción del hilo por la fuerza? ¿Si el procedimiento del hilo no se devuelve limpiamente o en el momento adecuado?

Limpiar el desorden de mi objeto en su destructor es atractivo, ya que requerirá menos atención a los detalles por parte del usuario (¡abstracción, hurra!) Pero me parece que solo debo hacer cosas en un destructor si puedo garantizar que asumo toda la responsabilidad de limpiando las cosas con éxito y a fondo, y hay una pequeña posibilidad de que un código fuera de la clase pueda necesitar algún día saber si el hilo se cerró limpiamente o no.

Además, ¿el mecanismo que estoy usando, escribir en una variable miembro en un objeto en la pila de un hilo y leer esa variable en otro hilo, es seguro y sensato?