c++并发编程实战-第4章并发操作的同步

2023-09-21 17:47 由西兰花战士发表于 #后端开发

等待事件或等待其他条件

坐车案例

想象一种情况：假设晚上坐车外出，如何才能确保不坐过站又能使自己最轻松？

方法一：不睡觉，时刻关注自己的位置

 1 #include <iostream>
 2 #include <thread>
 3 #include <mutex>
 4 using namespace std;
 5 
 6 mutex _mtx;
 7 bool bFlag = false;
 8 void wait_for_flag()
 9 {
10     auto startTime = chrono::steady_clock::now();
11     while (1)
12     {
13         unique_lock<mutex> lock(_mtx);
14         if (bFlag)
15         {
16             auto endTime = chrono::steady_clock::now();
17             double dCount = chrono::duration<double, std::milli>(endTime - startTime).count();
18             cout << "wait_for_flag consume : " << dCount << endl;
19             return;
20         }
21     }
22 }
23 
24 void set_flag()
25 {
26     auto startTime = chrono::steady_clock::now();
27     unique_lock<mutex> lock(_mtx);
28     for (int i = 0; i < 5; i++)
29     {
30         lock.unlock();
31         //do something comsume 1000ms
32         this_thread::sleep_for(chrono::milliseconds(1000));
33         lock.lock();
34     }
35 
36     bFlag = true;
37     auto endTime = chrono::steady_clock::now();
38     double dCount = chrono::duration<double, std::milli>(endTime - startTime).count();
39     cout << "set_flag consume : " << dCount << endl;
40 }
41 
42 int main()
43 {
44     thread th1(wait_for_flag);
45     thread th2(set_flag);
46     th1.join();
47     th2.join();
48     return 0;
49 }

这种方式存在双重浪费：

线程 th1（wait_for_flag）须不断查验标志，浪费原本有用的处理时间，这部分计算资源原本可以留给其他线程使用。
线程 th1（wait_for_flag）每次循环都需要给互斥上锁，导致其他线程无法加锁。如果 th2 此时完成操作，则需要等待 th1 释放互斥才能操作。

程序输出如下：

set_flag consume : 5045.39
wait_for_flag consume : 5045.97

两个线程执行时间相近，但查看任务管理器，发现Debug程序CPU占用率始终保持10%。

方法二：通过设定多个闹钟，每隔一段时间叫醒自己

 1 void wait_for_flag()
 2 {
 3     auto startTime = chrono::steady_clock::now();
 4     unique_lock<mutex> lock(_mtx);
 5     while (!bFlag)
 6     {
 7         lock.unlock();
 8         //设置 500ms 的闹钟
 9         this_thread::sleep_for(chrono::milliseconds(500));    
10         lock.lock();
11     }
12 
13     auto endTime = chrono::steady_clock::now();
14     double dCount = chrono::duration<double, std::milli>(endTime - startTime).count();
15     cout << "wait_for_flag consume : " << dCount << endl;
16 }

上面代码中引用了 this_thread::sleep_for()函数，如果暂时不满足条件，就让线程休眠。这确有改进，因为线程休眠，所以处理时间不再被浪费（不用熬夜）。但是，还是存在缺陷，休眠间隔时间难以确定。如果设置太短，会导致频繁检验，如果设置太长，又可能导致过度休眠（到站还没响）。如果线程 th2 完成了任务，线程 th1 却没有被及时唤醒，就会导致延迟。

上面的代码将休眠时间设置为500ms，CPU占用率始终为0%，但两个线程的运行时间相差过大。运行结果如下：

set_flag consume : 5061.66
wait_for_flag consume : 5570.77

方法三：让列车员叫醒你（使用 c++提供的同步机制）

若数据存在先后处理关系，线程甲需要等待线程乙完成处理后才能开始操作，那么线程甲则需等待线程乙完成并且触发事件，其中最基本的方式是条件变量。

 1 mutex _mtx;
 2 bool bFlag = false;
 3 condition_variable _cond;    //条件变量
 4 void wait_for_flag()
 5 {
 6     auto startTime = chrono::steady_clock::now();
 7     unique_lock<mutex> lock(_mtx);
 8     _cond.wait(lock, []() {return bFlag; });    //等待
 9 
10     auto endTime = chrono::steady_clock::now();
11     double dCount = chrono::duration<double, std::milli>(endTime - startTime).count();
12     cout << "wait_for_flag consume : " << dCount << endl;
13 }
14 
15 void set_flag()
16 {
17     auto startTime = chrono::steady_clock::now();
18     unique_lock<mutex> lock(_mtx);
19     for (int i = 0; i < 5; i++)
20     {
21         lock.unlock();
22         //do something comsume 1000ms
23         this_thread::sleep_for(chrono::milliseconds(1000));
24         lock.lock();
25     }
26 
27     bFlag = true;
28     _cond.notify_one();    //通知
29     auto endTime = chrono::steady_clock::now();
30     double dCount = chrono::duration<double, std::milli>(endTime - startTime).count();
31     cout << "set_flag consume : " << dCount << endl;
32 }

引用条件变量后，两线程执行时间相差不大，程序输出如下：

set_flag consume : 5015.84
wait_for_flag consume : 5016.75

注：上述案例的测试结果可能不尽相同，理解意思即可。

条件变量

C++标准库提供了条件变量的两种实现：

std::condition_variable，只能和std::mutex一起使用。（推荐）
std::condition_variable_any，只要某一类型符合成为互斥的最低标准，就能与其一起使用。

二者都在标准库的头文件<condition_variable>内声明。

std::condition_variable

构造函数

condition_variable();
~condition_variable();

condition_variable(const condition_variable&) = delete;
condition_variable& operator=(const condition_variable&) = delete;

不支持拷贝、也不支持移动。

通知

void notify_one();      //唤醒一个等待者
void notify_all();      //唤醒所有等待者

wait()函数

void wait(unique_lock<mutex>& _Lck);
void wait(unique_lock<mutex>& _Lck, _Predicate _Pred);

参数：

_Lck：独占锁，需要多次调用加锁、解锁操作。
_Pred：一个返回bool类型的可调用对象，用于检查条件是否成立。

含义：

使当前线程进入休眠状态，等待其他线程调用notify_one()函数或notify_all()函数唤醒。

该函数执行过程如下：

