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

等待事件或等待其他条件

坐车案例

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

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

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;

mutex _mtx;
bool bFlag = false;
void wait_for_flag()
{
    auto startTime = chrono::steady_clock::now();
    while (1)
    {
        unique_lock<mutex> lock(_mtx);
        if (bFlag)
        {
            auto endTime = chrono::steady_clock::now();
            double dCount = chrono::duration<double, std::milli>(endTime - startTime).count();
            cout << "wait_for_flag consume : " << dCount << endl;
            return;
        }
    }
}

void set_flag()
{
    auto startTime = chrono::steady_clock::now();
    unique_lock<mutex> lock(_mtx);
    for (int i = 0; i < 5; i++)
    {
        lock.unlock();
        //do something comsume 1000ms
        this_thread::sleep_for(chrono::milliseconds(1000));
        lock.lock();
    }

    bFlag = true;
    auto endTime = chrono::steady_clock::now();
    double dCount = chrono::duration<double, std::milli>(endTime - startTime).count();
    cout << "set_flag consume : " << dCount << endl;
}

int main()
{
    thread th1(wait_for_flag);
    thread th2(set_flag);
    th1.join();
    th2.join();
    return 0;
}

这种方式存在双重浪费：

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

程序输出如下：

set_flag consume : 5045.39
wait_for_flag consume : 5045.97

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

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

void wait_for_flag()
{
    auto startTime = chrono::steady_clock::now();
    unique_lock<mutex> lock(_mtx);
    while (!bFlag)
    {
        lock.unlock();
        //设置 500ms 的闹钟
        this_thread::sleep_for(chrono::milliseconds(500));    
        lock.lock();
    }

    auto endTime = chrono::steady_clock::now();
    double dCount = chrono::duration<double, std::milli>(endTime - startTime).count();
    cout << "wait_for_flag consume : " << dCount << endl;
}

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

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

set_flag consume : 5061.66
wait_for_flag consume : 5570.77

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

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

mutex _mtx;
bool bFlag = false;
condition_variable _cond;    //条件变量
void wait_for_flag()
{
    auto startTime = chrono::steady_clock::now();
    unique_lock<mutex> lock(_mtx);
    _cond.wait(lock, []() {return bFlag; });    //等待

    auto endTime = chrono::steady_clock::now();
    double dCount = chrono::duration<double, std::milli>(endTime - startTime).count();
    cout << "wait_for_flag consume : " << dCount << endl;
}

void set_flag()
{
    auto startTime = chrono::steady_clock::now();
    unique_lock<mutex> lock(_mtx);
    for (int i = 0; i < 5; i++)
    {
        lock.unlock();
        //do something comsume 1000ms
        this_thread::sleep_for(chrono::milliseconds(1000));
        lock.lock();
    }

    bFlag = true;
    _cond.notify_one();    //通知
    auto endTime = chrono::steady_clock::now();
    double dCount = chrono::duration<double, std::milli>(endTime - startTime).count();
    cout << "set_flag consume : " << dCount << endl;
}

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

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)

虚假唤醒

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

mutex _mtx;
condition_variable        _cond;
queue<int> _dataQueue;

void data_preparation_thread()
{
    while (true)
    {
        int _data = rand();
        {
            std::lock_guard<mutex> lock(_mtx);
            _dataQueue.push(_data);
        }
        _cond.notify_all();
        this_thread::sleep_for(chrono::milliseconds(1000));
    }
}

void data_processing_thread()
{
    while (true)
    {
        std::unique_lock<mutex> lock(_mtx);
        _cond.wait(lock, []()
            {
                bool bEmpty = _dataQueue.empty();
                if (bEmpty)
                    cout << this_thread::get_id() << " be spurious waken up\n";

                return !bEmpty;
            });
        int _data = _dataQueue.front();
        _dataQueue.pop();
        lock.unlock();

        cout << "threadID : " << this_thread::get_id() << " data = " << _data << endl;
    }
}

int main()
{
    srand(time(NULL));

    thread th1(data_processing_thread);
    thread th2(data_processing_thread);
    thread th3(data_preparation_thread);
    th1.join();
    th2.join();
    th3.join();
    return 0;
}

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

唤醒丢失

void wait_for_flag()
{
    unique_lock<mutex> lock(_mtx);
    _cond.wait(lock);    //等待
}

void set_flag()
{
    unique_lock<mutex> lock(_mtx);
    bFlag = true;
    _cond.notify_one();    //通知
}

int main()
{
    thread th1(set_flag);
    thread th2(wait_for_flag);
    th1.join();
    th2.join();
    return 0;
}

先执行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对象

std::promise<int> pro;
std::future<int> _fu = pro.get_future();
std::shared_future<int> _sfu = std::move(_fu);        //显示

