使用boost::condition实现线程的暂停/启动

在项目中需要实现pause/resume功能，用boost::condition实现大致如下：

class Geo
{
    ...
    bool m_bPauseFlag;
    boost::condition m_pause_cond;
    boost::mutex m_pause_mutex;
    boost::mutex m_pauseflag_mutex;

}

实现:

void Geor::pause()
{
    LOG_DEBUG("GeoCrawler::pause()!");

    lock l(m_pauseflag_mutex);
    m_bPauseFlag = true;
}

void Geo::resume()
{
    LOG_DEBUG("GeoCrawler::resume()!");

    lock l(m_pauseflag_mutex);
    m_bPauseFlag = false;
    m_pause_cond.notify_all();
}

void Geo::WorkThread()
{
    while(1)
    {
         ...
         
        if(m_bPauseFlag == true)
        {
            LOG_DEBUG("WAITING...");
            m_pause_cond.wait(m_pause_mutex);
            LOG_DEBUG("CONTINUING...");
        }
    }
}

 

需要注意的是：

m_pause_cond.wait的含义是等待信号并对m_pause_mutex加锁，调用resume()进行unblock之后,线程从wait处继续运行，但是：此时m_pause_mutex并未被解锁，如果在其他地方尝试对m_pause_mutex加锁的话，会一直block的！因此我这里使用了两个mutex，m_pause_mutex是用来传递给m_pause_cond.wait的，m_pauseflag_mutex是用来修改暂停标志的。刚开始我把他们弄混淆了，只是用了一个mutex，最后线程挂住了。

--------------------------------

boost文档说明：

void wait(boost::unique_lock<boost::mutex>& lock

Precondition:
lock is locked by the current thread, and either no other thread is currently waiting on *this, or the execution of the mutex() member function on the lock objects supplied in the calls to wait or timed_wait in all the threads currently waiting on *this would return the same value as lock->mutex() for this call to wait. 

Effects:
Atomically call lock.unlock() and blocks the current thread. The thread will unblock when notified by a call to this->notify_one() or this->notify_all(), or spuriously. When the thread is unblocked (for whatever reason), the lock is reacquired by invoking lock.lock() before the call to wait returns. The lock is also reacquired by invoking lock.lock() if the function exits with an exception. 

Postcondition:
lock is locked by the current thread. 

Throws:
boost::thread_resource_error if an error occurs. boost::thread_interrupted if the wait was interrupted by a call to interrupt() on the boost::thread object associated with the current thread of execution.