《C++ concurrency in action》 读书笔记 －－ Part 3 第四章 线程的同步

唐风

www.cnblogs.com/liyiwen

---

《C++ concurreny in action》 第四章 Synchronizing concurrent operations

这一章主要讲C++11中的进行线程同步的方法

4.1 Waiting for an event or other condition

经常遇到的一种场景是一个线程A需要等待另一个线程B完成一些“事”（操作）才能往下运行继续处理。

有以下几种“办法”

一，设置一个多个线程都能访问到的变量，B线程一旦完成自己的操作，就把这个全局的变量设为某个值，而线程A则 不断地去检查变量的值是不是已经设置为这个值，一直到满足条件才往下执行。否则就一直循环地Check这个变量。（当然，A和B都要通过互斥锁来访问变量）。这个方法一般来说都不行，A不断地执行检查变量值只是个纯粹浪费CPU处理时间的操作。而且由于A进行锁定的时候，B还不能去操作那个被锁定全局变量，也无形中增加了最终条件满足所需要的时间

二，方法一的改进，就是A线程Sleep一段时间再检查一次

bool flag;
std::mutex m;
void wait_for_flag()
{
    std::unique_lock<std::mutex> lk(m);
    while(!flag) 
    {
        lk.unlock(); 
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); 
        lk.lock(); 
    }
}

这个方法性能更好，但是A的sleep时间取多少并不很好判断，而且这个方法对于实时的或是要求快速反应的程序并不合并

三，用事件来进行同步

这是最“正常的”解法。C++11中提供了相应的库和函数来完成这种任务。

其中最为常见的就是：condition variable（条件变量）。条件变量（condition variable）会把信号量（event）与某些条件在一起，如果一个线程把这个条件变量设置某满足某一条件时，condition variable就会自动地通知其它等待这个条件的线程。

4.1.1 Waiting for a condition with condition variable

C++11中有两种condition variable的实现：

std::condition_variable 和 std::condition_variable_any （都定义在<condition_variable>头文件中）

• std::condition_variable只能与mutex一起使用
• std::condition_variable_any可以与mutext-like（只需要满足一些最低要求锁操作的“锁”，不仅限于mutex）一起使用，但是，可能会“更大更慢更占操作系统资源一些”

std::condition_variable的使用例：

std::mutex mut;
std::queue<data_chunk> data_queue; 
std::condition_variable data_cond;
void data_preparation_thread()
{
    while(more_data_to_prepare())
    {
        data_chunk const data=prepare_data();
        std::lock_guard<std::mutex> lk(mut);
        data_queue.push(data); 
        data_cond.notify_one(); 
    }
}
void data_processing_thread()
{
    while(true)
    {
        std::unique_lock<std::mutex> lk(mut);    // (1)
        data_cond.wait(lk,[]{return !data_queue.empty();}); 
        data_chunk data=data_queue.front();
        data_queue.pop();
        lk.unlock(); 
        process(data);
        if(is_last_chunk(data))
            break;
    }
}

注意（1）必须使用 unique_lock，而不能用guard_lock，因为在condition_variable内部实现中，有可能要多次进行lock和unlock操作。

4.1.2

因为线程间的共享数据的queue非常之有用，而上面的例子并不是一个很好的用法，本节构造了一个好的“线程间共享queue”。

4.2 Waiting for one-off events with futures

one-off event就是“只需要等一次的事件”。C++11对这种场景提供了 future 模型。如果一个线程需要等待一个“只会发生一次的”事件，它就可以获取一个包含这个 event 的 future。别的线程可以把 future 设置为 ready 状态，这样等待 future的线程就可以知晓并接着进行处理。future一旦ready就不能再重新设置了（不会再变成 unready状态了）

C++标准库中有两种future，

• unique future -> std::future<>
• shared_future -> std::shared_future<>

是模仿智能指针 std::unique_ptr 和 std::share_ptr 的思路来分类的。

最常见的一种one-off event的场景就是开启一个线程进行后台的计算，而主线程去做些别的事，之后再等这个计算的结果出来。当从第二章我们知道，std::thread 没有提供什么方便的方法可以让你取得线程调用函数的“返回值”。这种场景的一个方案就是：std::async

4.2.1 从后台线程中返回值

