Wie kann ein Boost-Thread, der von einer C ++ - Klasse verwaltet wird, am besten beendet werden, wenn ein Objekt dieser Klasse zerstört werden soll? Ich habe eine Klasse, die einen Thread zum Bauen erstellt und startet und eine Öffentlichkeit zur Verfügung stelltWake() Methode, die den Thread weckt, wenn es Zeit ist, etwas zu arbeiten. DasWake() Methode verwendet einen Boost-Mutex und eine Boost-Bedingungsvariable, um den Thread zu signalisieren; Die Thread-Prozedur wartet auf die Bedingungsvariable, erledigt dann die Arbeit und kehrt zum Warten zurück.

Im Moment habe ich diesen Thread im Destruktor der Klasse heruntergefahren und eine boolesche Member-Variable als "running" -Flag verwendet. Ich lösche das Flag und rufe dann notify_one () für die Bedingungsvariable auf. Die Thread-Prozedur wacht dann auf, stellt fest, dass "running" falsch ist, und kehrt zurück. Hier ist der Code:

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
    }
}

Ist es eine gute Idee, den Thread im Destruktor der Klasse wie folgt herunterzufahren, oder sollte ich eine öffentliche Methode bereitstellen, mit der der Benutzer dies tun kann, bevor das Objekt zerstört wird, wenn mehr Potenzial für die Fehlerbehandlung und / oder die gewaltsame Zerstörung des Threads besteht Wenn die Thread-Prozedur nicht sauber oder rechtzeitig zurückkehrt?

Das Aufräumen des Chaos meines Objekts in seinem Destruktor ist ansprechend, da der Benutzer weniger auf Details achten muss (Abstraktion, Hurra!), Aber es scheint mir, dass ich nur dann Dinge in einem Destruktor tun sollte, wenn ich garantieren kann, die volle Verantwortung dafür zu übernehmen Bereinigen von Dingen erfolgreich und gründlich, und es besteht eine geringe Chance, dass Code außerhalb der Klasse eines Tages wissen muss, ob der Thread ordnungsgemäß heruntergefahren wurde oder nicht.

Ist der von mir verwendete Mechanismus - Schreiben in eine Mitgliedsvariable in einem Objekt auf dem Stapel eines Threads und Lesen dieser Variablen in einem anderen Thread - sicher und vernünftig?