Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://cplusplus.com/unique_lock below:

class template

<mutex>

template <class Mutex> class unique_lock;

Unique lock

On construction (or by move-assigning to it), the object acquires a mutex object, for whose locking and unlocking operations becomes responsible.

The object supports both states: locked and unlocked.

This class guarantees an unlocked status on destruction (even if not called explicitly). Therefore it is especially useful as an object with automatic duration, as it guarantees the mutex object is properly unlocked in case an exception is thrown.

Note though, that the unique_lock object does not manage the lifetime of the mutex object in any way: the duration of the mutex object shall extend at least until the destruction of the unique_lock that manages it.

Mutex

A mutex-like type.
It shall be a basic lockable type, such as mutex (see BasicLockable for requirements).

(constructor)

Construct unique_lock (public member function)

(destructor)

Destroy unique_lock (public member function)

lock

Lock mutex (public member function)

try_lock

Lock mutex if not locked (public member function)

try_lock_for

Try to lock mutex during time span (public member function)

try_lock_until

Try to lock mutex until time point (public member function)

unlock

Unlock mutex (public member function)

operator=

Move-assign unique_lock (public member function)

swap

Swap unique locks (public member function)

release

Release mutex (public member function)

owns_lock

Owns lock (public member function)

operator bool

Return whether it owns a lock (public member function)

mutex

Get mutex (public member function)

swap (unique_lock)

Swap locks (function)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// unique_lock example
#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // 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<std::mutex> lck (mtx);
  for (int i=0; i<n; ++i) { std::cout << c; }
  std::cout << '\n';
}

int main ()
{
  std::thread th1 (print_block,50,'*');
  std::thread th2 (print_block,50,'$');

  th1.join();
  th2.join();

  return 0;
}

**************************************************
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4