【Example】C++ 标准库 std::thread 与 std::mutex-阿里云开发者社区

std::thread

std::thread 对象是 C++ 标准库当中最基本的多线程实现方式。

可以使用 thread 对象查看和管理应用程序中的执行线程。使用 thread 默认构造函数创建的对象不与任何执行线程相关联。使用 thread 可调用对象构造的对象将创建一个新的执行线程，并调用该中的可调用对象 thread。 Thread 对象可以移动，但不能复制。这就是执行线程只能与一个对象关联 thread 的原因。

每个执行线程都具有 thread::id 类型的唯一标识符。函数 this_thread::get_id 返回调用线程的标识符。成员函数 thread::get_id 返回由对象管理的线程的标识符 thread 。 thread::this_thread::get_id、thread::thread::get_id对于默认构造的对象，该方法返回一个对象，该对象的值对于所有默认构造的对象都相同，并且不同于在调用时可以联接的任何执行线程返回的值。

-- Microsoft Docs

std::thread 的头文件是：

#include <thread>

它的语法是：

【伪代码】std::threadt(FuncPtr, args1, ...);
【常规情况】std::threadt1(SortVectorMutex, std::ref(m), std::ref(vec1));

可以看到 std::thread 第一个参数为一个函数指针，后面则是该函数的参数。

当 std::thread 对象被初始化后，线程便立即开始执行。请注意是线程对象被初始化后，当使用默认空构造函数创建对象后，线程并没有被初始化，因此不会开始新的线程。

std::thread 的构造函数：

构造函数	操作	是否初始化
thread() noexcept;	默认空构造函数	否
template <class Fn, class... Args> explicit thread(Fn&& fn, Args&&... args);	初始化构造函数	是
thread(thread&& x) noexcept;	移动构造函数	视情况而定

额外备注：

1，std::thread 禁用了拷贝构造函数(thread(const thread&) = delete)，无法被拷贝构造。

2，std::thread 禁用了拷贝赋值重载(thread& operator=(const thread&) = delete)，无法被拷贝赋值。

3，std::thread 可以被移动赋值:

thread&operator=(thread&&rhs) noexcept;
std::threadt3(PrintID);
std::threadt4=std::move(t3);

4，std::thread 的移动构造本身不会对其进行初始化，如果被移动的对象本身是已初始化过的，那么它也是初始化的，反之亦然。

std::thread 的成员函数：

成员函数名	作用
join	阻塞等待到该线程结束。
detach	将线程从父进程分离，无法再通过 thread 对象对其进行操作，生命周期也脱离父进程，最终由操作系统进行资源回收。
joinable	检查线程是否可被阻塞等待。
get_id	获取该线程的唯一标识符。
swap	与指定 thread 对象进行互换操作。
native_handle	获取该线程的句柄。
hardware_concurrency	返回逻辑处理器数量。

以下展示了一个 std::thread 的最简单应用：

voidPrintID() {
cout<<"Thread ID: "<<std::this_thread::get_id() <<endl;    
return;
}
voidSortVector(vector<int>&vec) {
std::sort(vec.begin(), vec.end());
return;
}
intmain()
{
cout<<"Concurrency: "<<std::thread::hardware_concurrency() <<endl;
std::threadt1(PrintID);
std::threadt2(PrintID);
std::threadt3(PrintID);
vector<int>vec1{2, 1, 4, 8, 7, 5, 9, 3};
std::threadt4(SortVector, ref(vec1));
t4.join();
for (auto&i : vec1)
    {
cout<<i<<endl;
    }
t1.join();
t2.join();
t3.join();
returnEXIT_SUCCESS;
}

互斥量

在多线程操作当中，必然会出现对资源的并发访问，如果资源本身会因为多个线程同时操作而导致损坏不可用，这时就需要用到互斥量进行保护，也就是俗称的“锁”。

C++ 标准库当中提供了互斥量 mutex 系列，然而在实际开发当中更多是与 std::lock_guard 、std::unique_lock 配合使用。

但是，要想学会使用 std::lock_guard 和 std::unique_lock ，必须先了解基本的 std::mutex。

头文件：

#include <mutex>

在头文件当中提供了四种互斥量：

名称	作用
std::mutex	基本互斥量
std::timed_mutex	定时互斥量
std::recursive_mutex	递归互斥量
std::recursive_timed_mutex	定时递归互斥量

std::mutex 与 std::timed_mutex

先从最基本的 std::mutex 入手，其余互斥量皆是其变种。需要了解4个公共方法：

