C++11中线程及信号量与条件变量
线程
互斥量与条件变量
C++11对线程支持有很大的提升（参见 C++11线程thread与任务async），可以方便地处理线程。同时提供了互斥量与条件变量，可方便处理类似消费者-生产者问题。
线程
C++11中对线程提供了良好的支持，通过thread即可直接创建线程，同时通过promise，future，packaged_task以及async提供了对线程控制的能力。
thread
通过thread定义一个线程变量，线程就会自动开始执行；变量离开作用域时，要join（等待线程结束）或detach（分离线程，线程在后台独立运行）线程，否则会出错。
使用thread启动线程时，可方便地传递参数（类成员函数的this指针也可以传递）；但是参数的默认传递方式是值传递，若要以引用方式则需要使用std::ref或std::cref来封装参数。
#includes
#includes
void multiNumber(int &nNum){
// ...
nNum *= 2;
}
void multiPtr(int *pNum){
*pNum *= 2;
}
class HelloThread{
public:
void Say(const char *strInfo){
cout<<"Hello "< async
async除能自动创建线程外，还会返回future，以便对线程进行控制（如获取返回值，捕获异常等）。
创建async时，还可以确定线程启动时机：
-
launch::async：立即开始执行 -
launch::deferred：等待retFuture.get()时才开始执行
int getMulti(int nNum){
// ...
return nNum * 2;
}
void TestThread(){
auto getNum = std::async(std::launch::async, getMulti, 2);
auto getRet = getNum.get();
cout<sleep
通过slee_for可以方便地进行休眠(yield可让出当前时间片），但是其使用的时间是chrono中的，我们可以重定义一个方便的接口。
class XThread{
public:
static void Sleep(int nSec, int nMillSec){
std::chrono::seconds secs(nSec);
std::chrono::milliseconds mills(nMillSec);
std::this_thread::sleep_for(secs+mills);
}
}
future
future除用作获取线程返回值外，还可作为同步用（一般从promise中获取；在没有设定前，一直是无信号状态）。future不可复制与共享，若要共享则需要使用share_future（类似shared_ptr，通过计数方式实现）。
void FutureWait(std::shared_future &ft){
ft.wait();
cout<<"Wait: "< ft){
ft.get(); // 一直等待，直到设定
cout<<"Wait: "< &pro){ // 需要修改，必须为引用（本身也不运行复制操作）
// ... sleep a while
cout<<"Future set"< pro;
auto ft = pro.get_future();
auto sf = ft.share();
thread thrWait(FutureWait, std::ref(sf));
thread thrGet(FutureGet, sf);
thread thrSet(FutureSet, pro);
thrSet.detach();
thrWait.join();
thrGet.join();
}
互斥量与条件变量
条件变量，能用于阻塞一个/多个线程，直至另一线程修改共享变量（条件）并通知。为了防止race-condition，条件变量总是和互斥锁变量mutex结合在一起使用。
-
执行wait、wait_for或wait_until时，需要持有锁
-
执行notify_one或notify_all时，不需要有锁
互斥量mutex
互斥量mutex可以通过lock_guard或unique_lock方便地进行管理。
class Products{
public:
void Produce(int nId){
std::lock_guard lker(m_mtx); // 只要离开当前函数，就会释放锁
// ...
}
private:
std::mutex m_mtx;
}
事件Event
通过mutex与condition_variable可以方便地构造事件，注意cv.wait时要使用unique_lock而非lock_guard（因wait时会解除锁定，当获取信号后再锁定）。
#include
#include
#include
class XEvent{ // No signal when init
public:
void Wait(){
std::unique_lock lker(m_mtx);
m_cv.wait(lker);
}
bool Wait(int nSec, int nMillSec){
std::unique_lock lker(m_mtx);
std::chrono::seconds secs(nSec);
std::chrono::milliseconds mills(nMillSec);
auto ret = m_cv.wait_for(lker, secs+mills);
return (ret != std::cv_status::timeout);
}
void NotifyOne(){
m_cv.notify_one();
}
void NotifyAll(){
m_cv.notify_all();
}
private:
std::mutex m_mtx;
std::condition_variable m_cv;
}
信号量semaphore
在Event基础上，只需再增加一个计数变量，即可方便地实现信号量。
class XSemaphore{
public:
XSemaphore(int nCount=0):m_count(nCount){}
void Wait(){
std::unique_lock lker(m_mtx);
m_cv.wait(lker, [this](){return m_count>0;});
--m_count;
}
bool Signal(){
{
std::unique_lock lker(m_mtx);
++m_count;
} // 通知前解锁，避免获取信号后因得不到锁重新进入等待
m_cv.notify_one();
}
private:
int m_count;
std::mutex m_mtx;
std::condition_variable m_cv;
}
读写锁RWLocker
读写锁在多读少写的情形下，非常有用；通过允许读者间可共享获取锁，来提高并发；同时通过互斥写锁，保证数据同步。通过两个条件变量与一个互斥量，可以很好地模拟出读写锁（写者优先锁：有写请求时，优先满足）。
class XWRLocker{
public:
void AcqurieRead(){
std::unique_lock lker(m_mtxCount);
m_cvRead.wait(lker, [this](){return m_writeCount==0;}); // 只要没有写请求，读请求就可被满足
++m_readCount;
}
void ReleaseRead(){
bool bNotify = false;
{
std::unique_lock lker(m_mtxCount);
if(--m_readCount==0 && m_writeCount>0){
bNotify=true;
}
}
if(bNotify) // 通知前解锁，避免获取信号后因得不到锁重新切换线程
m_cvWrite.notify_one();
}
void AcqurieWrite(){
std::unique_lock lker(m_mtxCount);
++m_writeCount; // 获取锁前，先声明写请求
m_cvWrite.wait(lker, [this](){return m_readCount==0 && !m_isWriting;}); // 当前没有读者与写者时，请求才会满足
m_isWriting=true;
}
void ReleaseWrite(){
auto nCount=0;
{
std::unique_lock lker(m_mtxCount);
m_isWriting=false;
nCount=--m_writeCount;
}
if(nCount==0){ // 没有写请求，直接触发可读信号
m_cvRead.notify_all();
}
else{
m_cvWrite.notify_one();
}
}
private:
bool m_isWriting{false};
unsigned m_readCount{0};
unsigned m_writeCount{0};
std::mutex m_mtxCount;
std::condition_variable m_cvRead;
std::condition_variable m_cvWrite;
}