文章目录
1 与 C++11 多线程相关的头文件
C++11 新标准中引入了五个头文件来支持多线程编程,他们分别是<atomic> ,<thread>,<mutex>,<condition_variable>
和<future>
。
<atomic>
:该头文主要声明了两个类,std::atomic
和std::atomic_flag
,另外还声明了一套 C 风格的原子类型和与 C 兼容的原子操作的函数。<thread>
:该头文件主要声明了std::thread
类,另外std::this_thread
命名空间也在该头文件中。<mutex>
:该头文件主要声明了与互斥量(mutex
)相关的类,包括std::mutex
系列类,std::lock_guard
,std::unique_lock
, 以及其他的类型和函数。<condition_variable>
:该头文件主要声明了与条件变量相关的类,包括std::condition_variable
和std::condition_variable_any
。<future>
:该头文件主要声明了std::promise
,std::package_task
两个 Provider 类,以及std::future
和std::shared_future
两个 Future 类,另外还有一些与之相关的类型和函数,std::async()
函数就声明在此头文件中。
2. std::thread
std::thread
在 <thread>
头文件中声明
2.1 std::thread
构造
default(1) | thread() noexcept ; |
---|---|
initialization(2) | template <class Fn, class …Args> explicit thread(Fn &&fn, Args && …args); |
copy [deleted] (3) | thread (const thread &) = delete; |
move(4) | thread (thread&& x) noexcept ; |
- 默认构造函数,创建一个空的 thread 执行对象。
- 初始化构造函数,创建一个 thread对象,该 thread对象可被 joinable,新产生的线程会调用 fn 函数,该函数的参数由 args 给出。
- 拷贝构造函数(被禁用),意味着 thread 不可被拷贝构造。
- move 构造函数,move 构造函数,调用成功之后 x 不代表任何 thread 执行对象。
注意:可被 joinable 的 thread 对象必须在他们销毁之前被主线程 join 或者将其设置为 detached.
示例:
#include <iostream>
#include <utility>
#include <thread>
#include <chrono>
#include <functional>
#include <atomic>
void f1(int n)
{
for (int i = 0; i < 5; ++i) {
std::cout << "Thread " << n << " executing\n";
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
}
void f2(int& n)
{
for (int i = 0; i < 5; ++i) {
std::cout << "Thread 2 executing\n";
++n;
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
}
int main()
{
int n = 0;
std::thread t1; // t1 is not a thread
std::thread t2(f1, n + 1); // pass by value
std::thread t3(f2, std::ref(n)); // pass by reference
std::thread t4(std::move(t3)); // t4 is now running f2(). t3 is no longer a thread
t2.join();
t4.join();
std::cout << "Final value of n is " << n << '\n';
}
2.2 move 赋值操作
move (1) | thread &operator = (thread&& rhs)noexcept; |
---|---|
copy [deleted] (2) | thread& operator= (const thread&) = delete; |
- move 赋值操作: 如果当前对象不可joinable,需要传递右值引用 (rhs)给move赋值操作;如果当前对象可被joinable,则terminate()报错。
- 拷贝赋值操作被禁用,thread 对象不可被拷贝。
示例:
#include <stdio.h>
#include <stdlib.h>
#include <chrono> // std::chrono::seconds
#include <iostream> // std::cout
#include <thread> // std::thread, std::this_thread::sleep_for
void thread_task(int n) {
std::this_thread::sleep_for(std::chrono::seconds(n));
std::cout << "hello thread "
<< std::this_thread::get_id()
<< " paused " << n << " seconds" << std::endl;
}
/*
* === FUNCTION =========================================================
* Name: main
* Description: program entry routine.
* ========================================================================
*/
int main(int argc, const char *argv[])
{
std::thread threads[5];
std::cout << "Spawning 5 threads...\n";
for (int i = 0; i < 5; i++) {
threads[i] = std::thread(thread_task, i + 1);
}
std::cout << "Done spawning threads! Now wait for them to join\n";
for (auto& t: threads) {
t.join();
}
std::cout << "All threads joined.\n";
return EXIT_SUCCESS;
} /* ---------- end of function main ---------- */
2.3 其他成员函数
- get_id 获取线程ID
如果线程对象是joinable
,则该函数返回一个唯一标识线程的值。
如果线程对象不是joinable
,则该函数返回成员类型为thread :: id的默认构造的对象。
id get_id() const noexcept;
//example
std::this_thread::get_id()
joinable
判断线程是否joinable
如果一个线程对象表示执行线程,则该对象是joinable。
在以下任何情况下,线程对象均不是joinable:- 如果他是默认构造的
- 如果已从中移出(构造另一个线程对象或为其分配)
- 如果已调用其成员join或detach。
bool joinable() const noexcept;
join
线程执行完成后,该函数返回。
这将使该函数返回的时刻与线程中所有操作的完成同步:阻塞调用该函数的线程的执行,直到构造函数上调用的函数返回为止(如果尚未返回)。
调用此函数后,线程对象变得不可连接,并且可以安全地销毁。
void join();
detach
从调用线程中分离对象所代表的线程,从而使它们彼此独立执行。
两个线程继续运行,而不会阻塞或以任何方式进行同步。请注意,当任何一个执行结束时,其资源将被释放。
调用此函数后,线程对象变得不可连接,并且可以安全地销毁。
void detach();
swap()
用x交换对象的状态。
void swap (thread& x) noexcept;
native_handle()
获取native handle
如果库实现支持,则该成员函数仅存在于类线程中。
如果存在,它将返回一个值,该值用于访问与线程关联的特定于实现的信息。
native_handle_type native_handle();
hardware_concurrency()
检测硬件并发
返回硬件线程上下文的数量。
此值的解释是特定于系统和实现的,可能不准确,而只是一个近似值。
请注意,这不需要与系统中可用的处理器或内核的实际数量相匹配:系统可以为每个处理单元支持多个线程,或限制对程序的资源访问。
如果此值不可计算或定义不正确,则该函数返回0。
static unsigned hardware_concurrency() noexcept;
3.std::mutex
Mutex 又称互斥量,C++ 11中与 Mutex 相关的类(包括锁类型)和函数都声明在 <mutex>
头文件中,所以如果你需要使用 std::mutex,就必须包含 <mutex>
头文件。
3.1 <mutex>
头文件
-
Mutex 系列类(4)
std::mutex
,最基本的mutex类std::recursive_mutex
,递归 Mutex 类。std::time_mutex
,定时 Mutex 类。std::recursive_timed_mutex
,定时递归 Mutex 类。
-
Lock 类(2)
std::lock_guard
,与 Mutex RAII 相关,方便线程对互斥量上锁。std::unique_lock
,与 Mutex RAII 相关,方便线程对互斥量上锁,但提供了更好的上锁和解锁控制。
-
其他类型
std::once_flag
std::adopt_lock_t
std::defer_lock_t
std::try_to_lock_t
-
函数
std::try_lock
,尝试同时对多个互斥量上锁。std::lock
,可以同时对多个互斥量上锁。std::call_once
,如果多个线程需要同时调用某个函数,call_once 可以保证多个线程对该函数只调用一次。
3.2 std::mutex
下面以 std::mutex 为例介绍 C++11 中的互斥量用法。
std::mutex
是C++11 中最基本的互斥量,std::mutex
对象提供了独占所有权的特性——即不支持递归地对 std::mutex
对象上锁,而 std::recursive_lock
则可以递归地对互斥量对象上锁。
std::mutex
的成员函数
-
构造函数,
std::mutex
不允许拷贝构造,也不允许move
拷贝,最初产生的 mutex 对象是处于 unlocked 状态的。 -
lock()
,调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况:- 如果该互斥量当前没有被锁住,则调用线程将该互斥量锁住,直到调用 unlock之前,该线程一直拥有该锁。
- 如果当前互斥量被其他线程锁住,则当前的调用线程被阻塞住。
- 如果当前互斥量被当前调用线程锁住,则会产生死锁(deadlock)。
-
unlock()
, 解锁,释放对互斥量的所有权。 -
try_lock()
,尝试锁住互斥量,如果互斥量被其他线程占有,则当前线程也不会被阻塞。线程调用该函数也会出现下面 3 种情况:- 如果当前互斥量没有被其他线程占有,则该线程锁住互斥量,直到该线程调用 unlock 释放互斥量。
- 如果当前互斥量被其他线程锁住,则当前调用线程返回 false,而并不会被阻塞掉。
- 如果当前互斥量被当前调用线程锁住,则会产生死锁(deadlock)。
示例:
#include <iostream> // std::cout
#include <thread> // std::thread
#include <mutex> // std::mutex
volatile int counter(0); // non-atomic counter
std::mutex mtx; // locks access to counter
void attempt_10k_increases() {
for (int i=0; i<10000; ++i) {
if (mtx.try_lock()) { // only increase if currently not locked:
++counter;
mtx.unlock();
}
}
}
int main (int argc, const char* argv[]) {
std::thread threads[10];
for (int i=0; i<10; ++i)
threads[i] = std::thread(attempt_10k_increases);
for (auto& th : threads) th.join();
std::cout << counter << " successful increases of the counter.\n";
return 0;
}
std::recursive_mutex
std::recursive_mutex
与 std::mutex
一样,也是一种可以被上锁的对象,但是和 std::mutex
不同的是,std::recursive_mutex
允许同一个线程对互斥量多次上锁(即递归上锁),来获得对互斥量对象的多层所有权,std::recursive_mutex
释放互斥量时需要调用与该锁层次深度相同次数的 unlock()
,可理解为 lock()
次数和 unlock()
次数相同,除此之外,std::recursive_mutex
的特性和 std::mutex
大致相同。
std::time_mutex
std::time_mutex
比 std::mutex
多了两个成员函数,try_lock_for()
,try_lock_until()
。
try_lock_for
函数接受一个时间范围,表示在这一段时间范围之内线程如果没有获得锁则被阻塞住(与std::mutex
的try_lock()
不同,try_lock
如果被调用时没有获得锁则直接返回 false),如果在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间内还是没有获得锁),则返回 false。try_lock_until
函数则接受一个时间点作为参数,在指定时间点未到来之前线程如果没有获得锁则被阻塞住,如果在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间内还是没有获得锁),则返回 false。
示例:
#include <iostream> // std::cout
#include <chrono> // std::chrono::milliseconds
#include <thread> // std::thread
#include <mutex> // std::timed_mutex
std::timed_mutex mtx;
void fireworks() {
// waiting to get a lock: each thread prints "-" every 200ms:
while (!mtx.try_lock_for(std::chrono::milliseconds(200))) {
std::cout << "-";
}
// got a lock! - wait for 1s, then this thread prints "*"
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
std::cout << "*\n";
mtx.unlock();
}
int main ()
{
std::thread threads[10];
// spawn 10 threads:
for (int i=0; i<10; ++i)
threads[i] = std::thread(fireworks);
for (auto& th : threads) th.join();
return 0;
}
std::recursive_timed_mutex
和 std:recursive_mutex
与 std::mutex
的关系一样,std::recursive_timed_mutex
的特性也可以从 std::timed_mutex
推导
std::lock_guard
与 Mutex RAII 相关,方便线程对互斥量上锁。
类lock_guard
是一个互斥包装器,它提供了一种方便的RAII风格的机制,可在作用域块的持续时间内拥有一个mutex。
创建一个lock_guard
对象时,它将尝试获取该互斥对象的所有权。当控制离开在其中创建lock_guard
对象的作用域时,将破坏lock_guard
并释放互斥量。
lock_guard
类是不可复制的。
示例
#include <iostream> // std::cout
#include <thread> // std::thread
#include <mutex> // std::mutex, std::lock_guard
#include <stdexcept> // std::logic_error
std::mutex mtx;
void print_even (int x) {
if (x%2==0) std::cout << x << " is even\n";
else throw (std::logic_error("not even"));
}
void print_thread_id (int id) {
try {
// using a local lock_guard to lock mtx guarantees unlocking on destruction / exception:
std::lock_guard<std::mutex> lck (mtx);
print_even(id);
}
catch (std::logic_error&) {
std::cout << "[exception caught]\n";
}
}
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;
}
std::unique_lock
与 Mutex RAII 相关,方便线程对互斥量上锁,但提供了更好的上锁和解锁控制。
类unique_lock
是一个通用的互斥体所有权包装器,它允许延迟锁定,受时间限制的锁定尝试,递归锁定,锁定所有权的转移以及与条件变量一起使用。
#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;
}
结果
4. Lock
C++11 标准为我们提供了两种基本的锁类型,分别如下:
std::lock_guard
,与 Mutex RAII 相关,方便线程对互斥量上锁。std::unique_lock
,与 Mutex RAII 相关,方便线程对互斥量上锁,但提供了更好的上锁和解锁控制。
另外还提供了几个与锁类型相关的 Tag 类,分别如下:
std::adopt_lock_t
一个空的标记类,定义如下:struct adopt_lock_t {};
该类型的常量对象adopt_lock
,定义如下:constexpr adopt_lock_t adopt_lock {};
通常作为参数传入给unique_lock
或lock_guard
的构造函数。std::defer_lock_t
一个空的标记类,定义如下:struct defer_lock_t {};
该类型的常量对象defer_lock
,定义如下:constexpr defer_lock_t defer_lock {};
通常作为参数传入给unique_lock
或lock_guard
的构造函数。std::try_to_lock_t
,
一个空的标记类,定义如下:struct try_to_lock_t {};
该类型的常量对象try_to_lock
,定义如下:
constexpr try_to_lock_t try_to_lock {};
通常作为参数传入给unique_lock
或lock_guard
的构造函数。
4.1 std::lock_guard
std::lock_gurad
是 C++11 中定义的模板类。
template <class Mutex> class lock_guard;
lock_guard
对象通常用于管理某个锁(Lock
)对象,因此与 Mutex RAII 相关,方便线程对互斥量上锁,即在某个lock_guard
对象的声明周期内,它所管理的锁对象会一直保持上锁状态;而lock_guard
的生命周期结束之后,它所管理的锁对象会被解锁(注:类似shared_ptr
等智能指针管理动态分配的内存资源 )。- 模板参数
Mutex
代表互斥量类型,例如std::mutex
类型,它应该是一个基本的 BasicLockable 类型,标准库中定义几种基本的 BasicLockable 类型,分别std::mutex
,std::recursive_mutex
,std::timed_mutex
,std::recursive_timed_mutex
以及std::unique_lock
。(注:BasicLockable 类型的对象只需满足两种操作,lock
和unlock
,另外还有 Lockable 类型,在 BasicLockable 类型的基础上新增了try_lock
操作,因此一个满足 Lockable 的对象应支持三种操作:lock
,unlock
和try_lock
;最后还有一种 TimedLockable 对象,在 Lockable 类型的基础上又新增了try_lock_for
和try_lock_until
两种操作,因此一个满足 TimedLockable 的对象应支持五种操作:lock
,unlock
,try_lock
,try_lock_for
,try_lock_until
)。 - 在
lock_guard
对象构造时,传入的 Mutex 对象(即它所管理的 Mutex 对象)会被当前线程锁住。在lock_guard
对象被析构时,它所管理的 Mutex 对象会自动解锁,由于不需要程序员手动调用lock
和unlock
对 Mutex 进行上锁和解锁操作,因此这也是最简单安全的上锁和解锁方式,尤其是在程序抛出异常后先前已被上锁的 Mutex 对象可以正确进行解锁操作,极大地简化了程序员编写与 Mutex 相关的异常处理代码。
值得注意的是,lock_guard
对象并不负责管理 Mutex 对象的生命周期,lock_guard
对象只是简化了 Mutex 对象的上锁和解锁操作,方便线程对互斥量上锁,即在某个 lock_guard 对象的声明周期内,它所管理的锁对象会一直保持上锁状态;而 lock_guard 的生命周期结束之后,它所管理的锁对象会被解锁。
4.1.1 std::lock_guard 构造函数
locking (1) | explicit lock_guard (mutex_type& m); |
---|---|
adopting (2) | lock_guard (mutex_type& m, adopt_lock_t tag); |
copy [deleted] (3) | lock_guard (const lock_guard&) = delete; |
- locking 初始化
lock_guard 对象管理 Mutex 对象 m,并在构造时对 m 进行上锁(调用 m.lock())。 - adopting初始化
lock_guard 对象管理 Mutex 对象 m,与 locking 初始化(1) 不同的是, Mutex 对象 m 已被当前线程锁住。 - 拷贝构造
lock_guard 对象的拷贝构造和移动构造(move construction)均被禁用,因此 lock_guard 对象不可被拷贝构造或移动构造。
示例
#include <iostream> // std::cout
#include <thread> // std::thread
#include <mutex> // std::mutex, std::lock_guard, std::adopt_lock
std::mutex mtx; // mutex for critical section
void print_thread_id (int id) {
mtx.lock();
std::lock_guard<std::mutex> lck(mtx, std::adopt_lock);
std::cout << "thread #" << id << '\n';
}
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;
}
在 print_thread_id 中,我们首先对 mtx 进行上锁操作(mtx.lock();
),然后用 mtx 对象构造一个 lock_guard 对象(std::lock_guard<std::mutex> lck(mtx, std::adopt_lock);
),注意此时 Tag 参数为 std::adopt_lock
,表明当前线程已经获得了锁,此后 mtx 对象的解锁操作交由 lock_guard 对象 lck 来管理,在 lck 的生命周期结束之后,mtx 对象会自动解锁。
lock_guard 最大的特点就是安全易于使用,请看下面例子(参考),在异常抛出的时候通过 lock_guard 对象管理的 Mutex 可以得到正确地解锁。
#include <iostream> // std::cout
#include <thread> // std::thread
#include <mutex> // std::mutex, std::lock_guard
#include <stdexcept> // std::logic_error
std::mutex mtx;
void print_even (int x) {
if (x%2==0) std::cout << x << " is even\n";
else throw (std::logic_error("not even"));
}
void print_thread_id (int id) {
try {
// using a local lock_guard to lock mtx guarantees unlocking on destruction / exception:
std::lock_guard<std::mutex> lck (mtx);
print_even(id);
}
catch (std::logic_error&) {
std::cout << "[exception caught]\n";
}
}
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;
}
4.2 std::unique_lock
但是 lock_guard
最大的缺点也是简单,没有给程序员提供足够的灵活度,因此,C++11 标准中定义了另外一个与 Mutex RAII 相关类 unique_lock
,该类与 lock_guard 类相似,也很方便线程对互斥量上锁,但它提供了更好的上锁和解锁控制。
顾名思义,unique_lock
对象以独占所有权的方式( unique owership)管理 mutex 对象的上锁和解锁操作,所谓独占所有权,就是没有其他的 unique_lock
对象同时拥有某个 mutex 对象的所有权。
在构造(或移动(move)赋值)时,unique_lock
对象需要传递一个 Mutex 对象作为它的参数,新创建的 unique_lock
对象负责传入的 Mutex 对象的上锁和解锁操作。
std::unique_lock
对象也能保证在其自身析构时它所管理的 Mutex 对象能够被正确地解锁(即使没有显式地调用 unlock 函数)。因此,和 lock_guard
一样,这也是一种简单而又安全的上锁和解锁方式,尤其是在程序抛出异常后先前已被上锁的 Mutex 对象可以正确进行解锁操作,极大地简化了程序员编写与 Mutex 相关的异常处理代码。
值得注意的是,unique_lock
对象同样也不负责管理 Mutex 对象的生命周期,unique_lock
对象只是简化了 Mutex 对象的上锁和解锁操作,方便线程对互斥量上锁,即在某个 unique_lock
对象的声明周期内,它所管理的锁对象会一直保持上锁状态;而 unique_lock
的生命周期结束之后,它所管理的锁对象会被解锁,这一点和 lock_guard
类似,但 unique_lock
给程序员提供了更多的自由,我会在下面的内容中给大家介绍 unique_lock
的用法。
另外,与 lock_guard
一样,模板参数 Mutex 代表互斥量类型,例如 std::mutex
类型,它应该是一个基本的 BasicLockable 类型,标准库中定义几种基本的 BasicLockable 类型,分别 std::mutex
, std::recursive_mutex
, std::timed_mutex
,std::recursive_timed_mutex
(以上四种类型均已在上一篇博客中介绍)以及 std::unique_lock
(本文后续会介绍 std::unique_lock
)。(注:BasicLockable 类型的对象只需满足两种操作,lock 和 unlock,另外还有 Lockable 类型,在 BasicLockable 类型的基础上新增了 try_lock
操作,因此一个满足 Lockable 的对象应支持三种操作:lock
,unlock
和 try_lock
;最后还有一种 TimedLockable 对象,在 Lockable 类型的基础上又新增了 try_lock_for
和 try_lock_until
两种操作,因此一个满足 TimedLockable 的对象应支持五种操作:lock
, unlock
, try_lock
, try_lock_for
, try_lock_until
)。
4.2.1 std::unique_lock 构造函数
std::unique_lock
的构造函数的数目相对来说比 std::lock_guard
多,其中一方面也是因为 std::unique_lock
更加灵活,从而在构造 std::unique_lock
对象时可以接受额外的参数。总的来说,std::unique_lock
构造函数如下:
default (1) | unique_lock() noexcept; |
---|---|
locking (2) | explicit unique_lock(mutex_type& m); |
try-locking (3) | unique_lock(mutex_type& m, try_to_lock_t tag); |
deferred (4) | unique_lock(mutex_type& m, defer_lock_t tag) noexcept; |
adopting (5) | unique_lock(mutex_type& m, adopt_lock_t tag); |
locking for (6) | template <class Rep, class Period> unique_lock(mutex_type& m, const chrono::duration<Rep,Period>& rel_time); |
locking until (7) | template <class Clock, class Duration> unique_lock(mutex_type& m, const chrono::time_point<Clock,Duration>& abs_time); |
copy [deleted] (8) | unique_lock(const unique_lock&) = delete; |
move (9) | unique_lock(unique_lock&& x); |
下面我们来分别介绍以上各个构造函数:
- 默认构造函数
新创建的 unique_lock 对象不管理任何 Mutex 对象。 - locking 初始化
新创建的 unique_lock 对象管理 Mutex 对象 m,并尝试调用m.lock()
对 Mutex 对象进行上锁,如果此时另外某个 unique_lock 对象已经管理了该 Mutex 对象 m,则当前线程将会被阻塞。 - try-locking 初始化
新创建的 unique_lock 对象管理 Mutex 对象 m,并尝试调用m.try_lock()
对 Mutex 对象进行上锁,但如果上锁不成功,并不会阻塞当前线程。 - deferred 初始化
新创建的 unique_lock 对象管理 Mutex 对象 m,但是在初始化的时候并不锁住 Mutex 对象。 m 应该是一个没有当前线程锁住的 Mutex 对象。 - adopting 初始化
新创建的 unique_lock 对象管理 Mutex 对象 m, m 应该是一个已经被当前线程锁住的 Mutex 对象。(并且当前新创建的 unique_lock 对象拥有对锁(Lock)的所有权)。 - locking 一段时间(duration)
新创建的unique_lock
对象管理 Mutex 对象 m,并试图通过调用m.try_lock_for(rel_time)
来锁住 Mutex 对象一段时间(rel_time)。 - locking 直到某个时间点(time point)
新创建的 unique_lock 对象管理 Mutex 对象m,并试图通过调用m.try_lock_until(abs_time)
来在某个时间点(abs_time)之前锁住 Mutex 对象。 - 拷贝构造 [被禁用]
unique_lock
对象不能被拷贝构造。 - 移动(move)构造
新创建的 unique_lock 对象获得了由 x 所管理的 Mutex 对象的所有权(包括当前 Mutex 的状态)。调用 move 构造之后, x 对象如同通过默认构造函数所创建的,就不再管理任何 Mutex 对象了。
综上所述,由 (2) 和 (5) 创建的 unique_lock 对象通常拥有 Mutex 对象的锁。而通过 (1) 和 (4) 创建的则不会拥有锁。通过 (3),(6) 和 (7) 创建的 unique_lock 对象,则在 lock 成功时获得锁。
#include <iostream> // std::cout
#include <thread> // std::thread
#include <mutex> // std::mutex, std::lock, std::unique_lock
// std::adopt_lock, std::defer_lock
std::mutex foo,bar;
void task_a () {
std::lock (foo,bar); // simultaneous lock (prevents deadlock)
std::unique_lock<std::mutex> lck1 (foo,std::adopt_lock);
std::unique_lock<std::mutex> lck2 (bar,std::adopt_lock);
std::cout << "task a\n";
// (unlocked automatically on destruction of lck1 and lck2)
}
void task_b () {
// foo.lock(); bar.lock(); // replaced by:
std::unique_lock<std::mutex> lck1, lck2;
lck1 = std::unique_lock<std::mutex>(bar,std::defer_lock);
lck2 = std::unique_lock<std::mutex>(foo,std::defer_lock);
std::lock (lck1,lck2); // simultaneous lock (prevents deadlock)
std::cout << "task b\n";
// (unlocked automatically on destruction of lck1 and lck2)
}
int main ()
{
std::thread th1 (task_a);
std::thread th2 (task_b);
th1.join();
th2.join();
return 0;
}
std::unique_lock 移动(move assign)赋值操作
std::unique_lock
支持移动赋值(move assignment),但是普通的赋值被禁用了
move (1) | unique_lock& operator= (unique_lock&& x) noexcept; |
---|---|
copy [deleted] (2) | unique_lock& operator= (const unique_lock&) = delete; |
移动赋值(move assignment)之后,由 x 所管理的 Mutex 对象及其状态将会被新的 std::unique_lock
对象取代。
如果被赋值的对象之前已经获得了它所管理的 Mutex 对象的锁,则在移动赋值(move assignment)之前会调用 unlock
函数释放它所占有的锁。
调用移动赋值(move assignment)之后, x 对象如同通过默认构造函数所创建的,也就不再管理任何 Mutex 对象了。请看下面例子
#include <iostream> // std::cout
#include <thread> // std::thread
#include <mutex> // std::mutex, std::unique_lock
std::mutex mtx; // mutex for critical section
void print_fifty (char c) {
std::unique_lock<std::mutex> lck; // default-constructed
lck = std::unique_lock<std::mutex>(mtx); // move-assigned
for (int i=0; i<50; ++i) { std::cout << c; }
std::cout << '\n';
}
int main ()
{
std::thread th1 (print_fifty,'*');
std::thread th2 (print_fifty,'$');
th1.join();
th2.join();
return 0;
}
4.2.2 std::unique_lock 主要成员函数
本节我们来看看 std::unique_lock
的主要成员函数。由于 std::unique_lock
比 std::lock_guard
操作灵活,因此它提供了更多成员函数。具体分类如下:
- 上锁/解锁操作:lock,try_lock,try_lock_for,try_lock_until 和 unlock
- 修改操作:移动赋值(move assignment)(前面已经介绍过了),交换(swap)(与另一个 std::unique_lock 对象交换它们所管理的 Mutex 对象的所有权),释放(release)(返回指向它所管理的 Mutex 对象的指针,并释放所有权)
- 获取属性操作:
owns_lock
(返回当前 std::unique_lock 对象是否获得了锁)、operator bool()
(与 owns_lock 功能相同,返回当前std::unique_lock
对象是否获得了锁)、mutex(返回当前std::unique_lock
对象所管理的 Mutex 对象的指针)。
std::unique_lock::lock
上锁操作,调用它所管理的 Mutex 对象的 lock 函数。如果在调用 Mutex 对象的 lock 函数时该 Mutex 对象已被另一线程锁住,则当前线程会被阻塞,直到它获得了锁。
该函数返回时,当前的 unique_lock
对象便拥有了它所管理的 Mutex 对象的锁。如果上锁操作失败,则抛出 system_error
异常。
// unique_lock::lock/unlock
#include <iostream> // std::cout
#include <thread> // std::thread
#include <mutex> // std::mutex, std::unique_lock, std::defer_lock
std::mutex mtx; // mutex for critical section
void print_thread_id (int id) {
std::unique_lock<std::mutex> 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(); //没有也没关系 unique_lock析构时会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;
}
std::unique_lock::try_lock
上锁操作,调用它所管理的 Mutex 对象的 try_lock 函数,如果上锁成功,则返回 true,否则返回 false。
#include <iostream> // std::cout
#include <vector> // std::vector
#include <thread> // std::thread
#include <mutex> // std::mutex, std::unique_lock, std::defer_lock
std::mutex mtx; // mutex for critical section
void print_star () {
std::unique_lock<std::mutex> lck(mtx,std::defer_lock);
// print '*' if successfully locked, 'x' otherwise:
if (lck.try_lock())
std::cout << '*';
else
std::cout << 'x';
}
int main ()
{
std::vector<std::thread> threads;
for (int i=0; i<500; ++i)
threads.emplace_back(print_star);
for (auto& x: threads) x.join();
return 0;
}
std::unique_lock::try_lock_for
上锁操作,调用它所管理的 Mutex 对象的 try_lock_for 函数,如果上锁成功,则返回 true,否则返回 false。
#include <iostream> // std::cout
#include <chrono> // std::chrono::milliseconds
#include <thread> // std::thread
#include <mutex> // std::timed_mutex, std::unique_lock, std::defer_lock
std::timed_mutex mtx;
void fireworks () {
std::unique_lock<std::timed_mutex> lck(mtx,std::defer_lock);
// waiting to get a lock: each thread prints "-" every 200ms:
while (!lck.try_lock_for(std::chrono::milliseconds(200))) {
std::cout << "-";
}
// got a lock! - wait for 1s, then this thread prints "*"
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
std::cout << "*\n";
}
int main ()
{
std::thread threads[10];
// spawn 10 threads:
for (int i=0; i<10; ++i)
threads[i] = std::thread(fireworks);
for (auto& th : threads) th.join();
return 0;
}
std::unique_lock::try_lock_until
std::unique_lock::unlock
解锁操作,调用它所管理的 Mutex 对象的 unlock 函数。
std::unique_lock::release
返回指向它所管理的 Mutex 对象的指针,并释放所有权。
#include <iostream> // std::cout
#include <vector> // std::vector
#include <thread> // std::thread
#include <mutex> // 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<std::mutex> lck(mtx);
++count;
print_count_and_unlock(lck.release());
}
int main ()
{
std::vector<std::thread> threads;
for (int i=0; i<10; ++i)
threads.emplace_back(task);
for (auto& x: threads) x.join();
return 0;
}
std::unique_lock::owns_lock
返回当前 std::unique_lock
对象是否获得了锁。
#include <iostream> // std::cout
#include <vector> // std::vector
#include <thread> // std::thread
#include <mutex> // std::mutex, std::unique_lock, std::try_to_lock
std::mutex mtx; // mutex for critical section
void print_star () {
std::unique_lock<std::mutex> lck(mtx,std::try_to_lock);
// print '*' if successfully locked, 'x' otherwise:
if (lck.owns_lock())
std::cout << '*';
else
std::cout << 'x';
}
int main ()
{
std::vector<std::thread> threads;
for (int i=0; i<500; ++i)
threads.emplace_back(print_star);
for (auto& x: threads) x.join();
return 0;
}
std::unique_lock::operator bool()
与 owns_lock
功能相同,返回当前 std::unique_lock
对象是否获得了锁。
#include <iostream> // std::cout
#include <vector> // std::vector
#include <thread> // std::thread
#include <mutex> // std::mutex, std::unique_lock, std::try_to_lock
std::mutex mtx; // mutex for critical section
void print_star () {
std::unique_lock<std::mutex> lck(mtx,std::try_to_lock);
// print '*' if successfully locked, 'x' otherwise:
if (lck)
std::cout << '*';
else
std::cout << 'x';
}
int main ()
{
std::vector<std::thread> threads;
for (int i=0; i<500; ++i)
threads.emplace_back(print_star);
for (auto& x: threads) x.join();
return 0;
}
std::unique_lock::mutex
返回当前 std::unique_lock
对象所管理的 Mutex 对象的指针。
#include <iostream> // std::cout
#include <thread> // std::thread
#include <mutex> // 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<MyMutex> 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;
}