std::promise<int> pro;
std::shared_future<int> _sfu = pro.get_future();        //隐式

std::promise<int> pro;
std::future<int> _fu = pro.get_future();
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，那么，在程序中如何获知当前的执行方式呢？方法如下：

std::future _fu = std::async(ThreadEntry);
future_status status = _fu.wait_for(std::chrono::microseconds(0));//等待0ms
if (status == future_status::deferred)        //延时执行
{
    //todo
}
else if (status == future_status::ready || status == future_status::timeout)
{
    //todo
}

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对象变为可用，而是等到该线程结束后才使其可用。

例如：

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()
{
    std::packaged_task<int(void)> task(ThreadEntry);
    std::future<int> _fu = task.get_future();

    task.make_ready_at_thread_exit(); //执行该函数后，_fu未就绪，调用get将出错
    //task();   //_fu立马就绪，调用get()不会出错
    cout << "value = " << _fu.get() << endl;
    return 0;
}

正确用法：

int main()
{
    std::packaged_task<int(void)> task(ThreadEntry);
    std::future<int> _fu = task.get_future();

    thread th1([&]() {task.make_ready_at_thread_exit(); });
    th1.detach();
    
    cout << "value = " << _fu.get() << endl;
    return 0;
}

reset()函数

void reset();

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

案例-在线程间传递任务

std::mutex m;
std::deque<std::packaged_task<void()>> tasks;

void gui_thread()
{
    while (...)   
    {
        std::packaged_task<void()> task;
        {
            std::lock_guard<std::mutex> lk(m);
            if (tasks.empty())    
                continue;
            task = std::move(tasks.front());    
            tasks.pop_front();
        }
        task();
        //其他操作
    }
}

template<typename Func>
std::future<void> post_task_for_gui_thread(Func f)
{
    std::packaged_task<void()> task(f);  
    std::future<void> res = task.get_future();  
    std::lock_guard<std::mutex> lk(m);
    tasks.push_back(std::move(task));    
    return res;    
}

std::promise-创建std::promise

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

void setValue(int nData, std::promise<int>& _pro)
{
    cout << "set value threadID : " << this_thread::get_id() << endl;
    this_thread::sleep_for(chrono::seconds(3));        //休息3秒
    _pro.set_value( nData * 2 + 5 );
}

void getValue(std::future<int>& _fu)
{
    cout << "get value threadID : " << this_thread::get_id() << endl;
    cout << "data = " << _fu.get() << endl;
}

int main()
{
    std::promise<int> pro;
    std::future fu = pro.get_future();

    thread th1(setValue, 10, std::ref(pro));
    thread th2(getValue, std::ref(fu));

    th1.join();
    th2.join();
    return 0;
}

构造函数

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存储到共享状态，在线程结束时，使共享状态进入就绪状态。

案例

void process_connections(vector<ConnectPackage>& connections)
{
    while (!done(connections))
    {
        for (auto itr : connections)
        {
            if (itr->has_incoming_data())        //有数据传入，接收
            {
                data_packet data = connection->incoming();
                std::promise<payload_type>& p = connection->get_promise(data.id);
                p.set_value(data.payload);
            }

            if (connection->has_outgoing_data())   //有数据需向外传递
            {
                outgoing_packet data = connection->top_of_outgoing_queue();
                connection->send(data.payload);
                data.promise.set_value(true);
            }
        }
    }
}

将异常保存到future中

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

double square_root(double x)
{
    if (x < 0)
        throw std::out_of_range("x < 0");
    
    return sqrt(x);
}

int main()
{
    std::future<double> f = std::async(square_root, -1);
    double dVal = f.get();
    return 0;
}

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

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

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

try
{
    pro.set_value(dVal);
}
catch (...)
{
    pro.set_exception(std::make_exception_ptr(std::logic_error("error")));
}

另一个方法是，直接销毁与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<>进行显示转换，例如：

std::chrono::milliseconds ms(54802);
std::chrono::seconds s = std::chrono::duration_cast<std::chrono::seconds>(ms);

cout << ms.count() << endl;    //54802
cout << s.count() << endl;     //54

强转将导致结果被截断。

count()函数

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

std::chrono::seconds s = std::chrono::seconds(1) * 5;
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日相隔多少天：

int main()
{
    using days_type = std::chrono::duration<int, std::ratio<60 * 60 * 24>>;

    std::chrono::time_point<std::chrono::system_clock, days_type> today = 
        std::chrono::time_point_cast<days_type>(std::chrono::system_clock::now());
    
    cout << today.time_since_epoch().count() << endl;
}

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

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

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

接受超时时限的函数

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

std::chrono::milliseconds ms(500);
this_thread::sleep_for(ms);

auto tp = std::chrono::high_resolution_clock::now() + std::chrono::milliseconds(500);
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;
}

