Mutex和Lock

=================================版权声明=================================

版权声明：原创文章 禁止转载 

请通过右侧公告中的“联系邮箱（wlsandwho@foxmail.com）”联系我

勿用于学术性引用。

勿用于商业出版、商业印刷、商业引用以及其他商业用途。　　　　　　　　　　　　　　　　   

本文不定期修正完善。

本文链接：https://www.cnblogs.com/wlsandwho/p/13840532.html

耻辱墙：http://www.cnblogs.com/wlsandwho/p/4206472.html

=======================================================================

C++ 异步

=======================================================================

mutex

使用lock锁定，使用unlock解锁。

使用lock_guard在作用域内自动对mutex加锁和解锁。（基于RAII）

使用try_lock尝试加锁，成功后需要unlock。

使用try_lock尝试加锁，成功后使用带adopt_lock的lock_guard接管。

timed_mutex

使用try_lock_for尝试在时间段内阻塞等待锁，超时则退出等待。（这个我不感兴趣不写例子了）

使用try_lock_until尝试在到某时间点之前一直阻塞等待锁，超过该时间点则退出等待。（这个我不感兴趣不写例子了）

recursive_mutex

可以多次加锁，当有1次解锁时就释放锁。

timed_recursive_mutex

使用try_lock_for尝试在时间段内阻塞等待锁，超时则退出等待。（这个我不感兴趣不写例子了）

使用try_lock_until尝试在到某时间点之前一直阻塞等待锁，超过该时间点则退出等待。（这个我不感兴趣不写例子了）

std::lock

同时锁住多个锁

std::try_lock

同事尝试锁住多个锁

unique_lock

（这个此处不是重点，应当和Condition Variable配合使用，先不写例子了）

#include <iostream>
#include <future>
#include <functional>

class CTestA
{
public:
    void Do0(std::string& str)
    {
        for (auto c : str)
        {
            std::cout.put(c);
        }

        std::cout.put('
');
    }

    void Do1(std::string& str)
    {
        std::lock_guard<std::mutex> lg(mtx);

        for (auto c:str)
        {
            std::cout.put(c);
        }

        std::cout.put('
');
    }

protected:
    std::mutex mtx;
};

void TestA0()
{
    //演示，当没有互斥量进行同步时，输出可能会被打乱。

    std::string strHello("This_is_a_lock_guard_demo.");
    CTestA oTA;

    //由于是类成员函数调用了复杂的参数（string），所以这里用std::bind作为第二个参数。当然可以用lambda但我不喜欢。
    //strHello可能需要std::ref，这里省略了因为不是本节主要内容。
    auto fA01 = std::async(std::launch::async, std::bind(&CTestA::Do0, &oTA, strHello));
    auto fA02 = std::async(std::launch::async, std::bind(&CTestA::Do0, &oTA, strHello));

    fA01.get();
    fA02.get();
}

void TestA1()
{
    //演示，当有互斥量进行同步时，输出正常。

    std::string strHello("This_is_a_lock_guard_demo.");
    CTestA oTA;

    auto fA11 = std::async(std::launch::async, std::bind(&CTestA::Do1, &oTA, strHello));
    auto fA12 = std::async(std::launch::async, std::bind(&CTestA::Do1, &oTA, strHello));

    fA11.get();
    fA12.get();
}

class CTestB
{
public:
    void Do01()
    {
        std::lock_guard<std::mutex> lg(mtx);
        std::cout << "Do01()" << std::endl;
    }
    
    void Do02()
    {
        std::lock_guard<std::mutex> lg(mtx);

        std::cout << "Do02()...begin" << std::endl;
        Do01();
        std::cout << "Do02()...end" << std::endl;
    }

    void Do11()
    {
        std::lock_guard<std::recursive_mutex> lg(rmtx);

        std::cout << "Do11()" << std::endl;
    }

    void Do12()
    {
        std::lock_guard<std::recursive_mutex> lg(rmtx);

        std::cout << "Do12()...begin" << std::endl;
        Do11();
        std::cout << "Do12()...end" << std::endl;
    }

protected:
    std::mutex mtx;
    std::recursive_mutex rmtx;
};

void TestB0()
{
    CTestB oB0;
    oB0.Do02();//未使用递归互斥量时，嵌套调用，引发异常。
}

void TestB1()
{
    CTestB oB0;
    oB0.Do12();//使用递归互斥量，嵌套调用，正常运行。
    oB0.Do11();//能够够正常运行。
}

class CTestC
{
public:
    void Do01()
    {
        mtx.lock();
        std::cout << "Do01()...lock" << std::endl;
    }
    void Do02()
    {
        mtx.unlock();
        std::cout << "Do02()...unlock" << std::endl;
    }

    void Do11()
    {
        if (mtx.try_lock())
        {
            std::cout << "Do11()...try_lock" << std::endl;

            mtx.unlock();
            std::cout << "Do11()...unlock" << std::endl;
        }
        else
        {
            std::cout << "Do11()...try_lock failed" << std::endl;
        }
    }
    void Do12()
    {
        if (mtx.try_lock())
        {
            std::cout << "Do12()...try_lock,use adopt_lock" << std::endl;

            std::lock_guard<std::mutex> lg(mtx, std::adopt_lock);//采用了mtx之前的状态，并在作用域结束后释放mtx
        }
        else
        {
            std::cout << "Do12()...try_lock failed" << std::endl;
        }
    }
protected:
    std::mutex mtx;
};

void TestC1()
{
    //此处使用单一线程模拟多线程时交错执行的情形
    CTestC oTC;

    //////////////////////////////////////////////////////////////////////////
    //失败的情形

    //使用mutex的try_lock功能，并用unlock释放。
    oTC.Do01();
    oTC.Do11();
    oTC.Do02();
    std::cout << "-----------" << std::endl;

    //使用mutex的try_lock功能，使用带adopt_lock的lock_guard接管。
    oTC.Do01();
    oTC.Do12();
    oTC.Do02();
    std::cout << "-----------" << std::endl;

    //////////////////////////////////////////////////////////////////////////
    //成功的情形

    oTC.Do11();//使用mutex的try_lock功能，并用unlock释放。
    std::cout << "-----------" << std::endl;

    oTC.Do12();//使用mutex的try_lock功能，使用带adopt_lock的lock_guard接管。
    std::cout << "-----------" << std::endl;
}

class CTestD
{
public:
    void Do01()
    {
        std::lock_guard<std::mutex> lg1(mtx1);
        std::cout << "Do01 Get mtx1" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));

        std::lock_guard<std::mutex> lg2(mtx2);
        std::cout << "Do01 Get mtx2" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(2));
    }

    void Do02()
    {
        std::lock_guard<std::mutex> lg2(mtx2);
        std::cout << "Do02 Get mtx2" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(2));

        std::lock_guard<std::mutex> lg1(mtx1);
        std::cout << "Do02 Get mtx1" << std::endl;
    }

    void Do03()
    {
        std::lock_guard<std::mutex> lg2(mtx2);
        std::cout << "Do03 Get mtx2" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(5));
    }

    void Do11()
    {
        std::lock(mtx1, mtx2);
        std::lock_guard<std::mutex> lg1(mtx1, std::adopt_lock);
        std::lock_guard<std::mutex> lg2(mtx2, std::adopt_lock);
        std::cout << "Do11 Get mtx1 mtx2" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(2));

    }

    void Do12()
    {
        std::lock(mtx2,mtx1);
        std::lock_guard<std::mutex> lg2(mtx2, std::adopt_lock);
        std::lock_guard<std::mutex> lg1(mtx1, std::adopt_lock);
        std::cout << "Do12 Get mtx2 mtx1" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(2));
    }

    void Do21()
    {
        int idx=std::try_lock(mtx1, mtx2);
        if (idx<0)
        {
            std::lock_guard<std::mutex> lg2(mtx2, std::adopt_lock);
            std::lock_guard<std::mutex> lg1(mtx1, std::adopt_lock);
            std::cout << "Do21 Get mtx1 mtx2" << std::endl;
        }
        else
        {
            std::cout << "Do21 did not get "<<idx+1 << std::endl;
        }
    }