当程序流程执行到wait时，如果指定了_Pred参数，wait会先执行_Pred。如果_Pred返回true，wait函数执行完毕，返回，执行后续代码；如果_Pred返回false，先将_Lck解锁并阻塞当前线程，等待其他线程唤醒。如果没有指定_Pred参数，等价于返回false的情况。
后续，其他线程调用notify_one()或notify_all()函数唤醒当前线程。当前线程被唤醒，先将_Lck上锁，如果指定_Pred参数，则先进行检查，根据返回值决定是否阻塞。如果没有指定_Pred参数，wait函数执行完毕，返回，执行后续代码。

wait_for()函数

template <class _Rep, class _Period>
cv_status wait_for(
            unique_lock<mutex>& _Lck,
            const chrono::duration<_Rep, _Period>& _Rel_time);

template <class _Rep, class _Period, class _Predicate>
bool wait_for(
        unique_lock<mutex>& _Lck,
        const chrono::duration<_Rep, _Period>& _Rel_time,
        _Predicate _Pred);

参数：

_Lck：独占锁
_Rel_time：等待所消耗的最大时间
_Pred：一个返回bool类型的可调用对象，用于检查条件是否成立。

返回值：

cv_status：如果在最大时间时间内被唤醒，则wait_for()函数返回cv_status::no_timeout，否则wait_for()函数返回cv_status::timeout。
bool：返回_Pred的返回值。

含义：

使当前线程进入休眠状态，等待其他线程调用notify_one()函数或notify_all()函数唤醒。如果等待时常超过_Rel_time，wait函数将返回。

wait_until()函数

template <class _Clock, class _Duration>
cv_status wait_until(
            unique_lock<mutex>&_Lck,
            const chrono::time_point<_Clock, _Duration>& _Abs_time);

template <class _Clock, class _Duration, class _Predicate>
bool wait_until(
        unique_lock<mutex>&_Lck,
        const chrono::time_point<_Clock, _Duration>&_Abs_time,
        _Predicate _Pred);

参数：

_Lck：独占锁
_Abs_time：指定停止等待的时间点
_Pred：一个返回bool类型的可调用对象，用于检查条件是否成立。

返回值：

cv_status：如果在指定的时间点之前被唤醒，则wait_until()函数返回cv_status::no_timeout，否则wait_until()函数返回cv_status::timeout。
bool：返回_Pred的返回值。

含义：

使当前线程进入休眠状态，等待其他线程调用notify_one()函数或notify_all()函数唤醒。如果等待时常超过指定的_Abs_time时间点，wait函数将返回。

std::condition_variable_any

std::condition_variable_any与std::condition_variable类似，这里只简单列出成员函数，具体含义可以参考上面的std::condition_variable。

构造函数

condition_variable_any();
~condition_variable_any();

condition_variable_any(const condition_variable_any&) = delete;
condition_variable_any& operator=(const condition_variable_any&) = delete;

不支持拷贝、也不支持移动。

通知

void notify_one();
void notify_all();

wait()函数

template <class _Lock>
void wait(_Lock& _Lck);

template <class _Lock, class _Predicate>
void wait(_Lock& _Lck, _Predicate _Pred);

wait_for()函数

template <class _Lock, class _Rep, class _Period>
cv_status wait_for(
            _Lock & _Lck,
            const chrono::duration<_Rep, _Period>& _Rel_time);

template <class _Lock, class _Rep, class _Period, class _Predicate>
bool wait_for(
        _Lock & _Lck,
        const chrono::duration<_Rep, _Period>&_Rel_time,
        _Predicate _Pred);

wait_until()函数

template <class _Lock, class _Clock, class _Duration>
cv_status wait_until(_Lock & _Lck,
            const chrono::time_point<_Clock, _Duration>&_Abs_time)

template <class _Lock, class _Clock, class _Duration, class _Predicate>
bool wait_until(_Lock & _Lck,
        const chrono::time_point<_Clock, _Duration>&_Abs_time,
        _Predicate _Pred)

虚假唤醒

当线程从休眠状态中被唤醒，却发现等待条件未满足时，因而无事，这种情况被称为虚假唤醒。发生虚假唤醒最常见的情况是，多个线程争抢同一个条件，例如：

 1 mutex _mtx;
 2 condition_variable        _cond;
 3 queue<int> _dataQueue;
 4 
 5 void data_preparation_thread()
 6 {
 7     while (true)
 8     {
 9         int _data = rand();
10         {
11             std::lock_guard<mutex> lock(_mtx);
12             _dataQueue.push(_data);
13         }
14         _cond.notify_all();
15         this_thread::sleep_for(chrono::milliseconds(1000));
16     }
17 }
18 
19 void data_processing_thread()
20 {
21     while (true)
22     {
23         std::unique_lock<mutex> lock(_mtx);
24         _cond.wait(lock, []()
25             {
26                 bool bEmpty = _dataQueue.empty();
27                 if (bEmpty)
28                     cout << this_thread::get_id() << " be spurious waken up\n";
29 
30                 return !bEmpty;
31             });
32         int _data = _dataQueue.front();
33         _dataQueue.pop();
34         lock.unlock();
35 
36         cout << "threadID : " << this_thread::get_id() << " data = " << _data << endl;
37     }
38 }
39 
40 int main()
41 {
42     srand(time(NULL));
43 
44     thread th1(data_processing_thread);
45     thread th2(data_processing_thread);
46     thread th3(data_preparation_thread);
47     th1.join();
48     th2.join();
49     th3.join();
50     return 0;
51 }

两个线程竞争队列中的一条数据，总有一个是被虚假唤醒的。

唤醒丢失

 1 void wait_for_flag()
 2 {
 3     unique_lock<mutex> lock(_mtx);
 4     _cond.wait(lock);    //等待
 5 }
 6 
 7 void set_flag()
 8 {
 9     unique_lock<mutex> lock(_mtx);
10     bFlag = true;
11     _cond.notify_one();    //通知
12 }
13 
14 int main()
15 {
16     thread th1(set_flag);
17     thread th2(wait_for_flag);
18     th1.join();
19     th2.join();
20     return 0;
21 }

先执行set_flag()函数，设置数据，然后通知等待线程，此时wait_for_flag()函数还未进入等待状态，导致通知信号丢失，后续又无新的通知信号，导致线程一直处于阻塞状态。

使用 future 等待一次性事件发生

本节介绍std::future类，该类一般用于处理一次性事件，可以获取该事件的返回值。

我们可以在某个线程启动一个目标事件，该目标事件由新的线程去执行，并获取一个std::future对象。之后，该线程执行自己余下的任务，等到未来某一时刻，获取目标事件中执行的结果。