后续函数的连锁调用

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

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

void process_login(std::string const& username, std::string const& password)
{
    try 
    {
        user_id const id = backend.authenticate_user(username, password);        //验证身份
        user_data const info_to_display = backend.request_current_info(id);        //请求账户信息
        update_display(info_to_display);        //更新显示
    }
    catch (std::exception& e) 
    {
        display_error(e);
    }
}

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

并行执行如下：

std::future<void> process_login(std::string const& username, std::string const& password)
{
    auto cbk = [=]()
    {
        try
        {
            const user_id id = backend.authenticate_user(username, password);        //验证身份
            const user_data info_to_display = backend.request_current_info(id);        //请求账户信息
            update_display(info_to_display);        //更新显示
        }
        catch (std::exception& e)
        {
            display_error(e);
        }
    };

    return std::async(std::launch::async, cbk);
}

 

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

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

std::experimental::future<void> process_login(std::string const& username, std::string const& password)
{
    //验证身份
    auto cbk1 = [=]()
    {
        return backend.authenticate_user(username, password);
    };

    //请求账户信息
    auto cbk2 = [](std::experimental::future<user_id> id)
    {
        return backend.request_current_info(id.get());
    };

    //更新显示
    auto cbk3 = [](std::experimental::future<user_data> info_to_display)
    {
        try {
            update_display(info_to_display.get());
        }
        catch (std::exception& e) {
            display_error(e);
        }
    };

    return spawn_async(cbk1).then(cbk2).then(cbk3);
}

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

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

std::experimental::future<void> process_login(std::string const& username, std::string const& password)
{
    auto cbk1 = [](std::experimental::future<user_id> id)
    {
        return backend.async_request_current_info(id.get());
    };

    auto cbk2 = [](std::experimental::future<user_data> info_to_display)
    {
        try
        {
            update_display(info_to_display.get());
        }
        catch (std::exception& e)
        {
            display_error(e);
        }
    };

    return backend.async_authenticate_user(username, password).then(cbk1).then(cbk2);
}

等待多个future全部就绪

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

std::future<FinalResult> process_data(std::vector<MyData>& vec)
{
    size_t const chunk_size = whatever;
    std::vector<std::future<ChunkResult>> results;

    for (auto begin = vec.begin(), end = vec.end(); beg != end;) 
    {
        const size_t  remaining_size = end - begin;
        const size_t  this_chunk_size = std::min(remaining_size, chunk_size);
        results.push_back(std::async(process_chunk, begin, begin + this_chunk_size));
        begin += this_chunk_size;
    }

    //新开线程，不断检查future是否就绪
    auto cbk = [all_results = std::move(results)]()
    {
        std::vector<ChunkResult> v;
        for (auto& f : all_results)
        {
            v.push_back(f.get());
        }
    };
    return std::async(cbk);
}

std::experimental::when_all()函数

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

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

上述代码可以改为如下：

std::experimental::future<FinalResult> process_data(std::vector<MyData>& vec)
{
    size_t const chunk_size = whatever;
    std::vector<std::experimental::future<ChunkResult>> results;
    for (auto begin = vec.begin(), end = vec.end(); beg != end;) 
    {
        const size_t remaining_size = end - begin;
        const size_t this_chunk_size = std::min(remaining_size, chunk_size);
        results.push_back(spawn_async(process_chunk, begin, begin + this_chunk_size));        
        begin += this_chunk_size;
    }

    auto cbk = [](std::future<std::vector<std::experimental::future<ChunkResult>>> ready_results)
    {
        std::vector<std::experimental::future<ChunkResult>> all_results = ready_results.get();
        std::vector<ChunkResult> v;
        v.reserve(all_results.size());

        for (auto& f : all_results)
        {
            v.push_back(f.get());
        }
        return gather_results(v);
    };

    return std::experimental::when_all(results.begin(), results.end()).then(cbk);
}

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

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

std::experimental::when_any()函数

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

代码如下：

struct DoneCheck
{
    std::shared_ptr<std::experimental::promise<FinalResult>> final_result;

    DoneCheck(std::shared_ptr<std::experimental::promise<FinalResult>> final_result_) : final_result(std::move(final_result_)) {}

    void operator()(std::experimental::future<std::experimental::when_any_result<std::vector<std::experimental::future<MyData*>>>> results_param)
    {
        auto results = results_param.get();
        const MyData* ready_result = results.futures[results.index].get();

        if (ready_result)
            final_result->set_value(process_found_value(*ready_result));
        else
        {
            results.futures.erase(results.futures.begin() + results.index);
            if (!results.futures.empty())
            {
                std::experimental::when_any(results.futures.begin(), results.futures.end()).then(std::move(*this));
            }
            else
            {
                final_result->set_exception(std::make_exception_ptr(std::runtime_error("Not found")));
            }
        }
    }
};

