关于c++:C并发与多线程-5互斥量概念用法死锁演示及详解

25次阅读

共计 4963 个字符，预计需要花费 13 分钟才能阅读完成。

临界资源：每次只容许一个线程进行拜访（读 / 写）的资源
线程间的互斥（竞争）：多个线程在同一时刻都须要拜访临界资源
mutex 类（互斥量）是一把线程锁，保障线程间的互斥
- 利用线程锁可能保障临界资源的平安

mutex.lock()
- 当锁闲暇时，获取并继续执行
- 当锁被获取时，阻塞并期待锁开释
mutex.unlock()
- 开释锁（同一把锁的获取和开释必须在同一线程中成对呈现）
如果 mutex 在调用 unlock() 时处于闲暇状态，那么程序的行为是未定义的

在 lock_guard 对象结构时，传入的 mutex 对象（即它治理的 mutex 对象）会被以后线程锁住。
在 lock_guard 对象被析构时，它所治理的 mutex 对象会主动解锁，不再须要手动调用 lock 和 unlock 对 mutex 进行上锁和解锁操作；
lock_guard 对象并不负责 mutex 对象的生命周期，只是简化了上锁和解锁操作；
这种采纳“资源分配时初始化”（RAII）办法来加锁、解锁， 防止了在临界区中因为抛出异样或 return 等操作导致没有解锁就退出的问题 。这极大的简化了编写 mutex 相干的异样解决代码。

#include <iostream>
#include <thread>
#include <queue>
#include <mutex>

using namespace std;

class Handle {
public:
    void inMsgRevQueue()
    {for (int i=0; i<100000; ++i)
        {m_mutex.lock();                     // 留神这里！！！cout << "inMsgRevQueue() :" << i << endl;
            m_queue.push(i);

            m_mutex.unlock();                   // 留神这里！！！}
    }

    void outMsgRevQueue()
    {for (int i=0; i<100000; ++i)
        {lock_guard<mutex> lck(m_mutex);     // 留神这里！！！if (!m_queue.empty())
            {cout << "outMsgRevQueue() :" << m_queue.front() << endl;
                m_queue.pop();}
        }
    }

private:
    queue<int> m_queue;
    mutex m_mutex;
};

int main()
{
    cout << "main begin" << endl;

    Handle handler;

    thread th1(&Handle::inMsgRevQueue, std::ref(handler));
    thread th2(&Handle::outMsgRevQueue, std::ref(handler));

    th1.join();
    th2.join();

    cout << "main end" << endl;

    return 0;
}

输入：

......

outMsgRevQueue() : 98267
outMsgRevQueue() : 98268
outMsgRevQueue() : 98269
outMsgRevQueue() : 98270
main end

概念
- 线程间相互期待临界资源而造成彼此无奈持续向下运行
产生死锁的条件
- 零碎存在多个临界资源且临界资源不可抢占
- 线程须要多个临界资源能力持续运行

#include <iostream>
#include <thread>
#include <queue>
#include <mutex>

using namespace std;

class Handle {
public:
    void inMsgRevQueue()
    {for (int i=0; i<100000; ++i)
        {m_mutex1.lock();
            m_mutex2.lock();

            cout << "inMsgRevQueue() :" << i << endl;
            m_queue.push(i);

            m_mutex2.unlock();
            m_mutex1.unlock();}
    }

    void outMsgRevQueue()
    {for (int i=0; i<100000; ++i)
        {m_mutex2.lock();
            m_mutex1.lock();

            if (!m_queue.empty())
            {cout << "outMsgRevQueue() :" << m_queue.front() << endl;
                m_queue.pop();}

            m_mutex1.unlock();
            m_mutex2.unlock();}
    }

private:
    queue<int> m_queue;
    mutex m_mutex1;
    mutex m_mutex2;
};

int main()
{
    cout << "main begin" << endl;

    Handle handler;

    thread th1(&Handle::inMsgRevQueue, std::ref(handler));
    thread th2(&Handle::outMsgRevQueue, std::ref(handler));

    th1.join();
    th2.join();

    cout << "main end" << endl;

    return 0;
}

输入：

inMsgRevQueue() : 63
inMsgRevQueue() : 64
inMsgRevQueue() : 65
inMsgRevQueue() : 66
inMsgRevQueue() : 67

不再输入 ...

对所有的临界资源都调配一个惟一的编号 (n1, n2, n3)
对应的线程锁也调配同样的序号（m1, m2, m3）
零碎中的每个线程依照严格递增（递加）的秩序申请资源

#include <iostream>
#include <thread>
#include <queue>
#include <mutex>

using namespace std;

class Handle {
public:
    void inMsgRevQueue()
    {for (int i=0; i<100000; ++i)
        {m_mutex1.lock();
            m_mutex2.lock();

            cout << "inMsgRevQueue() :" << i << endl;
            m_queue.push(i);

            m_mutex2.unlock();
            m_mutex1.unlock();}
    }

