如何“停止”正在等待条件变量的分离线程？

Question

I detach a thread from Class B :

t1 = std::thread(&Class::method, this);
t1.detach();

which as part of it's normal operation waits on a condition variable:

cv.wait(lock);

However, when I close my B application the detached thread remains. How do I stop/clean-up this thread when B::~B() is called?

Answer 1

Try this snippet: Set bool member variable discard_ to true to avoid execution of your scheduled process execution:

std::thread([&](){
   std::lock_guard<std::mutex> lock(mutex_);
   cv.wait(lock,[](){ return normal_predicate_here || discard_ ;});
   if(discard_) return;
   // execute scheduled process
}).detach();

Answer 2

Make the other thread cooperate for termination. Non-detached thread makes it easier to terminate cleanly, so that you do not destroy the state accessed by the other thread prematurely:

struct OtherThread {
    std::mutex m_;
    std::condition_variable c_;
    bool stop_ = false;
    std::thread t_;

    void thread_function() {
        for(;;) {
            std::unique_lock<std::mutex> l(m_);
            while(!stop_ /* || a-message-received */)
                c_.wait(l);
            if(stop_)
                return;

            // Process a message.
            // ...
            // Continue waiting for messages or stop.
        }
    }

    ~OtherThread() {
        this->stop();
    }

    void stop() {
        {
            std::unique_lock<std::mutex> l(m_);
            if(stop_)
                return;
            stop_ = true;
        }
        c_.notify_one();
        t_.join(); // Wait till the thread exited, so that this object can be destroyed.
    }
};