std::experimental::future<FinalResult> find_and_process_value(std::vector<MyData>& data)
{
    const unsigned  concurrency = std::thread::hardware_concurrency();
    const unsigned  num_tasks = (concurrency > 0) ? concurrency : 2;

    std::vector<std::experimental::future<MyData*>> results;

    auto const chunk_size = (data.size() + num_tasks - 1) / num_tasks;

    auto chunk_begin = data.begin();

    std::shared_ptr<std::atomic<bool>> done_flag = std::make_shared<std::atomic<bool>>(false);

    for (unsigned i = 0; i < num_tasks; ++i)
    {
        auto chunk_end = (i < (num_tasks - 1)) ? chunk_begin + chunk_size : data.end();

        auto cbk = [=]()
        {
            for (auto entry = chunk_begin; !*done_flag && (entry != chunk_end); ++entry)
            {
                if (matches_find_criteria(*entry))
                {
                    *done_flag = true;
                    return &*entry;
                }
            }
            return (MyData*)nullptr;
        };

        std::experimental::future<MyData*> _fu = spawn_async(cbk);
        results.push_back(std::move(_fu));
        chunk_begin = chunk_end;
    }

    std::shared_ptr<std::experimental::promise<FinalResult>> final_result = std::make_shared<std::experimental::promise<FinalResult>>();

    std::experimental::when_any(results.begin(), results.end()).then(DoneCheck(final_result));
    return final_result->get_future();
}

上面代码别看了，要命...（书上的更要命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序列和索引值，如下：

auto results = results_param.get();
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()。

例子如下：

void foo() 
{
    unsigned const thread_count = 5;
    std::experimental::latch done(thread_count);
    my_data data[thread_count];
    std::vector<std::future<void>> threads;

    for (unsigned i = 0; i < thread_count; ++i)
    {
        auto cbk = [&, i]()
        {
            data[i] = make_data(i);
            done.count_down();
            do_more_stuff();
        };

        std::future<void> _fu = std::async(std::launch::async, cbk);
        threads.push_back(std::move(_fu));
    }

    done.wait();
    process_data(data, thread_count);
}

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

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

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

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

代码如下：

void process_data(data_source& source, data_sink& sink)
{
    const unsigned concurrency = std::thread::hardware_concurrency();
    const unsigned num_threads = (concurrency > 0) ? concurrency : 2;            //线程个数

    std::experimental::barrier sync(num_threads);
    std::vector<joining_thread> threads(num_threads);

    std::vector<data_chunk> chunks;
    result_block result;

    for (unsigned i = 0; i < num_threads; ++i)
    {
        auto cbk = [&, i]()
        {
            while (!source.done())
            {
                if (!i) //在0号线程上做分割
                {
                    data_block current_block = source.get_next_data_block();    
                    chunks = divide_into_chunks(current_block, num_threads);    //分成num_threads块
                }

                sync.arrive_and_wait();        //其他线程等待0号线程分割完
                result.set_chunk(i, num_threads, process(chunks[i]));        //各个线程进行相关处理
                sync.arrive_and_wait();        //等待所有线程处理完

                if (!i) 
                {
                    sink.write_data(std::move(result));        //由0号线程负责处理写入操作
                }
            }
        };

        threads[i] = joining_thread(cbk);            //创建std::thread线程，会自动调用join()
    }
}

std::experimental::flex_barrier

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

代码如下：

void process_data(data_source& source, data_sink& sink)
{
    const unsigned concurrency = std::thread::hardware_concurrency();
    const unsigned num_threads = (concurrency > 0) ? concurrency : 2;
    std::vector<data_chunk> chunks;

    auto split_source = [&] ()
    {
        if (!source.done()) 
        {
            data_block current_block = source.get_next_data_block();
            chunks = divide_into_chunks(current_block, num_threads);
        }
    };

    //先对数据进行分割
    split_source();

    result_block result;

    auto cbk1 = [&]()
    {
        sink.write_data(std::move(result));
        split_source();
        return -1;
    };

    //等到线程都到达时，其中一个线程会调用cbk1补全函数
    std::experimental::flex_barrier sync(num_threads, cbk1);

    std::vector<joining_thread> threads(num_threads);
    for (unsigned i = 0; i < num_threads; ++i) 
    {
        auto cbk2 = [&, i]
        {
            while (!source.done())
            {
                result.set_chunk(i, num_threads, process(chunks[i]));    //各个线程进行相关处理
                sync.arrive_and_wait();        //等待所有线程就位（就位后其中一个线程会调用补全函数cbk1）
            }
        };
        threads[i] = joining_thread(cbk2);        //创建std::thread线程，会自动调用join()
    }
}

Copyright

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