名称	作用
lock	阻止其他线程。如果已被其他线程阻止，则等待到被解除，再获取所有权并阻止。
unlock	立即解除阻止。
try_lock	尝试获取所有权，如果没有被其他线程阻止，则获取所有权并阻止。如果已被其他线程阻止，则返回false。
native_handle	返回 mutex 的句柄。

以下演示了一个对 std::mutex 最简单的使用：

voidSortVectorMutex(std::mutex&m, vector<int>&vec) {
m.lock();
std::sort(vec.begin(), vec.end());
m.unlock();
return;
}
voidPushVectorGuard(std::mutex&m, vector<int>&vec) {
m.lock();
vec.push_back(15);
vec.push_back(12);
vec.push_back(10);
m.unlock();
return;
}
intmain()
{
std::mutexm;
vector<int>vec1{2, 1, 4, 8, 7, 5, 9, 3};
std::threadt1(SortVectorMutex, ref(m), ref(vec1));
std::threadt2(PushVectorGuard, ref(m), ref(vec1));
t1.join();
t2.join();
for (auto&i : vec1)
    {
cout<<i<<endl;
    }
returnEXIT_SUCCESS;
}

可以看到，std::mutex 的操作仅仅对作用域的手动上锁与解锁。因此，也要牢记，lock 与 unlock 应成对使用避免造成死锁！

那么 std::timed_mutex 呢？无非就是在 mutex 的基础上增加了时间限制功能而已：

名称	作用
try_lock_for	等待到时间间隔
try_lock_until	等待到指定时间

演示代码：

voidSortVectorTimeMutex(std::timed_mutex&m, vector<int>&vec) {
std::chrono::millisecondstimes=std::chrono::milliseconds(100); // 100毫秒if (m.try_lock_for(times)){
std::sort(vec.begin(), vec.end());
m.unlock();
    }
return;
}

std::recursive_mutex 与 std::recursive_timed_mutex

std::mutex 及其变种不允许同一个线程对互斥量多次上锁，而 std::recursive_mutex 则允许。相应的 lock 次数也必须和 unlock 次数相等，否则仍然死锁。

例子：

classBrainBox{
public:
std::recursive_mutexrec_mutex;
public:
voidPrintHelloByte() {
this->rec_mutex.lock();
cout<<"Hello Byte"<<endl;
this->rec_mutex.unlock();
return;
    }
voidPrintHelloBlu() {
this->rec_mutex.lock();
this->PrintHelloByte(); // 对互斥量重复上锁cout<<"Hello Blu"<<endl;
this->rec_mutex.unlock();
return;
    }
};
intmain()
{
BrainBoxbox;
std::threadt1(&BrainBox::PrintHelloByte, &box);
std::threadt2(&BrainBox::PrintHelloBlu, &box);
t1.join();
t2.join();
returnEXIT_SUCCESS;
}

std::lock_guard 与 std::unique_lock

上面演示了C++标准库4种互斥量的原始用法。在实际开发当中，互斥量更多的是与 std::lock_guard 、std::unique_lock 相配合使用。

是一种更为智能、安全、现代的用法。std::lock_guard 和 std::unique_lock 设计上并存，并非功能上的替代关系。

std::lock_guard

首先，它是一个模板类，它的语法是：

std::lock_guard<std::mutex>locker(Mutex);

它需要一个互斥量对其进行初始化操作，它的特点是：根据 RAII 原则，在构造函数中上锁(创建即上锁)，在析构函数中解锁(销毁即解锁)。

voidPushVectorGuard(std::mutex&m, vector<int>&vec) {
try    {
std::lock_guard<std::mutex>locker(m);
vec.push_back(15);
vec.push_back(12);
vec.push_back(10);
    }
catch (conststd::exception&e)
    {
cout<<e.what() <<endl;
    }
return;
}

于是，可以总结出它的特点：

1，简单易用。

2，锁定范围是它初始化位置向后的作用域。

3，无法手动上锁、解锁。

4，不能被复制。

5，异常安全，防止线程意外结束导致死锁。

6，不会对 std::mutex 本身进行托管，初始化时请确保 std::mutex 也已经正确初始化。

因此，在需要对资源进行保护的小范围作用域内，应首先考虑使用std::lock_guard。

std::unique_lock

std::lock_guard 在简单且小范围的作用域内，它无疑是高效的。

有一个显著的问题，std::lock_guard 机制是初始化即上锁，涵盖它初始化位置向后的所有作用域。也就意味着它并不灵活。无法手动管理锁定及解锁时机。

所以这时候就需要 std::unique_lock 登场了，它同样是一个模板类，拥有和 std::lock_guard 一样的异常安全优点。

