c++11区域锁

unique_lock

方法	说明	详细说明
unique_lock() noexcept;	默认构造函数	默认构造函数 新创建的 unique_lock 对象不管理任何 Mutex 对象
explicit unique_lock(mutex_type& m);	加锁	新创建的 unique_lock 对象，管理 Mutex 对象 m，并尝试调用 m.lock() 对 Mutex 对象进行上锁，如果此时另外某个 unique_lock 对象已经管理了该 Mutex 对象 m，则当前线程将会被阻塞。
unique_lock(mutex_type& m, try_to_lock_t tag);	尝试加锁	try-locking 初始化新创建的 unique_lock 对象，管理 Mutex 对象 m，并尝试调用 m.try_lock() 对 Mutex 对象进行上锁，但如果上锁不成功，并不会阻塞当前线程。
unique_lock(mutex_type& m, defer_lock_t tag) noexcept;	延迟加锁	deferred 初始化新创建的 unique_lock 对象，管理 Mutex 对象 m，但是在初始化的时候并不锁住 Mutex 对象。 m 应该是一个没有当前线程锁住的 Mutex 对象。
unique_lock(mutex_type& m, adopt_lock_t tag);	递归加锁	adopting 初始化 新创建的 unique_lock 对象管理 Mutex 对象 m， m 应该是一个已经被当前线程锁住的 Mutex 对象。(并且当前新创建的 unique_lock 对象拥有对锁(Lock)的所有权)。
template <class Rep, class Period> unique_lock(mutex_type& m, const chrono::duration<Rep,Period>& rel_time);	限时锁定	locking 一段时间(duration) 新创建的 unique_lock 对象管理 Mutex 对象 m，并试图通过调用 m.try_lock_for(rel_time) 来锁住 Mutex 对象一段时间(rel_time)。
template <class Clock, class Duration> unique_lock(mutex_type& m, const chrono::time_point<Clock,Duration>& abs_time);	定时锁定	locking 直到某个时间点(time point) 新创建的 unique_lock 对象管理 Mutex 对象m，并试图通过调用 m.try_lock_until(abs_time) 来在某个时间点(abs_time)之前锁住 Mutex 对象。
unique_lock(const unique_lock&) = delete;	禁止拷贝	拷贝构造 [被禁用] unique_lock 对象不能被拷贝构造。
unique_lock(unique_lock&& x);	所有权转移	新创建的 unique_lock 对象获得了由 x 所管理的 Mutex 对象的所有权(包括当前 Mutex 的状态)。调用 move 构造之后，x 对象如同通过默认构造函数所创建的，就不再管理任何 Mutex 对象了。

简单地讲，unique_lock 是 lock_guard 的升级加强版，它具有 lock_guard 的所有功能，同时又具有其他很多方法，使用起来更强灵活方便，能够应对更复杂的锁定需要。

特点如下：

    创建时可以不锁定（通过指定第二个参数为 std::defer_lock），而在需要时再锁定
    可以随时加锁解锁
    作用域规则同 lock_grard，析构时自动释放锁
    不可复制，可移动
    条件变量需要该类型的锁作为参数（此时必须使用 unique_lock）

#include <mutex>
#include <thread>
#include <chrono>
 
struct Box {
    explicit Box(int num) : num_things{num} {}
 
    int num_things;
    std::mutex m;
};
 
void transfer(Box &from, Box &to, int num)
{
    std::unique_lock<std::mutex> lock1(from.m, std::defer_lock);
    std::unique_lock<std::mutex> lock2(to.m, std::defer_lock);
 
    
    std::lock(lock1, lock2);
 
    from.num_things -= num;
    to.num_things += num; 
}
 
int main()
{
    Box acc1(100);
    Box acc2(50);
 
    std::thread t1(transfer, std::ref(acc1), std::ref(acc2), 10);
    std::thread t2(transfer, std::ref(acc2), std::ref(acc1), 5);
 
    t1.join();
    t2.join();
}