C++11并发学习之三:线程同步

版权声明:本文为灿哥哥http://blog.csdn.net/caoshangpa原创文章,转载请标明出处。 https://blog.csdn.net/caoshangpa/article/details/52842618

1.<mutex> 头文件介绍 

Mutex又称互斥量,C++ 11中与 Mutex 相关的类(包括锁类型)和函数都声明在 <mutex> 头文件中,所以如果你需要使用 std::mutex,就必须包含 <mutex> 头文件。

(1)Mutex系列类(四种)
std::mutex,最基本的 Mutex 类。
std::recursive_mutex,递归 Mutex 类。
std::time_mutex,定时 Mutex 类。

std::recursive_timed_mutex,定时递归 Mutex 类。

(2)Lock系列类(两种)
std::lock_guard,与 Mutex RAII 相关,方便线程对互斥量上锁。

std::unique_lock,与 Mutex RAII 相关,方便线程对互斥量上锁,但提供了更好的上锁和解锁控制。

(3)其他类型(结构体)
std::adopt_lock_t——它的常量对象定义为constexpr adopt_lock_t adopt_lock {};//constexpr 是C++11 中的新关键字)
std::defer_lock_t——它的常量对象定义为constexpr defer_lock_t defer_lock {}; //constexpr 是C++11 中的新关键字)
std::try_to_lock_t——它的常量对象定义为constexpr try_to_lock_t try_to_lock {};//constexpr 是C++11 中的新关键字)

(4)函数
std::try_lock,尝试同时对多个互斥量上锁。
std::lock,可以同时对多个互斥量上锁。

std::call_once,如果多个线程需要同时调用某个函数,call_once 可以保证多个线程对该函数只调用一次。


2.常用类型举例

(1)std::mutex类

☆构造函数,std::mutex不允许拷贝构造,也不允许 move 拷贝,最初产生的 mutex 对象是处于 unlocked 状态的。
☆lock(),调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况:①如果该互斥量当前没有被锁住,则调用线程将该互斥量锁住,直到调用 unlock之前,该线程一直拥有该锁。②如果当前互斥量被其他线程锁住,则当前的调用线程被阻塞住。③如果当前互斥量被当前调用线程锁住,则会产生死锁(deadlock)。
☆unlock(), 解锁,释放对互斥量的所有权。
☆try_lock(),尝试锁住互斥量,如果互斥量被其他线程占有,则当前线程也不会被阻塞。线程调用该函数也会出现下面 3 种情况:① 如果该互斥量当前没有被锁住,则该线程锁住互斥量,直到该线程调用 unlock 释放互斥量。②如果当前互斥量被其他线程锁住,则当前调用线程返回 false,而并不会被阻塞掉。③如果当前互斥量被当前调用线程锁住,则会产生死锁(deadlock)。

不论是lock()还是try_lock()都需要和unlock()配套使用,下面举例说明lock()和try_lock()的区别。

#include <thread>
#include <iostream>
#include <string>
#include <chrono>
#include <assert.h>
#include <mutex>
int counter=0;
std::mutex mtx;
void func()
{
    for (int i=0; i<10000; ++i)
    {
            mtx.lock();
            ++counter;
            mtx.unlock();
    }
}

int main()
{
    std::thread workerThreads[10];
    for (int i=0; i<10; ++i)
    {
        workerThreads[i] = std::thread(func);
    }
    for (auto& workerThread : workerThreads)
    {
        workerThread.join();
    }
    std::cout << counter << " successful increases of the counter"<<std::endl;

    return 0;
}

由于lock()的阻塞特性,所以每个线程都统计了10000次,一共是10*10000=100000次。
#include <thread>
#include <iostream>
#include <string>
#include <chrono>
#include <assert.h>
#include <mutex>
int counter=0;
std::mutex mtx;
void func()
{
    for (int i=0; i<10000; ++i)
    {
        if (mtx.try_lock())
        {
            ++counter;
            mtx.unlock();
        }
    }
}

