c++ boost库--线程同步

1. Mutex对象

#include <boost/thread/mutex.hpp>
#include <boost/thread/shared_mutex.hpp>
boost::mutex                    //支持排他访问的互斥对象。
boost::try_mutex                //等同于 boost::mutex, 用来兼容以前的版本。
boost::timed_mutex              //支持超时的排他互斥对象。
boost::recursive_mutex          //支持递归加锁的排他互斥对象。
boost::recursive_timed_mutex    //支持递归和超时的排他互斥对象。
boost::shared_mutex             //可共享的互斥对象。

1. Lock对象

#include <boost/thread/locks.hpp>
boost::lock_guard           //是最简单的锁，构造时对传入的mutex加锁，析构时解锁。
boost::unique_lock          /*可以推迟lock(构造时指定defer_lock_t参数), 通过调用加锁函数显示lock:ock(), try_lock(),time_lock(),可以调用unlock()解锁，或unique_lock对象析构时自动解锁。*/
boost::shared_lock          //类似于unique_lock,不同的是获得的是共享访问权限（前面获得的都是排他权限）。
boost::upgrade_lock         //获得可升级的访问权限。
boost::upgrade_to_unique_lock   //提升upgrade_lock权限，析构时upgrade_lock权限降级。
explicit upgrade_to_unique_lock(upgrade_lock<Lockable>& m_);

1. Lock函数（全局函数）

lock(Lockable1,Lockable2,...)
lock(begin,end) // 将lockable对象(mutex)放到一个容器中
try_lock(Lockable1,Lockable2,...)
try_lock(begin,end)
用来对多个顺序不确定的mutex同时加锁，以避免死锁。

1. 条件变量 condition_variable
   提供机制实现一个线程为某个条件等待来自另一个线程的通知。

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.
boost::condition_variable
boost::condition_variable_any

通常的用法示例如下：

互斥锁 mutex

支持排他访问的互斥对象，当多个线程对同一临界资源进行访问时候，只有获得锁的线程可以获得临界资源，其他等待资源的线程都会被阻塞。例如一个卫生间里面只有一个坑，有是个人抢着去蹬坑，每次一个人进去后，其他人就不能进去。
示例

#include "stdafx.h"
#include <iostream>
#include <boost/signal.hpp>
#include <boost/bind.hpp>
#include <boost/thread.hpp>

using namespace std;
//互斥锁的使用
boost::mutex g_mutex;

void wait(int second)
{
    boost::this_thread::sleep(boost::posix_time::microsec(second));
}
void ThreadFun()
{

    boost::lock_guard<boost::mutex> lock(g_mutex);
    cout << boost::this_thread::get_id() << "：开始蹬坑" << endl;
    wait(500);
    cout << boost::this_thread::get_id() << "：结束蹬坑\n\n" << endl;

}

int main()
{
    //10个人在厕所外面排队等着蹬坑
    for (int i = 0; i < 10; i++)
    {
        boost::thread t(ThreadFun);
    }
    getchar();
    return 0;
}

不加锁的情况下其输出结果

31804b8c：开始蹬坑
3c28：开始蹬坑
2308：开始蹬坑
4c08：开始蹬坑
3578：开始蹬坑
17460：开始蹬坑
3c64：开始蹬坑
2118：开始蹬坑
：开始蹬坑
3f04：开始蹬坑
3f04：结束蹬坑


17460：结束蹬坑


3c64：结束蹬坑


2118：结束蹬坑


3180：结束蹬坑


15400：结束蹬坑


4c08：结束蹬坑


4b8c：结束蹬坑


3578：结束蹬坑


2308：结束蹬坑

加锁情况下

26b0：开始蹬坑
26b0：结束蹬坑


4378：开始蹬坑
4378：结束蹬坑


3c40：开始蹬坑
3c40：结束蹬坑


e10：开始蹬坑
e10：结束蹬坑


3960：开始蹬坑
3960：结束蹬坑


1420：开始蹬坑
1420：结束蹬坑


41e4：开始蹬坑
41e4：结束蹬坑


476c：开始蹬坑
476c：结束蹬坑


1184：开始蹬坑
1184：结束蹬坑


282c：开始蹬坑
282c：结束蹬坑

不加锁的情况下所有人一股脑冲进测试，至于怎么解决问题的不想而知，而加锁的情况下，只有等一个人用完厕所之后，其余人才能进去。

读写锁 shared_mutex

shared_mutex即读写锁，不同与我们常用的独占式锁mutex，shared_mutex是共享与独占共存的锁，实现了读写锁的机制，即多个读线程一个写线程，通常用于对于一个共享区域的读操作比较频繁，而写操作比较少的情况。