C++标准程序库有两种future，分别由两个类模板实现，其声明都位于标准库的头文件<future>内：

std::future：独占future。
std::shared_future：共享future。

它们的设计参照了std::unique_ptr和std::shared_ptr。同一目标事件仅仅允许关联唯一一个std::future实例，但可以关联多个std::shared_future实例。大致含义是：目标事件中的返回结果，如果想被其他多个线程访问，则应该使用std::shared_future，否则使用std::future。

std::future

std::future类提供了访问异步操作执行结果的机制。通过std::async、std::packaged_task或std::promise创建的异步操作，这些函数会返回一个std::future对象，该对象中保存了异步操作的执行结果。但是，该类的结果并不是共享的，即，该结果只能访问一次。

构造函数

future();
~future();
future(future&& _Other);
future& operator=(future&& _Right);

future(const future&) = delete;
future& operator=(const future&) = delete;

仅支持移动语义，不支持拷贝。

valid()函数

bool valid() const;

检测当前结果是否就绪。

get()函数

template <class _Ty>
_Ty get()；

阻塞，等待future拥有合法结果并返回该结果。结果返回后，释放共享状态，后续调用valid()函数将返回false。若调用该函数前valid()为false，则行为未定义。

wait()函数

void wait() const;

阻塞直至结果变得可用，该函数执行后，valid() == true。

wait_for()函数

template <class _Rep, class _Per>
future_status wait_for(const chrono::duration<_Rep, _Per>& _Rel_time);

等待结果，如果在指定的超时间隔后仍然无法得到结果，则返回。

future_status有如下取值：

future_status::ready：共享状态就绪。
future_status::timeout：共享状态在经过指定的等待时间内仍未就绪。
future_status::deferred：共享状态持有的函数正在延迟运行，结果将在显式请求时计算。

wait_until()函数

template <class _Clock, class _Dur>
future_status wait_until(const chrono::time_point<_Clock, _Dur>& _Abs_time);

等待结果，如果在已经到达指定的时间点时仍然无法得到结果，则返回。

share()函数

template <class _Ty>
shared_future<_Ty> share();

将本对象移动到std::shared_future对象。

std::shared_future

类似std::future类，同样提供了访问异步操作执行结果的机制，与std::future类不同的是，该类的结果可以被访问多次（可以连续多次调用get()函数）。

构造函数

shared_future();      //构造函数
~shared_future();     //析构函数

//支持拷贝
shared_future(const shared_future& _Other);
shared_future& operator=(const shared_future& _Right);

//支持移动
shared_future(future<_Ty>&& _Other);
shared_future& operator=(shared_future&& _Right);

支持拷贝，可以复制多个std::shared_future对象指向同一异步结果。每个线程通过自身的std::shared_future对象副本访问共享的异步结果，这一操作是安全的。

valid()函数

bool valid() const;

检测当前结果是否可用。

get()函数

template <class _Ty>
const _Ty& get() const;

阻塞，等待shared_future 拥有合法结果并获取它。若调用此函数前valid()为false，则行为未定义。

等待

void wait() const;

template <class _Rep, class _Per>
future_status wait_for(
    const chrono::duration<_Rep, _Per>&_Rel_time);

template <class _Clock, class _Dur>
future_status wait_until(
    const chrono::time_point<_Clock, _Dur>& _Abs_time);

和std::future相似。

案例-构造std::shared_future对象

 1 std::promise<int> pro;
 2 std::future<int> _fu = pro.get_future();
 3 std::shared_future<int> _sfu = std::move(_fu);        //显示
 4 
 5 std::promise<int> pro;
 6 std::shared_future<int> _sfu = pro.get_future();        //隐式
 7 
 8 std::promise<int> pro;
 9 std::future<int> _fu = pro.get_future();
10 std::shared_future<int> _sfu = _fu.share();        //share函数

std::async()函数-从后台任务返回值

std::async()函数用于构建后台任务，并允许调用者在未来某一时刻获取该任务的返回值。

函数定义

template <class _Fty, class... _ArgTypes>
std::future<...> async(_Fty&& _Fnarg, _ArgTypes&&... _Args);

template <class _Fty, class... _ArgTypes>
std::future<...> async(launch _Policy, _Fty&& _Fnarg, _ArgTypes&&... _Args);

参数：

_Policy：该函数执行方式，有如下几种取值：

std::launch::async：异步执行。该函数执行后，会启动新线程执行可调用对象。
std::launch::deferred：惰性执行。该函数执行后，并不会启动线程，而是等到后续需要获取结果时，由获取值的线程直接执行可调用对象。如果没有调用get()或者wait()，可调用对象不会执行。
std::launch::async | std::launch::deferred：由系统自行决定采用其中一个。

_Fnarg：可调用对象。
_Args：传递给可调用对象的参数包。

返回值：

std::future对象，通过该对象可用获取后台任务的返回值。

参数传递流程

//省略Res_Data类
int Entry(Res_Data data)
{
    cout << "-----------";
    return 5;
}

int main()
{
    Res_Data _data;
    auto _fu = std::async(Entry, _data);
    cout << _fu.get() << endl;
    return 0;
}

输出如下：

008FF9E3  Constractor
008FF6E8  Copy Constractor
008FF33C  Move Constractor
00CE0854  Move Constractor
008FF33C  Destractor
008FF6E8  Destractor
009FDE74  Move Constractor
-----------
009FDE74  Destractor
00CE0854  Destractor
5
008FF9E3  Destractor

结论：一次拷贝，3次移动。

案例

int ThreadEntry()
{
    cout << "son threadId : " << std::this_thread::get_id() << " start to do something!" << endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(5000));
    cout << "son threadId : " << std::this_thread::get_id() << " end doing something!" << endl;
    return 5;
}

int main()
{
    cout << "main threadId : " << std::this_thread::get_id() << endl;
    std::future<int> fu = std::async(ThreadEntry);
    cout << "main thread to do something" << endl;

    cout << fu.get() << endl;            //等待线程结束并获取值，不能重复调用
    //fu.wait();                        //仅等待线程结束

    cout << "main thread end doing something" << endl;

    return 0;
}

如何判断std::async的执行方式

如果在构建异步任务时，不指定std::async的执行方式，那么操作系统会根据当前系统资源自动决定采用 std::launch::async 或 std::launch::deferred，那么，在程序中如何获知当前的执行方式呢？方法如下：

 1 std::future _fu = std::async(ThreadEntry);
 2 future_status status = _fu.wait_for(std::chrono::microseconds(0));//等待0ms
 3 if (status == future_status::deferred)        //延时执行
 4 {
 5     //todo
 6 }
 7 else if (status == future_status::ready || status == future_status::timeout)
 8 {
 9     //todo
10 }