首先需要注意的是 std::unique_lock 会获得 mutex 对象的所有权。

一个已经托管给 std::unique_lock 的 mutex 对象就不要再去手动调用方法、给 guard 使用、托管给其他 unique。

语法：

【伪代码】std::unique_lock<MutexType>name(MutexObj, args);
【一般情况】std::mutexmutex;
std::unique_lock<std::mutex>unique_m(mutex);
orstd::unique_lock<std::mutex>unique_m(mutex, std::defer_lock);
orstd::unique_lock<std::mutex>unique_m(mutex, std::adopt_lock);

是的，它有第二个参数，第二个参数是固定的几个值，分别代表：

名称	作用
std::defer_lock	默认不锁定互斥量。(不获得所有权)
std::adopt_lock	告诉正在初始化的 unique_lock 互斥量已锁定。
std::try_to_lock	默认尝试锁定，如果失败则不阻止当前线程。

如果第二个参数为空，那么 std::unique_lock 会默认对托管的互斥量进行 lock 操作，如果互斥量已经 lock，它会等待互斥量被 unlock 后再进行托管并上锁。

std::unique_lock 作为互斥量的强大补充，它拥有以下方法：

名称	作用
lock	阻止其他线程。如果已被其他线程阻止，则等待到被解除，再获取所有权并阻止。
unlock	立即解除阻止。
mutex	返回当前托管的互斥量指针。
owns_lock	检查当前 unique_lock 是否与拥有关联互斥量的所有权。
release	解除与互斥量对象的关联。（但不解锁互斥量）
swap	与另一个 unique_lock 交换 mutex 所有权。
try_lock	尝试获取所有权，如果没有被其他线程阻止，则获取所有权并阻止。如果已被其他线程阻止，则返回false。
try_lock_for	等待到时间间隔。
try_lock_until	等待到指定时间。

代码例子：(参考了 CPP Reference 当中例子)

classBrainBox{
public:
std::mutexc_mutex;
intvalue=0;
};
voidChangeValue(BrainBox&skylake, BrainBox&coffeelake) {
std::unique_lock<std::mutex>locker1(skylake.c_mutex, std::defer_lock);
std::unique_lock<std::mutex>locker2(coffeelake.c_mutex, std::defer_lock);
std::lock(locker1, locker2);
skylake.value+=1;
coffeelake.value+=2;
return;
};
intmain()
{
BrainBoxboxA;
BrainBoxboxB;
std::threadt1(ChangeValue, std::ref(boxA), std::ref(boxB));
std::threadt2(ChangeValue, std::ref(boxB), std::ref(boxA));
t1.join();
t2.join();
cout<<"BrainBox A : "<<boxA.value<<endl; // out 3cout<<"BrainBox B : "<<boxB.value<<endl; // out 3returnEXIT_SUCCESS;
}

于是，可以总结出它的特点：

1，std::unique_lock 是通用互斥包装器，允许延迟锁定、锁定的有时限尝试、递归锁定、所有权转移和与条件变量一同使用。

2，std::unique_lock 可移动，但不可复制。

3，std::unique_lock 会获得互斥量的所有权以完全托管 mutex。

4，std::unique_lock 的资源开销大于 std::lock_guard。

5，默认情况下，std::unique_lock 和 std::lock_guard 一样同样锁定它初始化位置向后的作用域。

std::condition_variable

std::condition_variable 和 std::condition_variable_any 是标准库线程同步以条件变量方式的实现。

它的作用是根据设定的条件同步一个或多个线程。

头文件：

#include <condition_variable>

其中 std::condition_variable 仅支持 std::unique_lock<std::mutex> 类型作为互斥量。

std::condition_variable_any 可以支持任意基本可锁定(BasicLockable)类型作为互斥量，例如 [C++14]std::shared_lock，但也就意味着它的效率低于 std::condition_variable。

它们两个的公共函数接口也基本一致：

名称	作用	支持
wait	阻止。	CV and Any
wait_for	阻止到时间间隔。	CV and Any
wait_until	阻止到指定时间。	CV and Any
notify_one	放行一个线程，如果此时托管了多个线程，则随机抽取。	CV and Any
notify_all	放行所有线程。	CV and Any
native_handle	返回原生句柄。	CV

它的语法是：

【伪代码】// 负责同步阻塞的互斥量std::mutexcv_mutex;
// 声明std::condition_variablecv;
// 等待 收到通知放行cv.wait(cv_mutex);
// 条件等待 收到通知且满足条件情况下放行cv.wait(uni_m, [=] {
return!flag;
});
// 通知一个线程cv.notify_one();
// 通知所有线程cv.cv.notify_all();

