c++多线程，unique_lock

template<class Mutex> class unique_lock;

unique_lock

不管时锁定还是非锁定状态，unique_lock对互斥量有唯一ownership；

在构建或通过移动构造，unique lock获得互斥量，并对该互斥量的lock/unlock负责；

该类保证在销毁时处于解锁状态，因此对于有自动持续时间的对象特别有用，因为它可以确保在抛出异常情况下，互斥对象已正确解锁；

mutex_type* mutex() const noexcept;

返回unique_lock管理的mutex指针；

class MyMutex : public mutex {
  public:
    MyMutex(int id_num) : id(id_num) {}
    int id() { return id; }
  private:
    int id;
}
MyMutex my_mtx(100);

void PrintId(int id) {
    unique_lock<MyMutex> lck(my_mtx);
    cout<<id<<" is "<<lck.mutex()->id()<<endl;
}  

bool owns_lock() const noexcept;

返回是否拥有锁

如果被uniique_lock locked或adopted并且还没有unlocked or released 返回true，否则返回false;

void PrintStar() {
    unique_lock<mutex> lck(mtx, std::try_to_lock);
    if (lck.owns_lock()) {
        cout<<"*";
    } else {
        cout<<"-";
    }
}

bool try_lock();

使用try_lock()管理锁对象，并且用返回值设置owing state;

如果调用try_lock()之前owing state已经true， 或者当前对象并没有管理任何mutex object， 函数则抛出system_error异常；

void PrintStar() {
    unique_lock<mutex> lck(mtx, std::defer_lock);
    if (lck.try_lock()) {
        cout<<"*";
    } else {
        cout<<"-";
    }
}

try_lock_until

template<class Clock, class Duration>

    bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);

使用管理的timed mutex object 对象调用try_lock_until， 使用返回的值设置owning state;

返回system_error情况同try_lock同；

如果成功锁定timed mutex object 返回true， 否则返回false；

try_lock_for

template<class Rep, class Period>

    bool try_lock_until(const chrono::duration<Rep, Period>& rel_time);

使用管理的timed mutex object调用成员函数try_lock_for，使用返回值设置owing state;

system_error情况，同try_lock_until同；

如果成功lock管理的timed mutex object 返回true， 否则返回false;

void FireWork() {
    unique_lock<timed_lock> lck(mtx, std::defer_lock);
    while (!lck.try_lock_for(chrono::milliseconds(200))) {
        cout<<"-";
    }
    this_thread::sleep_for(chrono::milliseconds(1000));
    cout<<"*"<<endl;
}

mutex_type* release() noexcept;

void task() {
    unique_lock<mutex> lck(mtx);
    ++count;
    PrintCountAndUnlock(lck.release());
}
void PrintCountAndUnlock(mutex* p_mtx) {
    cout<<count<<endl;
    p_mtx.unlock();
}

void unlock();

调用管理的mutex type的成员函数unlock，并且将unique_lock的归属状态设为false;

void PrintThreadId(int id) {
    unique_lock<mutex> lck(mtx);
    lck.lock();
    cout<<"thread id is: "<<id<<endl;
    lock.unlock();
}

operator boo;

explicit operator bool() const noexcept;

返回一个object是否拥有一个锁；

如果是则返回true

~unique_lock();

如果对互斥量拥有锁，在析构之前会县调用unlock