boost线程暂停和恢复

注：我的boost 是1.75

 

The classes condition_variable and condition_variable_any provide a mechanism for one thread to wait for notification from another thread that a particular condition has become true. The general usage pattern is that one thread locks a mutex and then calls wait on an instance of condition_variable or condition_variable_any. When the thread is woken from the wait, then it checks to see if the appropriate condition is now true, and continues if so. If the condition is not true, then the thread then calls wait again to resume waiting. In the simplest case, this condition is just a boolean variable:

boost::condition_variable cond;
boost::mutex mut;
bool data_ready;

void process_data();

void wait_for_data_to_process()
{
    boost::unique_lock<boost::mutex> lock(mut);
    while(!data_ready)
    {
        cond.wait(lock);
    }
    process_data();
}

Notice that the lock is passed to wait: wait will atomically add the thread to the set of threads waiting on the condition variable, and unlock the mutex. When the thread is woken, the mutex will be locked again before the call to wait returns. This allows other threads to acquire the mutex in order to update the shared data, and ensures that the data associated with the condition is correctly synchronized.（请注意，锁已传递给wait：wait将自动将线程添加到等待条件变量的线程集中，并解锁互斥锁。 唤醒线程后，互斥锁将在等待调用返回之前再次被锁定。 这允许其他线程获取互斥体以更新共享数据，并确保与条件关联的数据正确同步。）

In the mean time, another thread sets the condition to true, and then calls either notify_one or notify_all on the condition variable to wake one waiting thread or all the waiting threads respectively.（同时，另一个线程将条件设置为true，然后在条件变量上调用notify_one或notify_all分别唤醒一个等待线程或所有等待线程。）

void retrieve_data();
void prepare_data();

void prepare_data_for_processing()
{
    retrieve_data();
    prepare_data();
    {
        boost::lock_guard<boost::mutex> lock(mut);
        data_ready=true;
    }
    cond.notify_one();
}

Note that the same mutex is locked before the shared data is updated, but that the mutex does not have to be locked across the call to notify_one.（请注意，在更新共享数据之前，该互斥锁已被锁定，但是在对notify_one的调用中不必锁定该互斥锁。）

This example uses an object of type condition_variable, but would work just as well with an object of type condition_variable_any: condition_variable_any is more general, and will work with any kind of lock or mutex, whereas condition_variable requires that the lock passed to wait is an instance of boost::unique_lock<boost::mutex>. This enables condition_variable to make optimizations in some cases, based on the knowledge of the mutex type; condition_variable_any typically has a more complex implementation than condition_variable.（此示例使用了condition_variable类型的对象，但与condition_variable_any类型的对象也可以正常工作：condition_variable_any更通用，并且可以与任何类型的锁或互斥锁一起使用，而condition_variable要求传递给wait的锁是一个实例 的：boost :: unique_lock <boost :: mutex>。 这可以使condition_variable在某些情况下根据互斥量类型的知识进行优化; condition_variable_any通常比condition_variable具有更复杂的实现。）

 

 

这里需要提醒：如果是多个线程，请使用不同的mutex