protected:
    std::mutex mtx1;
    std::mutex mtx2;
};

void TestD01()
{
    //Do01与Do02的顺序相反造成死锁
    CTestD oTD;
    auto f01 = std::async(std::launch::async, &CTestD::Do01, &oTD);
    auto f02 = std::async(std::launch::async, &CTestD::Do02, &oTD);
    f01.get();
    f02.get();
}

void TestD02()
{
    //Do01过了很久才拿到所有的锁
    CTestD oTD;
    auto f01 = std::async(std::launch::async, &CTestD::Do01, &oTD);
    auto f03 = std::async(std::launch::async, &CTestD::Do03, &oTD);
    f01.get();
    f03.get();
}

void TestD11()
{
    //避免了死锁

    CTestD oTD;
    auto f01 = std::async(std::launch::async, &CTestD::Do02, &oTD);
    auto f11 = std::async(std::launch::async, &CTestD::Do11, &oTD);
    f01.get();
    f11.get();
}

void TestD12()
{
    //避免了死锁

    CTestD oTD;
    auto f11 = std::async(std::launch::async, &CTestD::Do11, &oTD);
    auto f12 = std::async(std::launch::async, &CTestD::Do12, &oTD);
    f11.get();
    f12.get();
}

void TestD21()
{
    //try_lock

    CTestD oTD;
    auto f03 = std::async(std::launch::async, &CTestD::Do03, &oTD);
    auto f21 = std::async(std::launch::async, &CTestD::Do21, &oTD);
    f03.get();
    f21.get();
}

int main()
{
    std::cout << "-----------A0-------------" << std::endl;
    TestA0();
    std::cout << "-----------A1-------------" << std::endl;
    TestA1();

    std::cout << "-----------B0-------------" << std::endl;
    //TestB0();//发生异常
    std::cout << "-----------B1-------------" << std::endl;
    TestB1();

    std::cout << "-----------C1-------------" << std::endl;
    TestC1();

    std::cout << "-----------D01-------------" << std::endl;
    //TestD01();//死锁
    std::cout << "-----------02" << std::endl;
    TestD02();
    std::cout << "-----------11" << std::endl;
    TestD11();
    std::cout << "-----------12" << std::endl;
    TestD12();
    std::cout << "-----------21" << std::endl;
    TestD21();

    std::cout << "-----------End-------------" << std::endl;
    return 0;
}

运行结果