std::future类的wait_for和wait_until成员函数会返回future_status枚举类型，该类型中记录当前的执行方式。

std::async与std::thread的区别

std::thread是创建一个线程执行相关操作，当系统资源紧张时，可能会导致线程创建失败。

std::async是创建一个异步任务，是否创建线程取决于操作系统，当系统资源紧张时，该函数可能不会创建线程，这取决于函数的执行方式。

std::thread不支持获取线程的执行结果，而std::async可以通过std::future获取异步任务的执行结果。

std::packaged_task - 关联future实例和任务

类模板 std::packaged_task 用于包装任何可调用对象，使之能被异步调用。可调用对象执行后，其返回值保存在std::future对象中，可用通过成员函数get_future()函数获取。

若一项庞杂的操作能分解为多个子任务，则可把它们分别包装到多个std::packaged_task实例之中，再传递给任务调度器或线程池。这就隐藏了细节，使任务抽象化，让调度器得以专注处理std::packaged_task<>实例，无须纠缠于形形色色的任务函数。

构造函数

packaged_task();      //默认构造函数
~packaged_task();     //析构函数

template <class _Fty2, ...>
packaged_task(_Fty2&& _Fnarg)    //传入一个可调用对象

//支持移动
packaged_task(packaged_task&& _Other);
packaged_task& operator=(packaged_task&& _Other);

//不支持拷贝
packaged_task(const packaged_task&) = delete;
packaged_task& operator=(const packaged_task&) = delete;

packaged_task的实例化与std::function类似，比如：

int ThreadEntry(string& str, double dValue, char* pBuf);

std::packaged_task<int(string&, double, char*)> task(ThreadEntry);

valid()函数

bool valid() const;

检查任务对象是否拥有合法的可调用对象。

swap()函数

void swap(packaged_task& _Other);

交换std::packaged_task中包装的可调用对象和与之关联的std::future对象。

get_future()函数

future<_Ret> get_future();

返回与之关联的std::future对象。

operator()()函数

void operator()(_ArgTypes... _Args);

调用被包装的可调用对象，可调用对象执行完后，将返回值保存到std::future对象中，并使std::future对象变为可用状态。

make_ready_at_thread_exit()函数

void make_ready_at_thread_exit(_ArgTypes... _Args);

该函数会调用被包装的可调用对象，可调用对象执行完后，将返回值保存到std::future对象中，但不会立马让std::future对象变为可用，而是等到该线程结束后才使其可用。

例如：

 1 int ThreadEntry()
 2 {
 3     cout << "son threadId : " << std::this_thread::get_id() << " start to do something!" << endl;
 4     std::this_thread::sleep_for(std::chrono::milliseconds(5000));
 5     cout << "son threadId : " << std::this_thread::get_id() << " end doing something!" << endl;
 6     return 5;
 7 }
 8 
 9 int main()
10 {
11     std::packaged_task<int(void)> task(ThreadEntry);
12     std::future<int> _fu = task.get_future();
13 
14     task.make_ready_at_thread_exit(); //执行该函数后，_fu未就绪，调用get将出错
15     //task();   //_fu立马就绪，调用get()不会出错
16     cout << "value = " << _fu.get() << endl;
17     return 0;
18 }

正确用法：

 1 int main()
 2 {
 3     std::packaged_task<int(void)> task(ThreadEntry);
 4     std::future<int> _fu = task.get_future();
 5 
 6     thread th1([&]() {task.make_ready_at_thread_exit(); });
 7     th1.detach();
 8     
 9     cout << "value = " << _fu.get() << endl;
10     return 0;
11 }

reset()函数

void reset();

抛弃之前的std::future对象和执行结果，重新构建新的std::future对象。不影响可调用对象。

案例-在线程间传递任务

 1 std::mutex m;
 2 std::deque<std::packaged_task<void()>> tasks;
 3 
 4 void gui_thread()
 5 {
 6     while (...)   
 7     {
 8         std::packaged_task<void()> task;
 9         {
10             std::lock_guard<std::mutex> lk(m);
11             if (tasks.empty())    
12                 continue;
13             task = std::move(tasks.front());    
14             tasks.pop_front();
15         }
16         task();
17         //其他操作
18     }
19 }
20 
21 template<typename Func>
22 std::future<void> post_task_for_gui_thread(Func f)
23 {
24     std::packaged_task<void()> task(f);  
25     std::future<void> res = task.get_future();  
26     std::lock_guard<std::mutex> lk(m);
27     tasks.push_back(std::move(task));    
28     return res;    
29 }

std::promise-创建std::promise

std::promise给出了一种异步求值的方法，能与某个std::future对象关联，延后读出需要求取的值。配对的std::promise和std::future可实现下面的工作机制：等待数据的线程在future上阻塞，而提供数据的线程利用相配的promise设定关联的值，使future准备就绪。

 1 void setValue(int nData, std::promise<int>& _pro)
 2 {
 3     cout << "set value threadID : " << this_thread::get_id() << endl;
 4     this_thread::sleep_for(chrono::seconds(3));        //休息3秒
 5     _pro.set_value( nData * 2 + 5 );
 6 }
 7 
 8 void getValue(std::future<int>& _fu)
 9 {
10     cout << "get value threadID : " << this_thread::get_id() << endl;
11     cout << "data = " << _fu.get() << endl;
12 }
13 
14 int main()
15 {
16     std::promise<int> pro;
17     std::future fu = pro.get_future();
18 
19     thread th1(setValue, 10, std::ref(pro));
20     thread th2(getValue, std::ref(fu));
21 
22     th1.join();
23     th2.join();
24     return 0;
25 }

构造函数

promise();
~promise();

template <class _Alloc>
promise(allocator_arg_t, const _Alloc& _Al);

//移动构造
promise(promise&& _Other);
promise& operator=(promise&& _Other);

//无拷贝
promise(const promise&) = delete;
promise& operator=(const promise&) = delete;

swap()函数

void swap(promise& _Other);

交换2个std::promise对象的内容，以及与之关联的std::future对象。

get_future()函数

future<_Ty> get_future();

获取std::future对象。

set_value()函数

void set_value(const _Ty& _Val);

void set_value(_Ty&& _Val);

将_Val存储到共享状态，并使其进入就绪状态。如果std::promise对象在销毁时还未设置值，会用异常代替。

