两个线程需要同步操作时,可以设置一个全局变量,用互斥量保护这个全局变量,通过这个全局变量来同步。
但是这样太浪费CPU,这时可以用休眠方法。
bool flag;
std::mutex m;
void wait_for_flag()
{
std::unique_lock<std::mutex> lk(m);
while(!flag)
{
lk.unlock();
//休眠期间,其他线程可以操作flag
std::this_thread::sleep_for(std::chrono::milliseconds(100));
lk.lock();
}
}
但是很难确定休眠时间的长短,太长或太短都不合理。
在C++库中,可以使用条件变量(condition variable)。条件变量可以和事件或条件结合起来,一个或多个线程等待时间或条件。当事件到达货事件满足后,使用nofify通知等待的线程。
下面看一个例子,生产者号消费者:
#include<iostream>
#include<mutex>
#include<condition_variable>
#include<queue>
#include<thread>
#include<Windows.h>//VS2013调试用的
std::mutex mut;
std::queue<int> q;
std::condition_variable cond;
void data_preparation_thread()
{
while (true)
{
//休眠一下
Sleep(1000);//1s
int data = rand() % 20;
std::lock_guard<std::mutex> lk(mut);
q.push(data);
std::cout << "Preparation Data:" << data << std::endl;
cond.notify_one();//唤醒一个,notify_any()唤醒所有
}
}
void data_processing_thread()
{
while (true)
{
Sleep(2000);//2s
std::unique_lock<std::mutex> lk(mut);
/*
wait先检查lambda表达式,如果满足条件则返回。否则就等待,此时unlock mut然后线程阻塞。
当线程被唤醒,会重新lock mut,并检查lambda表达式。如果lambda不满足,那么unlock mut继续等待。
所以上面要有unique_lock
*/
cond.wait(lk, []{return !q.empty(); });//lambda function,等待的条件[]{return !q.empty(); }
int data = q.front();
q.pop();
lk.unlock();
std::cout << "Processing Data:" << data << std::endl;
}
}
int main()
{
std::thread t1(data_preparation_thread);
std::thread t2(data_processing_thread);
t1.join();
t2.join();
return 0;
}
下面使用条件变量编写一个线程安全的队列
#include<queue>
#include<condition_variable>
#include<mutex>
#include<memory>
template<typename T>
class threadsafe_queue
{
private:
mutable std::mutex mut;//在const函数中使用
std::queue<T> data_queue;
std::condition_variable data_cond;
public:
threadsafe_queue()
{}
threadsafe_queue(threadsafe_queue const& other)
{
std::lock_guard<std::mutex> lk(other.mut);
data_queue = other.data_queue;
}
void push(T new_value)
{
std::lock_guard<std::mutex> lk(mut);
data_queue.push(new_value);
data_cond.notify_one();//如果多个线程等待,可以使用nofity_all()
}
void wait_and_pop(T& value)
{
std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk, [this]{return !data_queue.empty(); });
valuue = data_queue.front();
data_queue.pop();
}
std::shared_ptr<T> wait_and_pop()
{
std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk, [this]{return !data_queue.empty(); });
std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
data_queue.pop();
return res;
}
bool try_pop(T& value)
{
std::lock_guard<std::mutex> lk(mut);
if (data_queue.empty())
return false;
value = data_queue.front();
data_queue.pop();
return true;
}
std::shared_ptr<T> try_pop()
{
std::lock_guard<std::mutex> lk(mut);
if (data_queue.empty())
return std::shared_ptr<T>();
std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
data_queue.pop();
return res;
}
bool empty() const
{
std::lock_guard<std::mutex> lk(mut);
return data_queue.empty();
}
};