C++并发-互斥元

1.std::mutex类

1.构造函数，std::mutex不允许拷贝构造，也不允许 move 拷贝，最初产生的 mutex 对象是处于 unlocked 状态的。
2.lock()，调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况：①如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁。②如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住。③如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。
3.unlock()， 解锁，释放对互斥量的所有权
4.unlock 和lock配套使用
5.必须在每个离开函数的路径上调用unlock。

2.std::lock_guard类

std::lock_guard使用起来比较简单，除了构造函数外没有其他成员函数。
优势在于不用配对使用

#include 
#include 
#include 
std::mutex some_mutex;
void add()
{
    std::lock_guard guard(some_mutex);
}

3.使用std::unique_lock灵活锁定

为了实现锁粒度，std::lock_guard就显得不够灵活，一个例子：

#include 
#include 
#include 
std::mutex some_mutex;
void add()
{
    {  //这边的括号是为了作用域，以便自动解锁
        std::lock_guard guard(some_mutex);
        //do something_1
    }
    //do something_2

    {
        std::lock_guard guard(some_mutex);
        //do something_3
    }
}

使用unique_lock

void add()
{
    std::unique_lock lock_1(some_mutex,std::defer_lock);//保留互斥元为未锁定
    std::lock(lock_1); //互斥元在这里锁定
    // do something_1
    std::unlock(lock_1);
    //do something_2
    std::lock(lock_1);
    // do something_3
    std::unlock(lock_1);
}

4.使用相同的顺序锁定互斥元来避免死锁

使用std::lock函数

std::mutex m1,m2;
void mutexer()
{
    std::lock(m1, m2); //锁定这两个互斥元

    //构建两个实例，告知该互斥元对象已被锁定，只是获取所有权，并不试图锁定互斥元
    std::lock_guard lock_1(m1, std::adopt_lock);
    std::lock_guard lock_2(m2, std::adopt_lock);
}

转载于:https://www.cnblogs.com/penuel/p/11571432.html