例子演示了 std::condition_variable 的使用：

#include <iostream>usingstd::cout;
usingstd::endl;
#include <thread>#include <mutex>#include <condition_variable>voidPrintID_CV(std::mutex&mu, std::condition_variable&cv, constint&flag) {
std::unique_lock<std::mutex>uni_m(mu);
cv.wait(uni_m, [=] {
returnflag!=1;
        });
cout<<"Thread ID: "<<std::this_thread::get_id() <<endl;
return;
}
intmain()
{
std::mutexcv_mutex;
std::condition_variablecv;
intflag=0;
std::threadt1(&PrintID_CV, ref(cv_mutex), ref(cv), flag);
while (flag!=1)
    {
std::unique_lock<std::mutex>uni_m(cv_mutex);
std::cout<<"Input 1 is print thread id."<<endl;
std::cin>>flag;
    }
cout<<"Msg Thread..."<<endl;
cv.notify_one();
t1.join();
returnEXIT_SUCCESS;
}

以上例子运行后需要手动在键盘上输入 1 才会打印线程ID。

注意事项：

1，std::condition_variable 和 std::condition_variable_any 对象本身均不可拷贝和赋值。

2，根据代码演示，使用 std::std::condition_variable 与 std::condition_variable_any 都仅仅是负责条件变量，而加锁、解锁操作都始终需要有一个互斥量交由其托管。其中 std::condition_variable 仅支持 std::unique_lock<std::mutex>。

3，调用 wait()、wait_for()、wait_until() 函数后，内部会阻止当前线程运行，并 unlock 互斥量。

4，wait()、wait_for()、wait_until() 函数的第二个可选参数为返回 true 或 false 的任何表达式(lambda、Callback)，为阻塞条件，当收到解锁信号且阻塞条件不满足(即表达式返回值为False)的情况下才会放行。

5，condition_variable.h 提供了额外的辅助函数 std::notify_all_at_thread_exit，语法为：

void std::notify_all_at_thread_exit (condition_variable& cv, unique_lock<mutex> mutex);

当调用该函数的线程退出后，会通知其他受该 std::condition_variable 托管的线程放行。为了避免误操作，请尽量避免使用该函数或在 wait 函数当中增加第二参数作为条件。

额外补充

std::call_once

使用例子另见：【Example】C++ 单例模式演示代码 (被动模式、兼容VS2022编译)

std::lock 与 std::try_lock

std::lock

锁定给定的可锁定 (Lockable) 对象 lock1 、 lock2 、 ... 、 lockn ，用免死锁算法避免死锁。

以对 lock 、 try_lock 和 unlock 的未指定系列调用锁定对象。若调用 lock 或 unlock 导致异常，则在重抛前对任何已锁的对象调用 unlock 。

std::try_lock

尝试锁定每个给定的可锁定 (Lockable) 对象 lock1 、 lock2 、 ... 、 lockn ，通过以从头开始的顺序调用 try_lock 。

若调用 try_lock 失败，则不再进一步调用 try_lock ，并对任何已锁对象调用 unlock ，返回锁定失败对象的 0 底下标。

若调用 try_lock 抛出异常，则在重抛前对任何已锁对象调用 unlock 。

--- CPP Reference

voidChangeValueAdopt(BrainBox&skylake, BrainBox&coffeelake) {
std::lock(skylake.c_mutex, coffeelake.c_mutex);
std::unique_lock<std::mutex>locker1(skylake.c_mutex, std::adopt_lock);
std::unique_lock<std::mutex>locker2(coffeelake.c_mutex, std::adopt_lock);
skylake.value+=1;
coffeelake.value+=2;
return;
};

死锁的四个必要条件：

必要条件

如果在一个系统中以下四个条件同时成立，那么就能引起死锁：

互斥：至少有一个资源必须处于非共享模式，即一次只有一个进程可使用。如果另一进程申请该资源，那么申请进程应等到该资源释放为止。

占有并等待：—个进程应占有至少一个资源，并等待另一个资源，而该资源为其他进程所占有。

非抢占：资源不能被抢占，即资源只能被进程在完成任务后自愿释放。

循环等待：有一组等待进程 {P₀，P₁，…，P_n}，P₀ 等待的资源为 P₁ 占有，P₁ 等待的资源为 P₂ 占有，……，P_n-1 等待的资源为 P_n 占有，P_n 等待的资源为 P₀ 占有。

-- C语言中文网