std::async和“线程”几乎有同样的作用，但是它会返回一个future，这个future就带有线程函数的返回值。你可以用future.get()来获取这个值，get()函数会在线程结果之前一直阻塞。

#include <future>
#include <iostream>
int find_the_answer_to_ltuae();
void do_other_stuff();
int main()
{
    std::future<int> the_answer=std::async(find_the_answer_to_ltuae);
    do_other_stuff();
    std::cout<<"The answer is "<<the_answer.get()<<std::endl;
}

std::async像std::thread一样，可以在构造的时候给线程主函数进行传参。本节比较详细地说明了传参的方法（主要是：如何传引用和如何move）

struct X
{
    void foo(int,std::string const&);
    std::string bar(std::string const&);
};
X x;
auto f1=std::async(&X::foo,&x,42,"hello"); 
auto f2=std::async(&X::bar,x,"goodbye"); 
struct Y
{
    double operator()(double);
};
Y y;
auto f3=std::async(Y(),3.141); 
auto f4=std::async(std::ref(y),2.718); 
X baz(X&);
std::async(baz,std::ref(x)); 
class move_only
{
public:
    move_only();
    move_only(move_only&&)
    move_only(move_only const&) = delete;
    move_only& operator=(move_only&&);
    move_only& operator=(move_only const&) = delete;
    void operator()();
};
auto f5=std::async(move_only());

std::async一构造完就会启动线程函数，还是要等future.get()被调用才启动线程函数，这是取决是编译器提供商的实现的（标准并没有进行规定）。但如果你想确认它，你可以指定参数：std::launch（立即启动新线程） 或是 std::deferred（等到wait或是get函数被调用时才启动新线程）。

auto f6=std::async(std::launch::async,Y(),1.2); 
auto f7=std::async(std::launch::deferred,baz,std::ref(x)); 
auto f8=std::async( 
std::launch::deferred | std::launch::async,
baz,std::ref(x));
auto f9=std::async(baz,std::ref(x)); 
f7.wait();

将future与并行任务关联的方法除了使用 std::async之外，还可以使用 std::packaged_task<>，或是std::promise<>，其中std::packaged_task是std::promise的高层一些的抽象。下节就讲这个。

4.2.2 Associating a task with a future

std::packaged_task<>可以把任务（Task，函数或是函数对象之类可调用的东西）与future关联起来，当std::packaged_task被调用的时候，它就会调用自己所包装的任务，并在可调用对象返回时把值设置到future中，然后再把future设定为ture。这个可以用在构造线程池时使用（第九章）会讲这个，也可以用在其它的任务管理调度。

std::packaged_task<>的模板参数与std::function的类似，是可调用对象的类型签名（像void()，int(std::string&, double*)之类的），但参数部分是用来进行并行任务的参数列表，而返回值部分则是可从future中get到的值的类型

template<>
class packaged_task<std::string(std::vector<char>*,int)>
{
public:
template<typename Callable>
explicit packaged_task(Callable&& f);
std::future<std::string> get_future();
void operator()(std::vector<char>*,int);
};

std::packaged_task是个可调用的对象，因此它也可以被封装在std::function中，或是使用在std::thread中表示一个线程的执行函数，或是在别的函数中调用，调用完之后它会把返回值作为异步的结果放在所关联的std::future中。所以使用时，我们可以把一个需要执行的任务包装在std::packaged_task中，然后获取它的std::future后，把这个包装好的任务传递给其它的线程。等我们需要这个任务的返回值的时候，我们就可以等待future变成ready。

下面是一个GUI的例子：

#include <deque>
#include <mutex>
#include <future>
#include <thread>
#include <utility>

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

void gui_thread() 
{
    while(!gui_shutdown_message_received()) 
    {
        get_and_process_gui_message(); 
        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(); 
    }
}

std::thread gui_bg_thread(gui_thread);
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; 
}

《C++ concurreny in action》 第四章 Synchronizing concurrent operations

4.2.3 Makeing (std::)promise

但是有时候我们在异步地获取值的时候，并不能总是“获取一个可调用对象的返回值”这么简单，在这些场景下，我们不一定能包装成一个可调用对象，或是，我们需要在一个函数获取多种不同类型的返回，这时std::packaged_task就不好用了。这种情况下我们可以使用std::promise。总的来说，std::promise/std::future对与std::packaged_task/std::future对的关系是类似的。我们也可以从一个promise关联获取一个std::future，当调用std::promise的set_value成员函数时，它所关联的std::future的值就会被设定，而且成为ready状态。

