异常的互斥锁的锁守卫

[bosthhe1]

在我们上锁和解锁的中间执行过程中，有可能抛异常导致死锁的问题，这时候guard_mutex()就可以解决这种问题，在抛异常之后出了作用域就解锁，不造成死锁问题

[bosthhe1]

guard_mutex的原理比较简单，就是用锁来创建一个局部类，这个局部类在初始化申请锁，出了作用域就调用析构函数解锁

class guard_mutex
{
public:
    guard_mutex(mutex& _mtx)
        :mtx(_mtx)
    {
        mtx.lock();
    }
    ~guard_mutex()
    {
        mtx.unlock();
    }
private:
    mutex& mtx;
};

int main()
{

    mutex mtx;
    try
    {
                int i = 0;
                int j = 0;
        vector<int> arr;
        thread td1([&]{
            guard_mutex mtx1(mtx);//出了作用域自动解锁
            for (; i < 100000; i++)
            {
                arr.push_back(i);//这里可能抛异常
            }
        });
        thread td2([&]{
            guard_mutex mtx1(mtx);
            for (; j < 100000; j++)
            {
                arr.push_back(i);
            }
        });
    }
    catch (const exception& e)
    {
        cout << e.what() << endl;
    }
    return 0;
}

[bosthhe1]

unique_lock不允许拷贝构造和赋值，其他功能和guard_lock差不多

class unique_lock
{
unique_lock(const unique_lock& _mtx) =delete;
unique_lock operator = (unique_lock& _mtx) =delete;
public:
    unique_lock(mutex& _mtx)
        :mtx(_mtx)
    {
        mtx.lock();
    }
    ~unique_lock()
    {
        mtx.unlock();
    }
private:
    mutex& mtx;
};