C++并发编程----并发和同步（《C++ Concurrency in Action》 读书笔记）
文章目录
-
-
- 条件变量
- 构建线程安全队列
- std::future< > 、 std::shared_future< >
- 等待时间
-
本文为《C++ Concurrency in Action》 读书笔记，对其中的一些知识点进行总结。阅读这本书前建议先阅读《Effective C++》
条件变量
std::condition_variable 和 std::condition_variable_any 。这两个实现都包含 在 < condition_variable > 头文件的声明中。
两者都需要与一个互斥量一起才能工作(互斥量是 为了同步)；前者仅限于与 std::mutex 一起工作，而后者可以和任何满足最低标准的互斥量一 起工作，从而加上了_any的后缀。一般使用std::condition_variable_any会产生更多的开销和使用更多的资源，因此，我们一般首选std::condition_variable。
std::mutex mut;
std::queue<data_chunk> data_queue; // 1 两个线程之间传递数据的队列
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); // 2 对队列上锁，将准备好的数据压入队列中
data_cond.notify_one(); // 3 对等待的线程(如果有等待 线程)进行通知
}
}
void data_processing_thread()
{
while(true)
{
std::unique_lock<std::mutex> lk(mut);
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;
}
}
data_cond.wait() )会去检查这些条件(通过调用所提供的lambda函数)，当条件满足(lambda函数返回true) 时返回。如果条件不满足(lambda函数返回false)，wait()函数将解锁互斥量，并且将这个线程 (上段提到的处理数据的线程)置于阻塞或等待状态。当准备数据的线程调用notify_one()通知 条件变量时，处理数据的线程从睡眠状态中苏醒，重新获取互斥锁，并且对条件再次检查， 在条件满足的情况下，从wait()返回并继续持有锁。当条件不满足时，线程将对互斥量解锁， 并且重新开始等待。 使用 std::unique_lock 而不使用 std::lock_guard等待中 的线程必须在等待期间解锁互斥量，并在这之后对互斥量再次上锁，而 std::lock_guard 没有这么灵活。
构建线程安全队列
设计一个安全队列，用于线程之间的通信，安全队列的使用是非常重要的，比如线程池中一般就会使用安全队列用于传递信息。
#include 为了防止固有接口间的条件竞争，一般将front()和pop()合并成一个函数调用，也就是在一个函数中即完成出栈队列，又完成对数据的取用。
std::future< > 、 std::shared_future< >
当一个线程需要等待一个特定的一次性 事件时，在某种程度上来说它就需要知道这个事件在未来的表现形式。这个线程会周 期性(较短的周期)的等待或检查，事件是否触发；在检查期间也会执行其他任务 。在等待任务期间它可以先执行另外一些任务，直到对应的任务触 发，而后等待期望的状态会变为就绪(ready)。
唯一期望(unique futures)( std::future< > )和共享期望(shared futures)( std::shared_future< > )。 std::future 的实例只能与一个指定事件相关联， 而 std::shared_future 的实例就能关联多个事件。当多个线程需要访问一个独 立“期望”对象时，他们必须使用互斥量或类似同步机制对访问进行保护。
带返回值的后台任务
当一个任务的结果你不着急要时，你可以使用 std::async 启动一个异步任务。与 std::thread 对 象等待的方式不同， std::async 会返回一个 std::future 对象，这个对象持有最终计算出来 的结果。当你需要这个值时，你只需要调用这个对象的get()成员函数；
#include 与 std::thread 做的方式一样， std::async 允许你通过添加额外的调用参数，向函数传递额 外的参数。当第一个参数是一个指向成员函数的指针，第二个参数提供有这个函数成员类的 具体对象(不是直接的，就是通过指针，还可以包装在 std::ref 中), 剩余的参数可作为成员 函数的参数传入。
更多用法：
#include 调用方式选择：
auto f6=std::async(std::launch::async,Y(),1.2); // 在新线程上执行
auto f7=std::async(std::launch::deferred,baz,std::ref(x)); // 在 wait()或get()调用时执行
auto f8=std::async( std::launch::deferred | std::launch::async, baz,std::ref(x)); // 实现选择执行方式
auto f9=std::async(baz,std::ref(x));
f7.wait(); // 调用延迟函数
任务和期望 packaged_task
std::packaged_task<> 对一个函数或可调用对象，绑定一个期望。当 std::packaged_task<> 对象被调用，它就会调用相关函数或可调用对象，将期望状态置为就绪，返回值也会被存储 为相关数据。
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::packaged_task 作为一个函数调用时，可为函数调用操作 符提供所需的参数，并且返回值作为异步结果存储在 std::future ，可通过get_future()获 取。你可以把一个任务包含入 std::packaged_task ，并且在检索期望之前，需要 将 std::packaged_task 对象传入，以便调用时能及时的找到。
使用std::promises
可以通过get_future()成员函数来获取与一个给定的 std::promise 相关的 std::future 对象。
void fun1(std::promise<int> &p)//线程1执行函数
{
int Val = 15;
std::cout << "传入数据(int)：" << Val <<endl;
p.set_value(Val);//设置数据
}
void fun2(std::future<int> &f)//线程二指向函数
{
auto Val = f.get(); //会阻塞，知道收到数据
cout << iVal <<endl;
}
实际上，可以通过promise传递函数指针，可调用对象，以及typename类型等。
参考：promise、
std::shared_future< >
std::future 模型独享同步结果的所有权，并且通过调用get()函数，一次性 的获取数据，只有一个线程可以获取结果值，因为在第一 次调用get()后，就没有值可以再获取了。
如果想要多个线程等待同一结果，我们就需要使用std::shared_future< >， std::shared_future 实例是可拷贝的，所以多个对象可以引用同一关联“期望”的结果。
也可以将std::future的所有权移动到std::shared_future，如下方式：
std::promise<int> p;
std::future<int> f(p.get_future());
assert(f.valid()); // 1 "期望" f 是合法的
std::shared_future<int> sf(std::move(f));
assert(!f.valid()); // 2 "期望" f 现在是不合法的
assert(sf.valid()); // 3 sf 现在是合法的
std::promise<std::string> p;
std::shared_future<std::string> sf(p.get_future()); // 1 隐式转移 所有权
也可以采用std::future的share()函数直接将实例化的对象转换为std::shared::future.
std::promise< std::map< SomeIndexType, SomeDataType,
SomeComparator,
SomeAllocator>::iterator> p;
auto sf=p.get_future().share(); //sf的类型为shared_future
等待时间
有两种方式设定线程的等待时间：一种是“时延”的超时方式，另一种是“绝对”超时方 式。第一种方式，需要指定一段时间(例如，30毫秒)；第二种方式，就是指定一个时间点(例 如，协调世界时[UTC]17:30:15.045987023，2011年11月30日)。
一般处理持续时间的变量以“_for”作为后缀，处理绝对时间的变量 以"_until"作为后缀。std::condition_variable 的两个成员函数wait_for()和wait_until()成员函数分别有两 个负载，这两个负载都与wait()成员函数的负载相关——其中一个负载只是等待信号触发，或 时间超期，亦或是一个虚假的唤醒，并且醒来时，会检查锁提供的谓词，并且只有在检查为 true时才会返回(这时条件变量的条件达成)，或直接而超时。
时钟
时钟的当前时间可以通过调用静态成员函数now()从时钟类中获取， std::chrono::system_clock::now() 是将返回系统时钟的当前时间。特定的时间点类型可 以通过time_point的数据typedef成员来指定，所以some_clock::now()的类型就是 some_clock::time_point
时延
std::chrono::duration<> 函数模板能够对时延进行处理(线程库使 用到的所有C++时间处理工具，都在 std::chrono 命名空间内)。第一个模板参数是一个类型 表示(比如，int，long或double)，第二个模板参数是制定部分，表示每一个单元所用秒数。例 如，当几分钟的时间要存在short类型中时，可以写成 std::chrono::duration
标准库在 std::chrono 命名空间内，为延时变量提供一系列预定义类型：nanoseconds[纳秒] , microseconds[微秒] , milliseconds[毫秒] , seconds[秒] , minutes[分]和hours[时]。而且他们之间可以相互转换。
std::chrono::milliseconds ms(54802);
std::chrono::seconds s=
std::chrono::duration_cast<std::chrono::seconds>(ms);
这里的结果就是截断的，而不是进行了舍入，所以s最后的值将为54。
时延可以进行计算，例如，5*seconds(1)与seconds(5)或minutes(1)- seconds(55)一样。在时延中可以通过count()成员函数获得单位时间的数量。例 如， std::chrono::milliseconds(1234).count() 就是1234。
使用方式：
std::future<int> f=std::async(some_task);
if(f.wait_for(std::chrono::milliseconds(35))==std::future_status
::ready)
do_something_with(f.get());
等待函数会返回一个状态值，来表示等待是超时，还是继续等待。在这种情况下，你可以等 待一个“期望”，所以当函数等待超时时，会返回 std::future_status::timeout ；当“期望”状态 改变，函数会返回 std::future_status::ready ；当“期望”的任务延迟了，函数会返 回 std::future_status::deferred 。
时间点
时钟的时间点可以用 std::chrono::time_point< > 的类型模板实例来表示，实例的第一个参数 用来指定所要使用的时钟，第二个函数参数用来表示时间的计量单位(特化 的 std::chrono::duration< > )。你可以通过 std::chrono::time_point<> 实例来加/减时延，来获得一个新的时间点，所 以 std::chrono::hight_resolution_clock::now() + std::chrono::nanoseconds(500) 将得到500纳 秒后的时间。
可以利用时间点计算某个代码块的运行时间。
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.1展示 了C++标准库中支持超时的函数。参数列表为“延时”(duration)必须是 std::duration<> 的实 例，并且列出为时间点(time_point)必须是 std::time_point<> 的实例。