set_value_at_thread_exit()函数

void set_value_at_thread_exit(const _Ty& _Val);

void set_value_at_thread_exit(_Ty&& _Val);

将_Val存储到共享状态，在线程结束时，使共享状态进入就绪状态。

set_exception()函数

void set_exception(exception_ptr _Exc);

将异常指针_Excl存储到共享状态，并使其进入就绪状态。

set_exception_at_thread_exit()函数

void set_exception_at_thread_exit(exception_ptr _Exc);

将异常指针_Excl存储到共享状态，在线程结束时，使共享状态进入就绪状态。

案例

 1 void process_connections(vector<ConnectPackage>& connections)
 2 {
 3     while (!done(connections))
 4     {
 5         for (auto itr : connections)
 6         {
 7             if (itr->has_incoming_data())        //有数据传入，接收
 8             {
 9                 data_packet data = connection->incoming();
10                 std::promise<payload_type>& p = connection->get_promise(data.id);
11                 p.set_value(data.payload);
12             }
13 
14             if (connection->has_outgoing_data())   //有数据需向外传递
15             {
16                 outgoing_packet data = connection->top_of_outgoing_queue();
17                 connection->send(data.payload);
18                 data.promise.set_value(true);
19             }
20         }
21     }
22 }

将异常保存到future中

在允许多线程程序时，如果有异常情况发生，异常值如何向外传递是我们需要考虑的一个问题，例如：

 1 double square_root(double x)
 2 {
 3     if (x < 0)
 4         throw std::out_of_range("x < 0");
 5     
 6     return sqrt(x);
 7 }
 8 
 9 int main()
10 {
11     std::future<double> f = std::async(square_root, -1);
12     double dVal = f.get();
13     return 0;
14 }

std::future实例化为double类型，因此f.get()将会返回一个double类型的值，那异常该如何传递呢？

c++规定，若经由std::async()调用的函数抛出异常，则会被保存到future中，代替本该设定的值，future随之进入就绪状态，等到其成员函数get()被调用，存储在内的异常即被重新抛出。假如我们把任务函数包装在std::packaged_task对象内，也依然如是。若包装的任务函数在执行时抛出异常，则会代替本应求得的结果，被保存到future内并使其准备就绪。只要调用get()，该异常就会被再次抛出。

对于std::promise类，可以调用调用成员函数set_exception()设置异常，例如：

1 try
2 {
3     pro.set_value(dVal);
4 }
5 catch (...)
6 {
7     pro.set_exception(std::make_exception_ptr(std::logic_error("error")));
8 }

另一个方法是，直接销毁与std::future对象关联的std::promise对象或std::packaged_task对象。如果关联的future未能准备就绪，无论销毁两者中的哪一个，其析构函数都会将异常std::future_error存储为异步任务的状态数据，它的值是错误代码是std::future_errc::broken_promise。

限时等待

时钟周期-std::ratio

时间周期是指时钟的计时单位，每隔多长时间计数一次，用std::chrono::ratio来描述，该类定义如下：

template<std::intmax_t Num, std::intmax_t Denom = 1>
class ratio;

std::chrono::ratio是一个比例类，其中Num代表分子，Denom代表分母。用于描述时间时，默认单位是秒，即：

ratio<2>          //代表2秒
ratio<60>         //代表1分钟
ratio<60*60>      //代表1小时
ratio<1，1000>    //代表1毫秒
ratio<1，1000000> //代表1微妙

时钟类

就C++标准库而言，时钟（clock）是时间信息的来源。具体来说，每种时钟都是一个类，提供4项关键信息：

当前时刻。
时间值的类型（int、double）。
该时钟的计时单元的长度（std::chrono::duration）。
计时速率是否恒定，即能否将该时钟视为恒稳时钟（steady clock）。

c++给出下列几种时钟：

std::chrono::system_clock：
std::chrono::steady_clock：
std::high_resolution_clock：

其中，high_resolution_clock 被定义为：

using high_resolution_clock = steady_clock;

时钟类中都提供了一个静态成员函数now()，用于返回当前时刻。另一个静态成员is_steady，用于判断当前始终的计时速率是否恒定且无法调整，如果is_steady=true，则该时钟为恒定时钟。通常，std::chrono::system_clock类不是恒稳时钟，而std::chrono::steady_clock是一个恒定时钟。

时长类

c++标准库用std::chrono::duration<>类描述时长，该类定义如下：

template<class Rep, class Period = std::ratio<1,1>>
class duration;

其中，Rep代表时钟数的类型；Period代表时钟周期，描述每一个计时周期代表多少秒。c++标准库也定义了一些常用的时长：

typedef duration<Rep ratio<3600,1>> hours;              //小时
typedef duration<Rep ratio<60,1>> minutes;              //分钟
typedef duration<Rep ratio<1,1>> seconds;               //秒
typedef duration<Rep ratio<1,1000>> milliseconds;       //毫秒
typedef duration<Rep ratio<1,1000000>> microseconds;    //微妙
typedef duration<Rep ratio<1,1000000000>> nanoseconds;  //纳秒

使用也非常方便，如果需要使线程休眠3秒，代码如下：

std::this_thread::sleep_for(std::chrono::seconds(3));    //休眠3秒

std::chrono::duration_cast时间转换

如果需要在两个时间周期转换，可以使用std::chrono::duration_cast<>进行显示转换，例如：

1 std::chrono::milliseconds ms(54802);
2 std::chrono::seconds s = std::chrono::duration_cast<std::chrono::seconds>(ms);
3 
4 cout << ms.count() << endl;    //54802
5 cout << s.count() << endl;     //54

强转将导致结果被截断。

count()函数

时长类支持算术运算，我们将时长乘或除以一个数值（数值应与时长类的计数类型相符）或对两个时长进行加减，就能得出一个新时长。可以通过count()函数获取该计时单位的数量：

1 std::chrono::seconds s = std::chrono::seconds(1) * 5;
2 cout << s.count() << endl;      //5

时间点类

在c++标准库中，用std::chrono::time_point<>表示时间点，时间点是一个时间跨度，始于一个称为时钟纪元的特定时刻（一般是1970年1月1日0时0分0秒），终于该时间点本身。

template <class _Clock, class _Duration = typename _Clock::duration>
class time_point;

其中，_Clock表示所参考的时钟，_Duration表示计时单元。

std::chrono::time_point类内提供了一个成员函数time_since_epoch()，该函数返回从时钟纪元到该时间点的时长跨度，下面例子是计算当前时间距1970年1月1日相隔多少天：

