boost--线程同步

 1、互斥锁（互斥量）

  mutex是独占式的互斥锁。timed_mutex增加了超时功能。

  成员函数：lock()用于锁定，try_lock()为非阻塞版本的锁定，unlock()用于解锁。timed_lock()只属于timed_mutex，它可以等待一定的时间，等待的时间可以是一个时间段，也可以是指定的时间。

  使用方法：使用mutex必须配合try-catch块以保证解锁互斥量，eg：

#include "boost\thread.hpp"

int main()
{
    boost::mutex mu;
    try
    {
        mu.lock();
        cout << "Need to be protected" << endl; //io流是个共享资源，多线程内使用的话需要同步
        mu.unlock();
    }
    catch (...)
    {
        mu.unlock();
    }

    return 0;
}

View Code

  mutex还提供了一系列的RAII型的互斥锁，用于取消麻烦的try-catch块，它会在构造的时候锁定互斥量，析构时自动解锁，eg：

#include "boost\thread.hpp"

int main()
{
    boost::mutex mu;
    boost::mutex::scoped_lock lock(mu);
    cout << "Need to be protected" << endl; //io流是个共享资源，多线程内使用的话需要同步

    return 0;
}

View Code

  使用实例：以下定义了一个支持原子前++的计数器atom_increase：

#include "boost\thread.hpp"

template<typename T>
class atom_increase
{
public:
    atom_increase(T x = 0): n(x){} //转换构造函数，实现T类型到atom_increase类型的隐式转换

    T operator++() //重载前++运算符
    {
        boost::mutex::scoped_lock lock(mu);
        return ++n;
    }

    operator T() { return n; } //类型转换函数，实现atom_increase类型到T类型的隐式转换

private:
    T n;
    boost::mutex mu;
};

int main()
{    
    atom_increase<int> n = 0; //隐式转换：int -> atom_increase
    ++n; //原子前++
    int i = 5 + n; //隐式转换：atom_increase ->int

    return 0;
}

View Code

2、递归锁

  recursive_mutex是递归锁，可以多次锁定，相应的也要多次解锁。recursive_timed_mutex增加了超时功能。递归锁的使用接口跟互斥锁基本相同。

3、读写锁

  shared_mutex是读写锁，提供了multiple-reader / single-writer功能。读取锁定时我们使用shared_lock<shared_mutex>对象，写入锁定时我们使用unique_lock<shared_mutex>对象：

    boost::shared_mutex rw_mu;

    //read thread
    {
        boost::shared_lock<boost::shared_mutex> sl(rw_mu); //读锁定
        //......
    }
    
    //write thread
    {
        boost::unique_lock<boost::shared_mutex> ul(rw_mu); //写锁定
        //......
    }

View Code

 4、条件变量

  condition_variable_any是条件变量，它用来在一个线程中等待某个事件的发生（满足某个条件），另一个线程会使条件成立。条件变量需要与一个互斥量配合使用。condition_variable_any::wait()用来等待条件满足，wait_for()用来等待条件满足直到超时，wait_until()用来等待条件满足直到指定的时间， condition_variable_any::notify_one() / notify_all()用来在条件满足的时候通知条件变量。

  boost中的条件变量的使用方法与posix或windows下条件变量使用方法基本一致：

#include "boost\thread.hpp"

boost::condition_variable_any g_cd;
boost::mutex g_mu;
bool g_bConditionFlag = false;

void Thread1Proc()
{
    boost::mutex::scoped_lock lock(g_mu);
    while (!g_bConditionFlag)
    {
        boost::this_thread::sleep(boost::posix_time::seconds(1));
        g_cd.wait(g_mu);
    }

    printf("thread1 exit\n");
}

int main()
{
    boost::thread t(Thread1Proc);
    t.detach();
    boost::this_thread::sleep(boost::posix_time::milliseconds(100));

    g_mu.lock();
    g_bConditionFlag = true;
    g_cd.notify_one();
    g_mu.unlock();

    printf("here\n");
    getchar();

    return 0;
}

View Code

 5、barrier

  barrier称为护栏，它可以用来设置线程执行到barrier时必须等待，直到所有线程都达到这个点时才继续执行。

 6、C++11中的线程操作

  c++11也提供了创建线程和线程同步的方法，c++11里的mutex，与boost里的mutex用法类似：

#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::lock

std::mutex foo, bar;

void task_a()
{
    // foo.lock(); 
    // bar.lock();
    std::lock(foo, bar);
    std::cout << "task a\n";

    foo.unlock();
    bar.unlock();
}

void task_b()
{
    // bar.lock(); 
    // foo.lock();
    std::lock(bar, foo);
    std::cout << "task b\n";
    bar.unlock();
    foo.unlock();
}

int main()
{
    std::thread th1(task_a);
    std::thread th2(task_b);
    // th1.detach();
    // th2.detach();
    th1.join();
    th2.join();

    return 0;
}

View Code

  创建线程的时候需要注意三点：

  ①、如果使用函数对象作为thread的参数的话，直接传入临时对象会出错，可以定义一个对象传入或者使用lambda表达式：

class CTask
{
public:
    void operator()()
    {
        int a = 0;
    }
};

//std::thread th1(CTask()); //直接传入临时对象会出错
CTask task;
std::thread th1(task);
th1.join();

View Code

  ②、传递给线程函数的参数是先保存在于一个中转站中，当函数执行的时候再传给函数的形参，而这个时候传递的参数指向的值很有可能已经失效，所以，对于线程函数传递的参数应该与形参类型相同，而不是再进行转换。

  ③、如果线程函数的参数是引用的话传入时还需要结合ref来使用。

    void task(int& a, string str)
    {

    }

    int iNum = 0;
    char* pStr = new char[100];
    strcpy(pStr, "test");
    //std::thread th(task, 5, std::ref(iNum), pStr); //不应该直接传入pStr
    std::thread th(task, std::ref(iNum), string(pStr)); //应该传入对应类型
    delete[] pStr;
    th.join();

View Code

  c++中的lock_guard、unique_lock也是RAII型的互斥锁，类似boost的scoped_lock，使用示例：

    std::lock_guard<std::mutex> _lock(m_mutex);
    g_num++;

  unique_lock在lock_guard的基础上增加了加锁和解锁的接口方法，对比下面的fun1和fun2，二者效果相同，通过代码可以看出二者区别：

std::mutex g_mu;

void fun1()
{
    {
        std::lock_guard<std::mutex> guard(g_mu);
        //do something 1
    }

    //do something 2
    
    {
        std::lock_guard<std::mutex> guard(g_mu);
        // do something 3
    }
}

void fun2()
{
    std::unique_lock<std::mutex> guard(g_mu);
    //do something 1
    guard.unlock();

    //do something 2

    guard.lock();
    // do something 3
}

View Code

  unique_lock可以配合条件变量来使用，而lock_guard不能，因为lock_guard没有加锁和解锁的接口方法。另外，unique_lock和lock_guard都不能复制，unique_lock可以移动，lock_guard不能移动。c++11中的条件变量condition_variable与boost的使用类似，其接口方法有wait()、notify_one()等。

 

转载于:https://www.cnblogs.com/milanleon/p/7591530.html