    void outMsgRevQueue()
    {for (int i=0; i<100000; ++i)
        {m_mutex1.lock();
            m_mutex2.lock();

            if (!m_queue.empty())
            {cout << "outMsgRevQueue() :" << m_queue.front() << endl;
                m_queue.pop();}

            m_mutex2.unlock();
            m_mutex1.unlock();}
    }

private:
    queue<int> m_queue;
    mutex m_mutex1;
    mutex m_mutex2;
};

int main()
{
    cout << "main begin" << endl;

    Handle handler;

    thread th1(&Handle::inMsgRevQueue, std::ref(handler));
    thread th2(&Handle::outMsgRevQueue, std::ref(handler));

    th1.join();
    th2.join();

    cout << "main end" << endl;

    return 0;
}

输入：

inMsgRevQueue() : 99995
inMsgRevQueue() : 99996
inMsgRevQueue() : 99997
inMsgRevQueue() : 99998
inMsgRevQueue() : 99999
main end

lock（mutex1, mutex2, ...）; 一次锁定两个或多个锁，用于解决多个互斥量

当全副锁闲暇时，获取并继续执行
当全副锁未被获取时，阻塞并期待锁开释
- 当只获取其中一部分锁，另一部分锁被其它线程锁定时，则开释以后已获取的锁，持续期待并从新尝试获取全副锁，以此避免死锁

#include <iostream>
#include <thread>
#include <queue>
#include <mutex>

using namespace std;

class Handle {
public:
    void inMsgRevQueue()
    {for (int i=0; i<100000; ++i)
        {m_mutex1.lock();
            m_mutex2.lock();

            cout << "inMsgRevQueue() :" << i << endl;
            m_queue.push(i);

            m_mutex2.unlock();
            m_mutex1.unlock();}
    }

    void outMsgRevQueue()
    {for (int i=0; i<100000; ++i)
        {lock(m_mutex1, m_mutex2);       // 留神这里！！！if (!m_queue.empty())
            {cout << "outMsgRevQueue() :" << m_queue.front() << endl;
                m_queue.pop();}

            m_mutex2.unlock();
            m_mutex1.unlock();}
    }

private:
    queue<int> m_queue;
    mutex m_mutex1;
    mutex m_mutex2;
};

int main()
{
    cout << "main begin" << endl;

    Handle handler;

    thread th1(&Handle::inMsgRevQueue, std::ref(handler));
    thread th2(&Handle::outMsgRevQueue, std::ref(handler));

    th1.join();
    th2.join();

    cout << "main end" << endl;

    return 0;
}

输入：

outMsgRevQueue() : 99599
outMsgRevQueue() : 99600
outMsgRevQueue() : 99601
outMsgRevQueue() : 99602
main end

应用 adopt_lock 结构的 unique_lock 和 lock_guard 对象在结构时不会锁定 mutex 对象，而是假设它已被以后线程锁定。

#include <iostream>
#include <thread>
#include <queue>
#include <mutex>

using namespace std;

class Handle {
public:
    void inMsgRevQueue()
    {for (int i=0; i<100000; ++i)
        {m_mutex.lock();

            cout << "inMsgRevQueue() :" << i << endl;
            m_queue.push(i);

            m_mutex.unlock();}
    }

    void outMsgRevQueue()
    {for (int i=0; i<100000; ++i)
        {m_mutex.lock();

            lock_guard<mutex> lck(m_mutex, adopt_lock);     // 留神这里！！！if (!m_queue.empty())
            {cout << "outMsgRevQueue() :" << m_queue.front() << endl;
                m_queue.pop();}
        }
    }

private:
    queue<int> m_queue;
    mutex m_mutex;
};

int main()
{
    cout << "main begin" << endl;

    Handle handler;

    thread th1(&Handle::inMsgRevQueue, std::ref(handler));
    thread th2(&Handle::outMsgRevQueue, std::ref(handler));

    th1.join();
    th2.join();

    cout << "main end" << endl;

    return 0;
}

输入:

......

outMsgRevQueue() : 97515
outMsgRevQueue() : 97516
outMsgRevQueue() : 97517
outMsgRevQueue() : 97518
main end

正文完

c++

发表至： c#

2021-02-02

0

关于c:C语言服务器编程必备常识

关于c++:C面试八股文stdvector和stdlist如何选择

关于c++:多位专家力推丨大量经典案例分析集锦带你深入学习Nginx底层源码

关于c#:如何在-AspNet-Core-MVC-中处理-null-值

关于javascript:扫码登录的实现原理

关于c++:C并发与多线程-5互斥量概念用法死锁演示及详解

互斥量的基本概念

互斥量的用法

lock

lock_guard

死锁

死锁的演示

死锁的防止

死锁的个别解决方案

std::lock 函数模板

std::lock_guard 的 std::adopt_lock 参数

Just My Socks（注册教程内含优惠码）

关于c++:C并发与多线程-5互斥量概念用法死锁演示及详解

互斥量的基本概念

互斥量的用法

lock

lock_guard

死锁

死锁的演示

死锁的防止

死锁的个别解决方案

std::lock 函数模板

std::lock_guard 的 std::adopt_lock 参数

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）