1 int main()
2 {
3     using days_type = std::chrono::duration<int, std::ratio<60 * 60 * 24>>;
4 
5     std::chrono::time_point<std::chrono::system_clock, days_type> today = 
6         std::chrono::time_point_cast<days_type>(std::chrono::system_clock::now());
7     
8     cout << today.time_since_epoch().count() << endl;
9 }

可以对某个时间进行加减操作，从而计算出新的时间点，例如：

std::chrono::high_resolution_clock::now() + std::chrono::milliseconds(500);

上面代码计算出未来500毫秒时刻，我们可以用它来指定绝对超时时刻。在前面的案例中，也给出了计算某段代码执行时长的例子。

接受超时时限的函数

在c++标准库中，以_for结尾的，一般对应一个时长；以_until()结尾的，一般对应一个时间点。

1 std::chrono::milliseconds ms(500);
2 this_thread::sleep_for(ms);
3 
4 auto tp = std::chrono::high_resolution_clock::now() + std::chrono::milliseconds(500);
5 this_thread::sleep_until(tp);

前面介绍的几个类中，都有包含_for和_until()结尾的函数，例如：std::this_thread、std::condition_variable、std::future、std::unique_lock等。

运用同步操作简化代码

注：该小节整理的不是很好，有部分内容我自己也没做过测试，大伙粗略看一下（或者跳过）。

利用future进行函数式编程

函数式编程是指一种编程风格，函数调用的结果完全取决于参数，而不依赖任何外部状态。若我们以相同的参数调用同一个函数两次，结果会完全一致。有一个函数类型叫“纯函数”，它的含义是：它产生的作用被完全限制在返回值上，而不会改动任何外部状态。这非常契合并发编程，只要共享数据没有改动，就不会引发条件竞争，因而无须动用互斥保护。

下面例子给出了快速排序并发版本：（大概理解一下就好，实际效率非常低）

template<typename T>
std::list<T> parallel_quick_sort(std::list<T> input)
{
    if (input.empty()) return input;

    std::list<T> result;
    result.splice(result.begin(), input, input.begin());
    const T& pivot = *result.begin();

    auto divide_point = std::partition(input.begin(), input.end(), [&pivot](const T& t) { return t < pivot; });
    std::list<T> lower_part;
    lower_part.splice(lower_part.begin(), input, input.begin(), divide_point);

    std::future<std::list<T>> fu = std::async(parallel_quick_sort<T>, std::move(lower_part));
    auto new_higher = parallel_quick_sort(std::move(input));

    result.splice(result.end(), new_higher);
    result.splice(result.begin(), fu.get());
    return result;
}

使用消息传递进行同步

CSP（通信式串行线程）：线程间没有共享数据，只负责接收消息，然后根据消息做出响应。比如去ATM机取钱，取款人需要先插入银行卡，之后输入密码，验证通过后输入金额，确认并等待机器吐钱。如果用线程来完成这个功能，则会有一个插卡线程，检测有没有插入银行卡，只有等卡插入了，才会通知输入线程显示并接收用户输入的密码，验证通过后，才会通知取钱线程，这样一环套一环的效果，没有完成前一项，就无法切换至下一项，这就是CSP。

符合并发技术规约的后续风格并发

并发技术规约在名字空间std::experimental内，提供了std::experimental::promise和std::experimental::packaged_task，二者与原始版本的差异是都返回std::experimental::future实例。

std::experimental::future提供了一个新的关键特性-then()后续。所谓后续是指，一旦future就绪，该函数立马执行某个函数。

并发技术规约中并没有提供与std::async()等价的函数，我们可以自己实现一个spawn_async函数，功能和std::async()函数类似：

template<typename Func>
std::experimental::future<decltype(std::declval<Func>()())> spawn_async(Func&& func)
{
    std::experimental::promise<decltype(std::declval<Func>()())> pro;
    auto fu = pro.get_future();

    auto cbk = [_pro = std::move(pro), _func = std::decay_t<Func>(func)]() mutable 
    {
        try
        {
            _pro.set_value_at_thread_exit(_func());
        }
        catch (...)
        {
            _pro.set_exception_at_thread_exit(std::current_exception());
        }
    };

    std::thread th(cbk);
    th.detach();
    return fu;
}

后续函数的连锁调用

假定有一系列耗时的任务需要执行，而且，为了让主线程抽身执行其他任务，我们想按异步方式执行这些任务。例如，当用户登录应用程序时，我们就需向后端服务器发送信息以验证身份；完成身份验证之后，我们需再次向后端服务器请求其账户信息；最后，一旦取得了相关信息，就做出更新并显式呈现。

串行方式顺序执行代码如下：

 1 void process_login(std::string const& username, std::string const& password)
 2 {
 3     try 
 4     {
 5         user_id const id = backend.authenticate_user(username, password);        //验证身份
 6         user_data const info_to_display = backend.request_current_info(id);        //请求账户信息
 7         update_display(info_to_display);        //更新显示
 8     }
 9     catch (std::exception& e) 
10     {
11         display_error(e);
12     }
13 }

如果该代码在UI线程中执行，相关请求可能会较慢从而阻塞UI线程。

并行执行如下：

 1 std::future<void> process_login(std::string const& username, std::string const& password)
 2 {
 3     auto cbk = [=]()
 4     {
 5         try
 6         {
 7             const user_id id = backend.authenticate_user(username, password);        //验证身份
 8             const user_data info_to_display = backend.request_current_info(id);        //请求账户信息
 9             update_display(info_to_display);        //更新显示
10         }
11         catch (std::exception& e)
12         {
13             display_error(e);
14         }
15     };
16 
17     return std::async(std::launch::async, cbk);
18 }

大多数程序员可能会这样书写，实际上这也存在浪费。全部代码集中到后台的某一线程上运行，该后台线程仍会消耗大量资源以逐一完成各任务，因而发生阻塞。若这样的任务很多，那将导致大量线程无所事事，它们只是在空等。

我们需要按照后续函数的方式，将任务接合，形成调用链，每完成一个任务，就执行下一个。使用then()改进代码：

 1 std::experimental::future<void> process_login(std::string const& username, std::string const& password)
 2 {
 3     //验证身份
 4     auto cbk1 = [=]()
 5     {
 6         return backend.authenticate_user(username, password);
 7     };
 8 
 9     //请求账户信息
10     auto cbk2 = [](std::experimental::future<user_id> id)
11     {
12         return backend.request_current_info(id.get());
13     };
14 
15     //更新显示
16     auto cbk3 = [](std::experimental::future<user_data> info_to_display)
17     {
18         try {
19             update_display(info_to_display.get());
20         }
21         catch (std::exception& e) {
22             display_error(e);
23         }
24     };
25 
26     return spawn_async(cbk1).then(cbk2).then(cbk3);
27 }

