c++11 unique_lock 使用

        我们知道c++11 提供了很多的类模板供我们使用，其中就有 lock_guard，这个用法也很简单，像这样：

std::mutex m_mutex;
std::lock_guard<std::mutex> guard(m_mutex);

mutex 的 lock 和 unlock 完全是自动的，无需我们手动操作。因为模板类 lock_guard 在构造函数里进行了 lock，在析构函数里进行了 unlock。我们可以看源码实现：

  template<typename _Mutex>
    class lock_guard
    {
    public:
      typedef _Mutex mutex_type;

      explicit lock_guard(mutex_type& __m) : _M_device(__m)
      { _M_device.lock(); }

      lock_guard(mutex_type& __m, adopt_lock_t) : _M_device(__m)
      { } // calling thread owns mutex

      ~lock_guard()
      { _M_device.unlock(); }

      lock_guard(const lock_guard&) = delete;
      lock_guard& operator=(const lock_guard&) = delete;

    private:
      mutex_type&  _M_device;
    };

和 lock_guard 具有同样功能的还有一个：unique_lock。同样的，unique_lock 也是可以自动锁定和解锁，但其多了几个接口，且构造函数里也多了一些参数。

1，和 lock_guard 一样的功能，如：

#include <thread>
#include <mutex>
#include <chrono>
#include <stdio.h>

std::mutex mtx;

void funcProc()
{
    std::unique_lock<std::mutex> guard(mtx);
    int count = 5;

    while(count-- > 0)
    {
        printf("in new thread\n");
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

int main()
{
    std::thread t1(funcProc);

    //先让子线程跑起来再去获取锁
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    printf("main thread begin to get mtx\n");
    {
        std::unique_lock<std::mutex> guard(mtx);
        int count = 5;
        while(count -- > 0)
        {
            printf("main thread already get mtx\n");
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }
    }

    t1.join();
    return 0;
}

很简单，子线程先获取锁，执行完后 main 线程获取锁，这里完全靠自动锁定和解锁。

2，构造函数里参数 std::defer_lock

当我们在构造函数里添加参数 std::defer_lock 时，此时构造函数里并没有调用锁的 lock()，即之后需要我们手动去调用 lock() 进行锁定，如：

#include <thread>
#include <mutex>
#include <chrono>
#include <stdio.h>

std::mutex mtx;

void funcProc()
{
    //加了defer_lock， 构造函数里不会进行lock
    std::unique_lock<std::mutex> guard(mtx, std::defer_lock);
    int count = 5;
    std::this_thread::sleep_for(std::chrono::milliseconds(10));

    //这里尝试锁定，但此锁已经被 main 线程锁定了
    guard.lock();
    while(count-- > 0)
    {
        printf("in new thread\n");
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

int main()
{
    std::thread t1(funcProc);

    printf("main thread begin to get mtx\n");
    {
        std::unique_lock<std::mutex> guard(mtx);
        int count = 5;
        while(count -- > 0)
        {
            printf("main thread already get mtx\n");
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }
        
    }
    
    //这里已经解锁，子线程可以获取锁了
    printf("main thread unlock\n");
    t1.join();
    return 0;
}

 

我们看源码里，带defer_lock参数的构造函数是这样的：

      unique_lock(mutex_type& __m, defer_lock_t) noexcept
      : _M_device(&__m), _M_owns(false)
      { }

 3，lock() 函数

相比 lock_guard ，unique_lock 可以进行手动 lock，但如果是已经lock的情况下再lock时，则会抛出异常，如：

#include <thread>
#include <mutex>
#include <chrono>
#include <stdio.h>

std::mutex mtx;

void funcProc()
{

    std::unique_lock<std::mutex> guard(mtx);
    int count = 5;

    //当前线程已经锁定时，再调用 lock() 则会抛出异常
    guard.lock();
    while(count-- > 0)
    {
        printf("in new thread\n");
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

int main()
{
    std::thread t1(funcProc);

    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    printf("main thread begin to get mtx\n");
    {
        std::unique_lock<std::mutex> guard(mtx);
        int count = 5;
        while(count -- > 0)
        {
            printf("main thread already get mtx\n");
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }
        
    }
    
    //这里已经解锁，子线程可以获取锁了
    printf("main thread unlock\n");
    t1.join();
    return 0;
}

4，unlock 函数

在没有 lock 的情况下进行 unlock 也会抛出异常，如：

#include <thread>
#include <mutex>
#include <chrono>
#include <stdio.h>

std::mutex mtx;

void funcProc()
{

    std::unique_lock<std::mutex> guard(mtx, std::defer_lock);
    int count = 5;

    //没有锁定的情况下解锁，则抛出异常
    guard.unlock();
    while(count-- > 0)
    {
        printf("in new thread\n");
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

int main()
{
    std::thread t1(funcProc);

    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    printf("main thread begin to get mtx\n");
    {
        std::unique_lock<std::mutex> guard(mtx);
        int count = 5;
        while(count -- > 0)
        {
            printf("main thread already get mtx\n");
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }
    }
    
    //这里已经解锁，子线程可以获取锁了
    printf("main thread unlock\n");
    t1.join();
    return 0;
}

5，release 函数

 注意这个 release 函数，它并不会解锁，所以这个函数慎用，否则就是死锁，如：

#include <thread>
#include <mutex>
#include <chrono>
#include <stdio.h>

std::mutex mtx;

void funcProc()
{
    std::unique_lock<std::mutex> guard(mtx);
    int count = 5;

    while(count-- > 0)
    {
        printf("in new thread\n");
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        if(count == 2)
        {
            printf("in new thread, release mtx\n");
            //release()并没有解锁，main 线程则会一直在等锁，若要解锁则：guard.release()->unlock()
            guard.release();
        }
    }
}

int main()
{
    std::thread t1(funcProc);

    //先让子线程跑起来再去获取锁
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    printf("main thread begin to get mtx\n");
    {
        std::unique_lock<std::mutex> guard(mtx);
        int count = 5;
        while(count -- > 0)
        {
            printf("main thread already get mtx\n");
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }
    }

    t1.join();
    return 0;
}

 我们看 release 的源码 ：

      mutex_type*
      release() noexcept
      {
	mutex_type* __ret = _M_device;
	_M_device = 0;
	_M_owns = false;
	return __ret;
      }

所以我们要解锁的话，得这样调用：guard.release()->unlock()。

其他函数这里就不讲了。