读写锁比起mutex具有更高的适用性，具有更高的并行性，可以有多个线程同时占用读模式的读写锁，但是只能有一个线程占用写模式的读写锁，读写锁的基本规则可以总结为“写优先，读共享，交叉互斥“，具体表现为读写锁的三种状态：
（1）当读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞。（交叉互斥）
（2）当读写锁在读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权，但是以写模式对它进行加锁的线程将会被阻塞。（读共享，交叉互斥）
（3）当读写锁在读模式的锁状态时，如果有另外的线程试图以写模式加锁，读写锁通常会阻塞随后的读模式锁的请求，这样可以避免读模式锁长期占用，而等待的写模式锁请求则长期阻塞。（写优先）

注：其实在读者-写者问题中，有读者优先和写者优先两种模式，只是在boost中的shared_mutex默认的实现是写者优先，这其实也是有道理的，因为在我们总是希望读到的数据是最新的，这就得保证写者优先。

下面通过一个 boost::shared_mutex的应用实例来反应其锁机制，该例子中我们建立两个读者线程，两个写者线程，程序的实际运行结果很直接的反应了shared_mutex应用情况。

#include <boost\ref.hpp>  
#include <boost\thread\thread.hpp>  
#include <string>  
using namespace boost;  

int g_num = 10;      //全局变量，写者改变该全局变量，读者读该全局变量  
shared_mutex s_mu;   //全局shared_mutex对象  

//写线程  
void read_(std::string &str)  
{  
    const char* c = str.c_str();  
    while (1)  
    {  
        {  
            shared_lock<shared_mutex> m(s_mu);    //读锁定，shared_lock  
            printf("线程%s进入临界区，global_num = %d\n", c, g_num);  
            boost::this_thread::sleep(boost::posix_time::seconds(1));    //sleep 1秒，给足够的时间看其他线程是否能进入临界区  
            printf("线程%s离开临界区...\n", c);  
        }  
        boost::this_thread::sleep(boost::posix_time::seconds(1));   //读线程离开后再slpp 1秒（改变这个值可以看到不一样的效果）  
    }  
}  

//读线程  
void writer_(std::string &str)  
{  
    const char* c = str.c_str();  
    while (1)  
    {  
        {  
            unique_lock<shared_mutex> m(s_mu);    //写锁定，unique_lock  
            ++g_num;  
            printf("线程%s进入临界区，global_num = %d\n", c, g_num);  
            boost::this_thread::sleep(boost::posix_time::seconds(1));    //sleep 1秒，让其他线程有时间进入临界区  
            printf("线程%s离开临界区...\n", c);  
        }  
        boost::this_thread::sleep(boost::posix_time::seconds(2));   //写线程离开后再slpp 2秒，这里比读线程多一秒是因为如果这里也是1秒，那两个写线程一起请求锁时会让读线程饥饿  
    }  
}  
int main()  
{  
    std::string r1 = "read_1";  
    std::string r2 = "read_2";  
    std::string w1 = "writer_1";  
    std::string w2 = "writer_2";  

    boost::thread_group tg;  
    tg.create_thread(bind(read_, boost::ref(r1)));   //两个读者  
    tg.create_thread(bind(read_, boost::ref(r2)));  

    tg.create_thread(bind(writer_, boost::ref(w1)));  //两个写者  
    tg.create_thread(bind(writer_, boost::ref(w2)));  
    tg.join_all();  

    return 0;  
}  

定时锁 timer_mutex

同样是上厕所，现在每个人规定了，只能使用三分钟的厕所，如果超过这个时间，那么我就踹门进去，把你给拉出来，强制你出来。
示例：

#include "stdafx.h"
#include <iostream>
#include <boost/signal.hpp>
#include <boost/bind.hpp>
#include <boost/thread.hpp>

using namespace std;
//互斥锁的使用
boost::timed_mutex g_mutex;

void wait(int second)
{
    boost::this_thread::sleep(boost::posix_time::seconds(second));
}
void ThreadFun()
{

    boost::unique_lock<boost::timed_mutex> lock(g_mutex,boost::try_to_lock);
    while (!lock.owns_lock())
    {
        lock.timed_lock(boost::get_system_time() + boost::posix_time::seconds(3));
    }

    cout << boost::this_thread::get_id() << "：开始蹬坑" << endl;
    wait(2);
    cout << boost::this_thread::get_id() << "：结束蹬坑\n\n" << endl;

}

int main()
{
    //10个人在厕所外面排队等着蹬坑
    for (int i = 0; i < 10; i++)
    {
        boost::thread t(ThreadFun);
    }
    getchar();
    return 0;
}