登录流程被拆分成一系列任务，每个任务各自作为上一个任务的后续函数，接合成调用链。

最后作者还提供了一个写法，但我没理解的太懂，先贴代码，后续补充：

 1 std::experimental::future<void> process_login(std::string const& username, std::string const& password)
 2 {
 3     auto cbk1 = [](std::experimental::future<user_id> id)
 4     {
 5         return backend.async_request_current_info(id.get());
 6     };
 7 
 8     auto cbk2 = [](std::experimental::future<user_data> info_to_display)
 9     {
10         try
11         {
12             update_display(info_to_display.get());
13         }
14         catch (std::exception& e)
15         {
16             display_error(e);
17         }
18     };
19 
20     return backend.async_authenticate_user(username, password).then(cbk1).then(cbk2);
21 }

等待多个future全部就绪

假定有大量数据需要处理，而且每项数据都能独立完成，此时我们会想到生成一组异步任务分别处理数据，最后通过future等待所有任务完成。但是，有可能我们需要将所有的结果汇总起来，则需要等待所有线程将任务完成，为此可能需要新开一个线程，让该线程不断检查future是否就绪，代码如下：

 1 std::future<FinalResult> process_data(std::vector<MyData>& vec)
 2 {
 3     size_t const chunk_size = whatever;
 4     std::vector<std::future<ChunkResult>> results;
 5 
 6     for (auto begin = vec.begin(), end = vec.end(); beg != end;) 
 7     {
 8         const size_t  remaining_size = end - begin;
 9         const size_t  this_chunk_size = std::min(remaining_size, chunk_size);
10         results.push_back(std::async(process_chunk, begin, begin + this_chunk_size));
11         begin += this_chunk_size;
12     }
13 
14     //新开线程，不断检查future是否就绪
15     auto cbk = [all_results = std::move(results)]()
16     {
17         std::vector<ChunkResult> v;
18         for (auto& f : all_results)
19         {
20             v.push_back(f.get());
21         }
22     };
23     return std::async(cbk);
24 }

std::experimental::when_all()函数

可以使用std::experimental::when_all()函数避免，该函数传入若干个需要等待的future对象，它在内部会生成并返回一个总future对象，等到传入的future全部就绪，总future也随之就绪。

std::experimental::when_all()函数产生一个新的future，将传入的多个future全部包装在内。

上述代码可以改为如下：

 1 std::experimental::future<FinalResult> process_data(std::vector<MyData>& vec)
 2 {
 3     size_t const chunk_size = whatever;
 4     std::vector<std::experimental::future<ChunkResult>> results;
 5     for (auto begin = vec.begin(), end = vec.end(); beg != end;) 
 6     {
 7         const size_t remaining_size = end - begin;
 8         const size_t this_chunk_size = std::min(remaining_size, chunk_size);
 9         results.push_back(spawn_async(process_chunk, begin, begin + this_chunk_size));        
10         begin += this_chunk_size;
11     }
12 
13     auto cbk = [](std::future<std::vector<std::experimental::future<ChunkResult>>> ready_results)
14     {
15         std::vector<std::experimental::future<ChunkResult>> all_results = ready_results.get();
16         std::vector<ChunkResult> v;
17         v.reserve(all_results.size());
18 
19         for (auto& f : all_results)
20         {
21             v.push_back(f.get());
22         }
23         return gather_results(v);
24     };
25 
26     return std::experimental::when_all(results.begin(), results.end()).then(cbk);
27 }

等待多个future中任意一个就绪

假定，我们依据某些具体条件，从庞大的数据集中查找值。不过，若存在多个值同时满足要求，则选取其中任意一个皆可。为此，我们可以生成多个线程，它们分别查找数据集的子集；若有线程找到了符合条件的值，就设立标志示意其他线程停止查找，并设置最终结果的值。

std::experimental::when_any()函数

我们可以采用std::experimental::when_any()函数统筹众多future，它生成一个新的future返回给调用者，只要原来的future中至少有一个准备就绪，则该新future也随之就绪。新future中包含了一个std::experimental::when_any_result<>内部实例，该实例由一个序列和一个索引值组成，其中序列包含传入的全体future，索引值则指明哪个future就绪。

代码如下：

 1 struct DoneCheck
 2 {
 3     std::shared_ptr<std::experimental::promise<FinalResult>> final_result;
 4 
 5     DoneCheck(std::shared_ptr<std::experimental::promise<FinalResult>> final_result_) : final_result(std::move(final_result_)) {}
 6 
 7     void operator()(std::experimental::future<std::experimental::when_any_result<std::vector<std::experimental::future<MyData*>>>> results_param)
 8     {
 9         auto results = results_param.get();
10         const MyData* ready_result = results.futures[results.index].get();
11 
12         if (ready_result)
13             final_result->set_value(process_found_value(*ready_result));
14         else
15         {
16             results.futures.erase(results.futures.begin() + results.index);
17             if (!results.futures.empty())
18             {
19                 std::experimental::when_any(results.futures.begin(), results.futures.end()).then(std::move(*this));
20             }
21             else
22             {
23                 final_result->set_exception(std::make_exception_ptr(std::runtime_error("Not found")));
24             }
25         }
26     }
27 };
28 
29 std::experimental::future<FinalResult> find_and_process_value(std::vector<MyData>& data)
30 {
31     const unsigned  concurrency = std::thread::hardware_concurrency();
32     const unsigned  num_tasks = (concurrency > 0) ? concurrency : 2;
33 
34     std::vector<std::experimental::future<MyData*>> results;
35 
36     auto const chunk_size = (data.size() + num_tasks - 1) / num_tasks;
37 
38     auto chunk_begin = data.begin();
39 
40     std::shared_ptr<std::atomic<bool>> done_flag = std::make_shared<std::atomic<bool>>(false);
41 
42     for (unsigned i = 0; i < num_tasks; ++i)
43     {
44         auto chunk_end = (i < (num_tasks - 1)) ? chunk_begin + chunk_size : data.end();
45 
46         auto cbk = [=]()
47         {
48             for (auto entry = chunk_begin; !*done_flag && (entry != chunk_end); ++entry)
49             {
50                 if (matches_find_criteria(*entry))
51                 {
52                     *done_flag = true;
53                     return &*entry;
54                 }
55             }
56             return (MyData*)nullptr;
57         };
58 
59         std::experimental::future<MyData*> _fu = spawn_async(cbk);
60         results.push_back(std::move(_fu));
61         chunk_begin = chunk_end;
62     }
63 
64     std::shared_ptr<std::experimental::promise<FinalResult>> final_result = std::make_shared<std::experimental::promise<FinalResult>>();
65 
66     std::experimental::when_any(results.begin(), results.end()).then(DoneCheck(final_result));
67     return final_result->get_future();
68 }