int main()
{
    std::thread workerThreads[10];
    for (int i=0; i<10; ++i)
    {
        workerThreads[i] = std::thread(func);
    }
    for (auto& workerThread : workerThreads)
    {
        workerThread.join();
    }
    std::cout << counter << " successful increases of the counter"<<std::endl;

    return 0;
}

由于try_lock()的非阻塞特性,如果当前互斥量被其他线程锁住,则当前try_lock()返回 false,此时counter并不会增加1。所以这十个线程的统计结果具有随机性,下次运行程序时,统计值不一定是16191。

(2).std::lock_guard和std::unique_lock类

std::lock_guard使用起来比较简单,除了构造函数外没有其他成员函数。
std::unique_lock除了lock_guard的功能外,提供了更多的成员函数,相对来说更灵活一些。这些成员函数包括lock,try_lock,try_lock_for,try_lock_until、unlock等。

std::unique_lock::lock——用它所管理的Mutex对象的 lock 函数。

std::unique_lock::try_lock——用它所管理的Mutex对象的 try_lock函数。

std::unique_lock::unlock——用它所管理的Mutex对象的 unlock函数。

这两个类相比使用std::mutex的优势在于不用配对使用,无需担心忘记调用unlock而导致的程序死锁。

#include <thread>
#include <iostream>
#include <string>
#include <chrono>
#include <assert.h>
#include <mutex>
int counter=0;
std::mutex mtx;
void func()
{
    for (int i=0; i<10000; ++i)
    {
        //将std::lock_guard替换成std::unique_lock,效果是一样的
        std::lock_guard<std::mutex> lck (mtx);
        ++counter;
    }
}

int main()
{
    std::thread workerThreads[10];
    for (int i=0; i<10; ++i)
    {
        workerThreads[i] = std::thread(func);
    }
    for (auto& workerThread : workerThreads)
    {
        workerThread.join();
    }
    std::cout << counter << " successful increases of the counter"<<std::endl;

    return 0;
}

std::uniqure_lock构造函数的第二个参数可以是std::defer_lock,std::try_to_lock或std::adopt_lock

#include <thread>
#include <iostream>
#include <string>
#include <chrono>
#include <assert.h>
#include <mutex>
int counter=0;
std::mutex mtx;
void func()
{
    for (int i=0; i<10000; ++i)
    {
        mtx.lock();
        //注意此时Tag参数为std::adopt_lock表明当前线程已经获得了锁,
        //此后mtx对象的解锁操作交由unique_lock对象lck来管理,在lck的生命周期结束之后,
        //mtx对象会自动解锁。
        std::unique_lock<std::mutex> lck(mtx,std::adopt_lock);
        ++counter;
    }
}

int main()
{
    std::thread workerThreads[10];
    for (int i=0; i<10; ++i)
    {
        workerThreads[i] = std::thread(func);
    }
    for (auto& workerThread : workerThreads)
    {
        workerThread.join();
    }
    std::cout << counter << " successful increases of the counter"<<std::endl;

    return 0;
}


#include <chrono>
#include <assert.h>
#include <mutex>
int counter=0;
std::mutex mtx;
void func()
{
    for (int i=0; i<10000; ++i)
    {
        //注意此时Tag参数为std::defer_lock表明当前线程没有获得了锁,
        //需要通过lck的lock和unlock来加锁和解锁,
        std::unique_lock<std::mutex> lck(mtx,std::defer_lock);
        lck.lock();
        ++counter;
        lck.unlock();
    }
}

int main()
{
    std::thread workerThreads[10];
    for (int i=0; i<10; ++i)
    {
        workerThreads[i] = std::thread(func);
    }
    for (auto& workerThread : workerThreads)
    {
        workerThread.join();
    }
    std::cout << counter << " successful increases of the counter"<<std::endl;

    return 0;
}


参考链接:http://www.cnblogs.com/haippy/p/3346477.html



没有更多推荐了,返回首页