【C++并发与多线程】 6_unique

unique_lock 取代 lock_guard

std::lock_guard 和 std::unique_lock 都能实现自动加锁与解锁功能。
std::unique_lock 内部持有 mutex 的状态(locked,unlocked)，因此比 lock_guard 使用更加灵活但同时更占用空间、速度更慢。

// unique_lock example
#include        // std::cout
#include          // std::thread
#include           // std::mutex, std::unique_lock

std::mutex mtx;           // mutex for critical section

void print_block (int n, char c) 
{
  // critical section (exclusive access to std::cout signaled by lifetime of lck):
  std::unique_lock lck (mtx);
  for (int i=0; i


输出：
**************************************************
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
unique_lock 的属性参数



属性
描述


 
通过调用成员lock来锁定互斥对象


try_lock
通过调用成员try_lock尝试锁定互斥对象


defer_lock
unique_lock 对象不会在构造时自动锁定互斥对象，将其初始化未不拥有锁


adopt_lock
unique_lock对象不会在构造时锁定互斥对象，而是假定调用线程已经拥有互斥锁的所有权。




try_to_lock

std::unique_locklck (mutex,std::try_to_lock);

defer_lock

std::unique_locklck (mutex,std::defer_lock);
// ...
lck.lock();
// ...
lck.unlock();
// ...
lck.lock();

adopt_lock

mutex.lock();
// ......
std::unique_locklck (mutex,std::adopt_lock);
std::unique_lock 的成员函数
std::unique_lock::owns_lock()
bool owns_lock() const noexcept;
功能：拥有锁

返回对象是否拥有锁。
如果托管互斥对象以由 unique_lock 对象锁定，并且此后未解锁或释放，则返回 true。
在其它情况下，都返回 false。
这是 unique_lock :: operator bool的别名。

参数

无

返回值

如果对象在托管互斥对象上拥有锁，则返回 true, 否则返回 false。

// unique_lock::operator= example
#include        // std::cout
#include          // std::vector
#include          // std::thread
#include           // std::mutex, std::unique_lock, std::try_to_lock

std::mutex mtx;           // mutex for critical section

void print_star () {
  std::unique_lock lck(mtx,std::try_to_lock);
  // print '*' if successfully locked, 'x' otherwise:
  if (lck.owns_lock())
    std::cout << '*';
  else
    std::cout << 'x';

    std::cout << '\n';
}

int main ()
{
  std::vector threads;
  for (int i=0; i<10; ++i)
    threads.emplace_back(print_star);

  for (auto& x: threads) x.join();

  return 0;
}
输出：
*
*
*
*
*
*
*
*
*
*
std::unique_lock::lock()
template 
  void lock (Mutex1& a, Mutex2& b, Mutexes&... cde);
功能：锁定多个互斥锁

锁定所有作为参数的对象，并在必要时阻塞调用线程。
该函数用一个未指定序列去调用他们的 lock, try_lock 和 unlock 成员锁定对象，以确保所有参数在返回时都被锁定（不产生任何死锁）。
如果该函数无法锁定所有对象（例如，由于内部调用之一引发了异常），则该函数会在失败之前首先解锁成功锁定的所有对象（如果有）。

参数
a, b, cde

尝试锁定的对象，Mutex1，Mutex2和Mutexes 应该是可以锁定的类型。

返回值

无

std::unique_lock::unlock()
void unlock();
功能：解锁互斥锁

调用托管互斥对象的成员解锁，并将拥有状态设置为 false。
如果在调用之前拥有状态为 false，则该函数将引发 system_error 异常。

返回值

无

// unique_lock::lock/unlock
#include        // std::cout
#include          // std::thread
#include           // std::mutex, std::unique_lock, std::defer_lock

std::mutex mtx;           // mutex for critical section

void print_thread_id (int id) {
  std::unique_lock lck (mtx,std::defer_lock);
  // critical section (exclusive access to std::cout signaled by locking lck):
  lck.lock();
  std::cout << "thread #" << id << '\n';
  lck.unlock();
}

int main ()
{
  std::thread threads[10];
  // spawn 10 threads:
  for (int i=0; i<10; ++i)
    threads[i] = std::thread(print_thread_id,i+1);

  for (auto& th : threads) th.join();

  return 0;
}
输出：
thread #1
thread #2
thread #4
thread #3
thread #7
thread #5
thread #6
thread #10
thread #8
thread #9
std::unique_lock::try_lock()
template 
  int try_lock (Mutex1& a, Mutex2& b, Mutexes&... cde);
功能：尝试去锁定多个对象

尝试使用其 try_lock 成员函数锁定所有作为参数传递的对象（非阻塞）。
该函数为每个参数（首先是a，然后是b，最后是cde中的其它参数，以相同的顺序）调用 try_lock 成员函数，直到所有调用都成功或者其中一个调用失败（通过返回错误或引发异常）。
如果函数由于调用失败而结束，则对 try_lock 调用成功的所有对象都将解锁，并且该函数返回锁定失败的对象的参数顺序号。不会对参数列表中的其余对象执行进一步的调用。

参数
a, b, cde

尝试锁定的对象，Mutex1，Mutex2和Mutexes 应该是可以锁定的类型。

返回值

如果函数成功锁定了所有对象，则返回 -1。
否则，该函数将返回未定锁定对象的索引（0表示a,1表示b）

// unique_lock::try_lock example
#include        // std::cout
#include          // std::vector
#include          // std::thread
#include           // std::mutex, std::unique_lock, std::defer_lock

std::mutex mtx;           // mutex for critical section

void print_star () {
  std::unique_lock lck(mtx,std::defer_lock);
  // print '*' if successfully locked, 'x' otherwise:
  if (lck.try_lock())
    std::cout << '*';
  else
    std::cout << 'x';

    std::cout << '\n';
}

int main ()
{
  std::vector threads;
  for (int i=0; i<10; ++i)
    threads.emplace_back(print_star);

  for (auto& x: threads) x.join();

  return 0;
}
输出：
*
*
*
*
*
*
*
*
*
*
std::unique_lock::release()
mutex_type* release() noexcept;
功能：释放互斥锁

返回指向退管互斥对象的指针，从而释放对其的所有权。
调用之后， unique_lock 对象不再管理任何互斥对象（即，其状态与默认构造的状态相同）。
请注意，此函数不会锁定或解锁返回的互斥量。

参数

无

返回值

指向调用之前由 unique_lock 管理的互斥对象的指针。

// unique_lock::release example
#include        // std::cout
#include          // std::vector
#include          // std::thread
#include           // std::mutex, std::unique_lock

std::mutex mtx;
int count = 0;

void print_count_and_unlock (std::mutex* p_mtx) {
  std::cout << "count: " << count << '\n';
  p_mtx->unlock();
}

void task() {
  std::unique_lock lck(mtx);
  ++count;
  print_count_and_unlock(lck.release());
}

int main ()
{
  std::vector threads;
  for (int i=0; i<10; ++i)
    threads.emplace_back(task);

  for (auto& x: threads) x.join();

  return 0;
}
输出：
count: 1
count: 2
count: 3
count: 4
count: 5
count: 6
count: 7
count: 8
count: 9
count: 10
std::unique_lock::mutex
mutex_type* mutex() const noexcept;
功能：获取互斥量

返回指向托管互斥对象的指针。
请注意，unique_lock 不会释放对托管互斥量的所有权。即，如果它拥有互斥锁，则仍然负责在某个时刻释放锁（例如销毁它时）

参数

无

返回值
指向由 unique_lock 管理的互斥对象的指针。
// unique_lock::mutex example
#include        // std::cout
#include          // std::thread
#include           // std::mutex, std::unique_lock, std::defer_lock

class MyMutex : public std::mutex {
  int _id;
public:
  MyMutex (int id) : _id(id) {}
  int id() {return _id;}
};

MyMutex mtx (101);

void print_ids (int id) {
  std::unique_lock lck (mtx);
  std::cout << "thread #" << id << " locked mutex " << lck.mutex()->id() << '\n';
}

int main ()
{
  std::thread threads[10];
  // spawn 10 threads:
  for (int i=0; i<10; ++i)
    threads[i] = std::thread(print_ids,i+1);

  for (auto& th : threads) th.join();

  return 0;
}
输出：
thread #1 locked mutex 101
thread #2 locked mutex 101
thread #3 locked mutex 101
thread #4 locked mutex 101
thread #7 locked mutex 101
thread #5 locked mutex 101
thread #10 locked mutex 101
thread #8 locked mutex 101
thread #9 locked mutex 101
thread #6 locked mutex 101
std::unique_lock::operator =
move (1)
unique_lock& operator= (unique_lock&& x) noexcept;

copy [deleted] (2)
unique_lock& operator= (const unique_lock&) = delete;
功能：移动赋值

用 x 中的一个替换托管的互斥对象，包括其拥有的状态。
如果对象在调用之前在其托管互斥对象上拥有锁，则在替换之前将调用其unlock成员。
x 保持与默认构造相同的状态（指没有托管对象）。
unique_lock 对象无法赋值。

参数
x

另一个 unique_lock 对象。

返回值

*this。

// unique_lock::operator= example
#include        // std::cout
#include          // std::thread
#include           // std::mutex, std::unique_lock

std::mutex mtx;           // mutex for critical section

void print_fifty () {
  std::unique_lock lck;         // default-constructed
  lck = std::unique_lock(mtx);  // move-assigned
  for (int i=0; i<50; ++i)
  {
      if (lck.owns_lock())
        std::cout << '*';
      else
         std::cout << '#';
  }
  std::cout << '\n';
}

int main ()
{
  std::thread th1 (print_fifty);

  th1.join();

  return 0;
}
输出：
**************************************************

【C++并发与多线程】 6_unique_lock 类模板详解

unique_lock 取代 lock_guard

unique_lock 的属性参数

std::unique_lock 的成员函数

std::unique_lock::owns_lock()

功能：拥有锁

参数

返回值

std::unique_lock::lock()

功能：锁定多个互斥锁

参数

返回值

std::unique_lock::unlock()

功能：解锁互斥锁

返回值

std::unique_lock::try_lock()

功能：尝试去锁定多个对象

参数

返回值

std::unique_lock::release()

功能：释放互斥锁

参数

返回值

std::unique_lock::mutex

功能：获取互斥量

参数

返回值

std::unique_lock::operator =

功能：移动赋值

参数

返回值

你可能感兴趣的:(c++后端)

属性	描述
	通过调用成员lock来锁定互斥对象
try_lock	通过调用成员try_lock尝试锁定互斥对象
defer_lock	unique_lock 对象不会在构造时自动锁定互斥对象，将其初始化未不拥有锁
adopt_lock	unique_lock对象不会在构造时锁定互斥对象，而是假定调用线程已经拥有互斥锁的所有权。