上面代码别看了，要命...（书上的更要命0_0），下面这句最要紧：

void operator()(std::experimental::future<std::experimental::when_any_result<std::vector<std::experimental::future<MyData*>>>> results_param)

返回的新future中保存的是一个std::experimental::when_any_result类型的实例，调用get函数可以获取future序列和索引值，如下：

1 auto results = results_param.get();
2 const MyData* ready_result = results.futures[results.index].get();

上面代码中，results.futures是future序列，results.index是索引值，results.futures[results.index]是就绪的future。

基本的线程闩类std::experimental::latch

std::experimental::latch的构造函数接收唯一一个参数，在构建该类对象时，我们需通过这个参数设定其计数器的初值。接下来，每当等待的目标事件发生时，我们就在线程闩对象上调用count_down()，一旦计数器减到0，它就进入就绪状态。若我们要等待线程闩的状态变为就绪，则在其上调用wait()。若需检查其是否已经就绪，则调用is_ready()。最后，假如我们要使计数器减持，同时要等待它减到0，则应该调用count_down_and_wait()。

例子如下：

 1 void foo() 
 2 {
 3     unsigned const thread_count = 5;
 4     std::experimental::latch done(thread_count);
 5     my_data data[thread_count];
 6     std::vector<std::future<void>> threads;
 7 
 8     for (unsigned i = 0; i < thread_count; ++i)
 9     {
10         auto cbk = [&, i]()
11         {
12             data[i] = make_data(i);
13             done.count_down();
14             do_more_stuff();
15         };
16 
17         std::future<void> _fu = std::async(std::launch::async, cbk);
18         threads.push_back(std::move(_fu));
19     }
20 
21     done.wait();
22     process_data(data, thread_count);
23 }

基本的线程卡类std::experimental::barrier

并发技术规约提出了两种线程卡：

std::experimental::barrier
std::experimental:: flex_barrier

假定有一组线程在协同处理某些数据，各线程相互独立，分别处理数据，因此操作过程不必同步。但是，只有在全部线程都完成各自的处理后，才可以操作下一项数据或开始后续处理，线程卡就是为了应对这种场景。为了同步一组线程，我们创建线程卡，并指定参与同步的线程数目。线程在完成自身的处理后，就运行到线程卡处，通过在线程卡对象上调用arrive_and_wait()等待同步组的其他线程。只要组内最后一个线程也运行至此，所有线程即被释放，线程卡会自我重置。接着，线程组视具体情况各自继续，或处理下一项数据，或进行下一阶段的处理。

代码如下：

 1 void process_data(data_source& source, data_sink& sink)
 2 {
 3     const unsigned concurrency = std::thread::hardware_concurrency();
 4     const unsigned num_threads = (concurrency > 0) ? concurrency : 2;            //线程个数
 5 
 6     std::experimental::barrier sync(num_threads);
 7     std::vector<joining_thread> threads(num_threads);
 8 
 9     std::vector<data_chunk> chunks;
10     result_block result;
11 
12     for (unsigned i = 0; i < num_threads; ++i)
13     {
14         auto cbk = [&, i]()
15         {
16             while (!source.done())
17             {
18                 if (!i) //在0号线程上做分割
19                 {
20                     data_block current_block = source.get_next_data_block();    
21                     chunks = divide_into_chunks(current_block, num_threads);    //分成num_threads块
22                 }
23 
24                 sync.arrive_and_wait();        //其他线程等待0号线程分割完
25                 result.set_chunk(i, num_threads, process(chunks[i]));        //各个线程进行相关处理
26                 sync.arrive_and_wait();        //等待所有线程处理完
27 
28                 if (!i) 
29                 {
30                     sink.write_data(std::move(result));        //由0号线程负责处理写入操作
31                 }
32             }
33         };
34 
35         threads[i] = joining_thread(cbk);            //创建std::thread线程，会自动调用join()
36     }
37 }

std::experimental::flex_barrier

std::experimental::flex_barrier是std::experimental::latch的灵活版本，二者的不同之处在于，前者具备另一个构造函数，其参数既接收线程的数目，还接收补全函数。只要全部线程都运行到线程卡处，该函数就会在其中一个线程上运行（并且是唯一一个）。

代码如下：

 1 void process_data(data_source& source, data_sink& sink)
 2 {
 3     const unsigned concurrency = std::thread::hardware_concurrency();
 4     const unsigned num_threads = (concurrency > 0) ? concurrency : 2;
 5     std::vector<data_chunk> chunks;
 6 
 7     auto split_source = [&] ()
 8     {
 9         if (!source.done()) 
10         {
11             data_block current_block = source.get_next_data_block();
12             chunks = divide_into_chunks(current_block, num_threads);
13         }
14     };
15 
16     //先对数据进行分割
17     split_source();
18 
19     result_block result;
20 
21     auto cbk1 = [&]()
22     {
23         sink.write_data(std::move(result));
24         split_source();
25         return -1;
26     };
27 
28     //等到线程都到达时，其中一个线程会调用cbk1补全函数
29     std::experimental::flex_barrier sync(num_threads, cbk1);
30 
31     std::vector<joining_thread> threads(num_threads);
32     for (unsigned i = 0; i < num_threads; ++i) 
33     {
34         auto cbk2 = [&, i]
35         {
36             while (!source.done())
37             {
38                 result.set_chunk(i, num_threads, process(chunks[i]));    //各个线程进行相关处理
39                 sync.arrive_and_wait();        //等待所有线程就位（就位后其中一个线程会调用补全函数cbk1）
40             }
41         };
42         threads[i] = joining_thread(cbk2);        //创建std::thread线程，会自动调用join()
43     }
44 }

Copyright

本文参考至《c++并发编程实战》第二版，作者：安东尼·威廉姆斯。本人阅读后添加了自己的理解并整理，方便后续查找，可能存在错误，欢迎大家指正，感谢！