C++并行处理支持库 之五
- mutex包装器(wrapper)
- std::lock_guard
- 构造器
- 应用实例
- std::scoped_lock
- 构造器
- 应用实例
- std::unique_lock
- 构造器
- 应用实例
- std::shared_lock
- 构造器
- 应用实例
mutex包装器(wrapper)
std::lock_guard
template< class Mutex > class lock_guard;
lock_guard 类是一个互斥锁包装器，它提供了一种方便的RAII样式机制，用于在作用域块的持续时间内，拥有互斥锁。
当创建 lock_guard 对象时，它会尝试获取所给定互斥体的所有权。当控制权离开创建 lock_guard 对象的范围时，lock_guard 将被破坏，并释放互斥锁。
lock_guard 类是不可复制的。
构造器
explicit lock_guard( mutex_type& m );
lock_guard( mutex_type& m, std::adopt_lock_t t );
lock_guard( const lock_guard& ) = delete;
获取给定mutex的所有权。
- 有效调用m.lock()。
- 获取mutex m的所有权，但不尝试锁定它。如果当前线程在 m 上没有持有非共享锁，即通过 lock、try_lock、try_lock_for 或 try_lock_until 获取的锁，则行为未定义。
- 删除复制构造函数。
如果 m 在 lock_guard 对象之前被销毁，则行为未定义。
参数
m - mutex，它的所有权被获取
t - 用于选择构造函数的非锁定版本的标记参数
应用实例
下列代码说明lock_guard的使用。
#include <iostream>
#include <mutex>
#include <thread>
#include <syncstream>using namespace std;volatile int count = 0;
mutex m;void safe_increment(int iterations)
{const lock_guard<std::mutex> lock(m);while (iterations-- > 0)count = count + 1;cout << "thread #" << this_thread::get_id() << ", count: " << count << '\n';
}int main()
{thread t1(safe_increment, 100);thread t2(safe_increment, 200);thread t3(safe_increment, 200);t1.join();t2.join();t3.join();
}
上述代码运行屏幕输出
thread #138501628626624, count: 200
thread #138501649598144, count: 300
thread #138501639112384, count: 500
std::scoped_lock
template< class… MutexTypes > class scoped_lock;
scoped_lock类是一个mutex包装器，它提供了一种方便的RAII风格的机制，用于在作用域块的持续时间内，拥有零个或多个mutex。
当创建scoped_lock对象时，它会尝试获取给定的mutex的所有权。当控制权离开创建scoped_lock对象的作用域时，scoped_lock将被破坏，并释放互斥锁。如果给出了多个mutex，则使用死锁避免算法，就像 std::lock 一样。
scoped_lock 类是不可复制的。
构造器
explicit scoped_lock( MutexTypes&… m );
scoped_lock( std::adopt_lock_t, MutexTypes&… m );
scoped_lock( const scoped_lock& ) = delete;
获取给定互斥体 m 的所有权。
- 如果 sizeof…(MutexTypes) == 0，则不执行任何操作。
如果 sizeof…(MutexTypes) == 1，则有效调用 m.lock()。
否则，有效地调用 std::lock(m…)。 - 获取mutex m… 的所有权，但不会锁定其中任何一个。构造器的行为是未定义的，除非当前线程在 m… 中的每个对象上持有非共享锁（即通过 lock、try_lock、try_lock_for 或 try_lock_until 获取的锁）。
- 复制构造函数已经删除。
如果 m 在scoped_lock 对象之前被销毁，则构造器行为未定义。
应用实例
下列代码说明如何在程序中使用scoped_lock。
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <cstdlib>using namespace std;mutex m1;
mutex m2;class CyclicBuffer {
private:std::vector<int> buffer;size_t head;size_t tail;size_t capacity;public:CyclicBuffer(size_t capacity) : capacity(capacity), buffer(capacity), head(0), tail(0) {}bool push(int value) {if (is_full()) {return false;}buffer[tail] = value;tail = (tail + 1) % capacity;return true;}int pop() {if (is_empty()) {return -1; }int value = buffer[head];head = (head + 1) % capacity;return value;}bool resize(int sz) {buffer.resize(sz);capacity = sz;cout << "New Capacity: " << capacity << endl;return true; }private:bool is_empty() const {return head == tail;}bool is_full() const {return (tail + 1) % capacity == head;}
};void send_thread(CyclicBuffer &buff, int value)
{int secs_n = rand() % 10 + 1;sleep(secs_n);lock_guard<std::mutex> lk(m1);while (true) {bool success = buff.push(value);if (success == true)break;sleep(1);}
}void receive_thread(CyclicBuffer &buff)
{int secs_n = rand() % 10 + 1;sleep(secs_n);lock_guard<std::mutex> lk(m2);int value;while (true) {value = buff.pop();if (value != -1)break;sleep(1);}cout << "Receive ID: " << this_thread::get_id() << ", value:" << value << endl;
}void change_thread(CyclicBuffer &buff)
{sleep(3);scoped_lock lock(m1, m2);buff.resize(5);
}int main()
{CyclicBuffer cbuff(3);vector<std::thread> threads;srand(time(0));for (int i=0; i < 10; i++)threads.emplace_back(send_thread, ref(cbuff), i+5);for (int i=0; i < 10; i++)threads.emplace_back(receive_thread, ref(cbuff));threads.emplace_back(change_thread, ref(cbuff));for (auto& thread : threads)thread.join();
}
上述代码运行屏幕输出
Receive ID: 125219144468160, value:7
Receive ID: 125219092039360, value:10
Receive ID: 125219050096320, value:11
Receive ID: 125219113010880, value:14
Receive ID: 125219102525120, value:6
New Capacity: 5
Receive ID: 125219123496640, value:5
Receive ID: 125219060582080, value:0
Receive ID: 125219071067840, value:0
Receive ID: 125219133982400, value:8
Receive ID: 125219081553600, value:9
std::unique_lock
template< class Mutex > class unique_lock;
unique_lock 类是通用mutex所有权包装器，允许延迟锁定、时间受限的锁定尝试、递归锁定、锁所有权转移，而且可以与条件变量一起使用。
unique_lock类是可移动的，但不可复制。它满足 MoveConstructible 和 MoveAssignable 的要求，但不满足 CopyConstructible 或 CopyAssignable 的要求。
unique_lock 类满足 BasicLockable 要求。如果Mutex满足Lockable要求，unique_lock也满足Lockable要求（例如：可以在std::lock中使用）；如果 Mutex 满足 TimedLockable 要求，则 unique_lock 也满足 TimedLockable 要求。
构造器
| 构造器 | 意义 |
|---|---|
| unique_lock() noexcept | 构造一个没有关联互斥锁的 unique_lock |
| unique_lock( unique_lock&& other ) noexcept | 移动构造函数。使用 other 的内容初始化 unique_lock。留下 other 没有关联的mutex。 |
| explicit unique_lock( mutex_type& m ) | 构造一个 unique_lock，其中m作为关联的mutex。通过调用 m.lock() 锁定关联的mutex |
| unique_lock( mutex_type& m, std::defer_lock_t t ) noexcept | 构造一个 unique_lock，其中m作为关联的mutex。不锁定关联的mutex |
| unique_lock( mutex_type& m, std::try_to_lock_t t ) | 构造一个 unique_lock，其中m作为关联的mutex。尝试通过调用 m.try_lock() 锁定关联的mutex，但不阻塞。如果Mutex不满足Lockable，则行为未定义 |
| unique_lock( mutex_type& m, std::adopt_lock_t t ) | 构造一个 unique_lock，其中m作为关联的mutex。假设调用线程已经在 m 上持有非共享锁，即通过 lock、try_lock、try_lock_for 或 try_lock_until 获取的锁。如果不是这样，则行为未定义 |
| template< class Rep, class Period > unique_lock( mutex_type& m, const std::chrono::duration<Rep, Period>& timeout_duration ) | 构造一个 unique_lock，其中m作为关联的mutex。尝试通过调用 m.try_lock_for(timeout_duration) 来锁定关联的mutex。阻塞直到指定的 timeout_duration 已过，或获取锁。阻塞时间可能超过 timeout_duration。如果 Mutex 不满足 TimedLockable，则行为未定义 |
| template< class Clock, class Duration > unique_lock( mutex_type& m, const std::chrono::time_point<Clock, Duration>& timeout_time ) | 构造一个 unique_lock，其中m作为关联的mutex。尝试通过调用 m.try_lock_until(timeout_time) 来锁定关联的mutex。阻塞直到达到指定的 timeout_time，或获取锁。阻塞时间可能会超过达到 timeout_time 为止。如果 Mutex 不满足 TimedLockable，则行为未定义 |
应用实例
下列代码说明如何使用unique_lock。
#include <iostream>
#include <mutex>
#include <thread>
#include <utility>
#include <vector>using namespace std;mutex m_a, m_b, m_c;
int a, b, c = 1;void update()
{{ // Note: std::lock_guard or atomic<int> can be used insteadunique_lock<std::mutex> lk(m_a);++a;}{ // Note: see std::lock and std::scoped_lock for details and alternativesunique_lock<std::mutex> lk_b(m_b, std::defer_lock);unique_lock<std::mutex> lk_c(m_c, std::defer_lock);lock(lk_b, lk_c);b = exchange(c, b + c);}
}int main()
{vector<thread> threads;for (unsigned i = 0; i < 12; ++i)threads.emplace_back(update);for (auto& i : threads)i.join();cout << a << "'th and " << a + 1 << "'th Fibonacci numbers: "<< b << " and " << c << '\n';
}
12'th and 13'th Fibonacci numbers: 144 and 233
std::shared_lock
template< class Mutex > class shared_lock;
shared_lock类是一个通用共享mutex所有权包装器，允许延迟锁定、定时锁定和锁所有权转移。锁定shared_lock会在共享模式下，锁定关联的共享mutex，要在独占模式下锁定它，可以使用std::unique_lock。
Shared_lock 类是可移动的，但不可复制。它满足 MoveConstructible 和 MoveAssignable 的要求，但不满足 CopyConstructible 或 CopyAssignable 的要求。
shared_lock满足Lockable要求。如果Mutex满足SharedTimedLockable要求，那么shared_lock也满足TimedLockable要求。
为了在共享所有权模式下，在共享mutex中等待，可以使用 std::condition_variable_any。
std::condition_variable 需要 std::unique_lock，因此只能在唯一所有权模式下等待。
构造器
| 构造器 | 意义 |
|---|---|
| shared_lock() noexcept | 构造一个无关联mutex的共享锁 |
| shared_lock( shared_lock&& other ) noexcept | 移动构造函数。使用other的内容初始化共享锁。other失去关联的mutex。 |
| explicit shared_lock( mutex_type& m ) | 构造一个共享锁，其中m作为关联的mutex。通过调用 m.lock_shared() 以共享模式锁定关联的mutex |
| shared_lock( mutex_type& m, std::defer_lock_t t ) noexcept | 构造一个共享锁，其中 m 作为关联的mutex。不锁定关联的mutex |
| shared_lock( mutex_type& m, std::try_to_lock_t t ) | 构造一个共享锁，其中 m 作为关联的mutex。尝试通过调用 m.try_lock_shared()，以共享模式锁定关联的mutex而不阻塞 |
| shared_lock( mutex_type& m, std::adopt_lock_t t ) | 构造一个共享锁，其中 m 作为关联的mutex。假设调用线程已经在 m 上持有共享锁，即由 lock_shared、try_lock_shared、try_lock_shared_for 或 try_lock_shared_until 获取的锁。如果不是这样，则行为未定义 |
| template< class Rep, class Period > shared_lock( mutex_type& m, const std::chrono::duration<Rep,Period>& timeout_duration ); | 构造一个共享锁，其中 m 作为关联的mutex。尝试通过调用 m.try_lock_shared_for(timeout_duration) 以共享模式锁定关联的互斥锁，该模式会阻塞，直到指定的 timeout_duration 已过或获取锁。阻塞时间可能超过 timeout_duration。如果 Mutex 不满足 SharedTimedLockable 要求，则行为未定义。 |
| template< class Clock, class Duration > shared_lock( mutex_type& m, const std::chrono::time_point<Clock,Duration>& timeout_time ) | 构造一个共享锁，其中 m 作为关联的mutex。尝试通过调用 m.try_lock_shared_until(timeout_time) 以共享模式锁定关联的互斥锁，该方法会阻塞，直到达到指定的 timeout_time 或获取锁（以先到者为准）。阻塞时间可能会超过达到 timeout_time 为止。如果 Mutex 不满足 SharedTimedLockable 要求，则行为未定义 |
应用实例
下面展示一些 内联代码片。
#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <string>using namespace std;class Personnel
{
public:Personnel() : name(""), age(0), salary(0) {}Personnel(string name_s, int age_i, float salary_f) : name(name_s), age(age_i), salary(salary_f){}Personnel& operator=(const Personnel& other){cout << "assign operator" << endl;// requires exclusive ownership to write to *thisstd::unique_lock<std::shared_timed_mutex> lhs(mut, std::defer_lock);// requires shared ownership to read from otherstd::shared_lock<std::shared_timed_mutex> rhs(other.mut, std::defer_lock);std::lock(lhs, rhs);/* assign data */name = other.name;age = other.age;salary = other.salary;return *this;}string name;int age;float salary;private:mutable shared_timed_mutex mut;
};int main()
{Personnel r("John", 30, 3500.00);Personnel t;t = r;cout << "name: " << t.name << ", age: " << t.age << ", salary: " << t.salary << endl;
}
assign operator
name: John, age: 30, salary: 3500