下面是一个例子：

#include <future>

void process_connections(connection_set& connections)
{
    while(!done(connections)) 
    {
        for(connection_iterator connection=connections.begin(),end=connections.end();
            connection!=end;
            ++connection)
        {
            if(connection->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); 
            }
        }
    }
}

4.2.4 Saving an exception for the future

在上面的例子中，我们都没有提到出现异常的情况。虽然 std::future与std::async/std::packaged_task/std::promise的场景大部分是多线中，但标准仍然提供了一个像“单线程环境”中的异常那样比较“符合”我们想像的处理方法：当std::async/std::packaged_task/std::promise发生异常时，可以把异常保存在std::future当中，等另一个线程调用 std::future和get/wait函数时，再把这个异常重新抛出（这时抛出的是原来异常的引用还是拷贝，则取决于编译器的实现）。std::async/std::packaged_task的情况下，我们不需要做额外的处理，这一切库函数已经做好了，std::promise的情况下，为了抛出异常，我们要则要调用 set_exception而不是set_value

extern std::promise<double> some_promise;
try
{
    some_promise.set_value(calculate_value());
}
catch(...)
{
    some_promise.set_exception(std::current_exception());
}

另外，如果std::promise的set_value函数没有被调用，或是std::packaged_task没有被调用就被析构了的话，他们也会把异常（std::future_error，值为std::future_errc::broken_promise）存在std::future中，并把future设置为ready。

4.2.5 Waiting from multiple threads

std::future的资源占有方式是unique的，只能在一个线程中获取（moveable）。如果有多个线程需要获取同一个future的话，必须使用std::shared_future（copyable）。

std::promise<std::string> p;

std::shared_future<std::string> sf(p.get_future());

4.3 Waiting for a time limit

前面介绍的所以有阻塞的调用“永远等待”的，不会超时。如果要设置超时，需要另外指定。

大体上分，C++11中有两种设置超时的方法，一种是设置超时的期间（duration-based），也就是从调用起多长时间超时（一般都是_for后缀），另一种是设置超时的绝对时间点（absolute timeout，一般是_util后缀）。

4.3.1 Clocks

C++中处理时间一般可以使用clock，clock可以提供下面4项内容

The time now

■ The type of the value used to represent the times obtained from the clock

■ The tick period of the clock

■ Whether or not the clock ticks at a uniform rate and is thus considered to be a steadyclock

静态函数now()可以获得现在的时间。比如std::chrono::system_clock::now()可以获取现在的系统时钟的时间。

tick period是以秒的分数形式指定的，std::ratio<1,25>就是1秒跳25次，std::ratio<5,2>就是2.5秒跳一次

4.3.2 Duration

时间段用std::chrono::duration来表示，这个类有两个模板参数，第一个表示时间的类型（int, long, double），第二个参数是一个“分数”，表示了一个单位的duration对象是多少秒，比如

std::chrono::duration<short, std::ratio<60, 1>> 就是60秒

std::chrono::duration<double,std::ratio<1,1000>> 是1/1000秒

标准库定义了一些duration的typedef：

nanoseconds, microseconds, milliseconds, seconds, minutes, hours

duration之间是可以隐式转换和进行算术运算的（此处不详记）

4.3.3 Time point

std::chrono::time_point<>表示一个时间点。

接受两个模板参数，第一个模板参数表示使用的“时钟”，第二个模板参数表示“计量的单位”（用 std::chrono::duration<>来指定）

比如：

std::chrono::time_point<std::chrono::system_clock, std::chrono::minutes> 就是指使用系统时钟进行，并以分为单位测定的时间点。std::chrono::time_point是可以与std::chrono::duration进行运算而得到新的std::chrono::time_point的。

auto start=std::chrono::high_resolution_clock::now();
do_something();
auto stop=std::chrono::high_resolution_clock::now();
std::cout<<”do_something() took “
        <<std::chrono::duration<double,std::chrono::seconds>(stop-start).count()
        <<” seconds”<<std::endl;

4.3.4 Functions that accept timeouts

线程库中可以指定Timeout的函数如下表

4.4 主要是讲如何使用前章和本章中介绍的技术来简化C++的代码（模拟一些Function Programming风格）。此处略去，