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