（十一）boost库之多线程间通信

1、互斥锁

在编程中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。每个对象都对应于一个可称为" 互斥锁" 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。

#include <iostream>
#include <boost/thread.hpp>
using namespace std;
int g_num = 0;
boost::mutex mu;  //定义互斥锁对象
int Func(int nCount)
{
    for (int i = 0; i < nCount; i++)
    {
        boost::mutex::scoped_lock lock(mu);  //对共享数据进行操作，需加锁
        g_num++;
        cout << __FUNCTION__ << ": " << g_num << endl;
    }
    return g_num;
}
int _tmain(int argc, _TCHAR* argv[])
{
    boost::thread th1(Func, 100);
    boost::thread th2(Func, 200);
    th1.join();
    th2.join();
    return 0;
}

2、读写锁

boost::shared_mutex rw_mu;   //定义读写锁
int Write(int nCount)
{
    for (int i = 0; i < nCount; i++)
    {
        boost::unique_lock<boost::shared_mutex> lock(rw_mu);   //加唯一锁
        g_num++;
        cout << __FUNCTION__ << ": " << g_num << endl;
    }
    return g_num;
}
void Read(int nCount)
{
    for (int i = 0; i < nCount; i++)
    {
        boost::shared_lock<boost::shared_mutex> lock(rw_mu);  //加共享锁
        cout << __FUNCTION__ << ": " << g_num << endl;
    }
}
int _tmain(int argc, _TCHAR* argv[])
{
    boost::thread th1(Write, 100);
    boost::thread th2(Read, 100);
    boost::thread th3(Read, 100);
    th1.join();
    th2.join();
    th3.join();
    return 0;
}

3、条件量

条件量相对于互斥锁和读写锁来说，并不是那么好理解，简单点说，条件变量就是用于等待某个条件被触发，但为什么要配合锁使用呢，因为我们的等待不能是干等，那样可能会出现死锁。

如线程A负责添加任务到队列，线程B负责处理队列中的任务，队列就是两个线程的共享资源，使用前必须加锁，但如果B线程加锁后，发现队列中没有数据，然后等待，A线程准备添加任务时，发现

锁已经被占用，于是就没法添加任务，就形成了死锁。但如果我等待时，释放锁资源，A线程就能正常添加任务，完成后通知B线程可以处理了，那么整个流程就畅通无阻了，这就是条件量的作用。

#include <queue>
boost::mutex g_ioMutex;    //输出控制锁
template<typename T>
class CMsgQueue
{
public:
    CMsgQueue(size_t n):m_nCapacity(n)
    {
    }
    void Push(const T& val)
    {
        {
            boost::mutex::scoped_lock lock(m_mu);              //加锁
            while(m_val.size() == m_nCapacity)                 //队列已满
            {
                {
                    boost::mutex::scoped_lock lock(g_ioMutex);
                    cout << "队列已满" << endl;
                }
                m_condPush.wait(m_mu);                         //等待，将暂时的解锁
            }
             m_val.push(val);                                   //添加数据到队列
        }
        m_condPop.notify_one();                                 //通知读线程
    }
    void Pop(T& val)
    {
        {
            boost::mutex::scoped_lock lock(m_mu);               //加锁
            while(m_val.size() == 0)                            //队列为空
            {
                {
                    boost::mutex::scoped_lock lock(g_ioMutex);
                    cout << "队列为空" << endl;
                }
                m_condPop.wait(m_mu);                           //等待可读，
            }
            val = m_val.front();                                 //读取数据
            m_val.pop();
        }
        m_condPush.notify_one();                                 //通知写线程
    }
private:
    queue<T> m_val;                            //队列
    int m_nCapacity;                           //队列最大容量
    boost::condition_variable_any m_condPush;  //写入条件量
    boost::condition_variable_any m_condPop;   //读取条件量
    boost::mutex m_mu;                         //互斥锁
};
CMsgQueue<int> g_numQueue(10);
void FuncA(int nCount)
{
    for (int i = 0; i < nCount; i++)
    {
        {
            boost::mutex::scoped_lock lock(g_ioMutex);
            cout << __FUNCTION__ << " Put " << i << endl;
        }    
        g_numQueue.Push(i);
        
    }
}
void FuncB(int nCount)
{
    for (int i = 0; i < nCount; i++)
    {        
        int val;
        g_numQueue.Pop(val);
        boost::mutex::scoped_lock lock(g_ioMutex);
        cout << __FUNCTION__ << " Get " << val << endl;
    }
}
int _tmain(int argc, _TCHAR* argv[])
{
    boost::thread th1(FuncA, 50);
    boost::thread th2(FuncB, 20);
    boost::thread th3(FuncB, 30);
    th1.join();
    th2.join();
    th3.join();
    return 0;
}

在多线程程序中，锁的使用需要特别的小心，比如，我们将FuncA稍微改一下：

void FuncA(int nCount)
{
    for (int i = 0; i < nCount; i++)
    {    
        boost::mutex::scoped_lock lock(g_ioMutex);
        cout << __FUNCTION__ << " Put " << i << endl;        
        g_numQueue.Push(i);    
    }
}

如果改成这样，程序将陷入死锁，我们轻轻松松就制造了一个死锁案例。

A线程占用了输入锁，那么B线程的Pop函数将一直在获取输入锁的地方等待，但它已经占用了m_mu锁，A线程也就只能一直在等待m_mu，故形成了死锁。