纯净、安全、绿色的下载网站

首页|软件分类|下载排行|最新软件|IT学院

当前位置:首页IT学院IT技术

C++ 对多线程/并发的支持 C++ 多线程编程建议之 C++ 对多线程/并发的支持(下)

Zijian/TENG   2021-10-12 我要评论
想了解C++ 多线程编程建议之 C++ 对多线程/并发的支持(下)的相关内容吗,Zijian/TENG在本文为您仔细讲解C++ 对多线程/并发的支持的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:C++,多线程并发,C++,多线程,下面大家一起来学习吧。

前言:

本文承接前文  C++ 对多线程/并发的支持(上) ,翻译自 C++ 之父 Bjarne Stroustrup 的 C++ 之旅(A Tour of C++)一书的第 13 章 Concurrency。本文将继续介绍 C++ 并发中的 future/promise,packaged_task 以及 async() 的用法。

1、通信任务

标准库还在头文件 <future> 中提供了一些机制,能够让编程人员基于更高的抽象层次任务来开发,而不是直接使用低层的线程、锁:

  • future promise:用于从任务(另一个线程)中返回一个值
  • packaged_task:帮助启动任务,封装了 future promise,并且建立两者之间的关联
  • async() :像调用一个函数那样启动一个任务。形式最简单,但也最强大!

1.1 future 和 promise

future promise 可以在两个任务之间传值,而无需显式地使用锁,实现了高效地数据传输。其基本想法很简单:当一个任务向另一个任务传值时,把值放入 promise,通过特定的实现,使得值可以通过与之关联的 future 读出(一般谁启动了任务,谁从 future 中取结果)。

假如有一个 future<X>fx,我们可以通过 get() 获取类型 X 的值:

X v = fx.get(); // if necessary, wait for the value to get computed

如果值还没有计算出,则调用 get() 的线程阻塞,直到有值返回。如果值无法计算出,get()可能抛出异常。

promise 的主要目的是提供一个简单的“put”的操作(set_value set_exception),和 future get() 相呼应。

如果你有一个 promise,需要发送一个类型为 X 的结果到一个 future,你要么传递一个值,要么传递一个异常。举个例子:

void f(promise<X>& px) // 一个任务:把结果放入 px
{
    try {
        X res;
        // 计算 res 的值
        px.set_value(res);
    }
    catch(...) { // 如果无法计算 res 的值
        px.set_exception(current_exception()); // 传异常到 future 的线程
    }
}


current_exception() 即捕获到的异常。

要处理通过 future 传递的异常,get() 的调用者必须在什么地方捕获,例如:

void g(future<X>& fx) // 一个任务;从 fx 提取结果
{
    try {
        X v = fx.get(); // 如有必要,等待值计算完成
        // 使用 v
    }
    catch(...){ // 无法计算 v
        // 错误处理
    }
}

如果 g() 不需要自己处理错误,代码可以进一步简化:

void g(future<X>& fx) // 一个任务;从 fx 提取结果
{
    X v = fx.get(); // 如有必要,等待值计算完成
    // 使用 v
}

思考:future 和 promise 是怎么关联起来的?

1.2 packaged_task

如何把 future 放入一个需要结果的任务,并且把与之关联的、产生结果的 promise 放入线程?packaged_task 可以简化任务的设置,关联 future/promisepackaged_task 封装了把返回值或异常放入 promise 的操作,并且调用 packaged_task get_future() 方法,可以得到一个与 promise 关联的 future。举个例子,我们可以设置两个任务,借助标准库的 accumulate() 分别累加 vector<double> 的前后部分:

double accum (double* beg, double* end, double init) // 计算以 init 为初值,[beg,end) 的和
{
    return accumulate(beg,end,init);
}

double comp2(vector<double>& v)
{
    using Task_type = double(double*,double*,double); // 任务的类型

    packaged_task<Task_type> pt0 {accum}; // 打包任务(即 accum)
    packaged_task<Task_type> pt1 {accum};

    future<double> f0 {pt0.get_future()}; // 取得 pt0 的 future
    future<double> f1 {pt1.get_future()}; // 取得 pt1 的 future

    double* first = &v[0];
    thread t1{move(pt0),first,first+v.size()/2,0};          // 为 pt0 启动线程
    thread t2{move(pt1),first+v.size()/2,first+v.size(),0}; // 为 pt1 启动线程

    return f0.get() + f1.get();
}

packaged_task 模板以任务的类型(Task_type,double(double*,double*,double) 的别名)作为其模板参数,以任务(accum)作为其构造函数的参数。move() 操作是必要的,因为 packaged_task 不可拷贝(只能移动)。packaged_task 不可拷贝是因为它是一个资源处理程序(resource handler),拥有 promise 的所有权,并且(间接地)负责与之关联的任务可能拥有的资源。

请注意,这里的代码没有显式地使用锁:我们能够专注于要完成的任务,而不是来管理它们通信的机制。这两个任务在不同的线程中执行,具有了潜在的并发性。

1.3 async()

我在本章所追求的思路,最简单,但也非常强大:把任务看成是一个恰巧可能和其他任务同时运行的函数。这并不是 C++ 标准库所支持的唯一模型,但它能很好地满足各类广泛的需求。其他更微妙、棘手的模型,如依赖于共享内存的编程风格也可以根据实际需要使用。

要启动潜在异步执行的任务,我们可以用 async():

double comp4(vector<double>& v) // 如果 v 足够大,派生多个任务
{
    if(v.size()<10000) // 犯得着用并发吗?
        return accum(v.begin(),v.end(),0);
    
    auto v0 = &v[0];
    auto sz = v.size();
    
    auto f0 = async(accum,v0,v0+sz/4,0.0);
    auto f1 = async(accum,v0+sz/4,v0+sz/2,0.0);
    auto f2 = async(accum,v0+sz/2,v0+sz*3/4,0.0);
    auto f3 = async(accum,v0+sz*3/4,v0+sz,0.0);
    
    return f0.get()+f1.get()+f2.get()+f3.get(); // 收集 4 部分的结果,求和
}

大体上,async() 把“调用部分”和“获取结果部分“分离开来,并且将两者和实际执行的任务分离。使用 async() 你不需要考虑线程、锁;你只要从任务(潜在地、异步地计算结果)的角度去考虑就可以了。async() 也有明显的限制:使用了共享资源、需要上锁的任务无法使用 async() ,你甚至不知道会用到多少线程,这完全是由 async() 决定的,它会根据调用时系统可用资源的情况,决定使用多少线程。例如,async() 在决定使用几个线程前,会检查有多少核心(处理器)空闲。

示例代码中的猜测计算开销和启动线程的相对开销(v.size()<10000)只是一个很原始、粗略的性能估计。这里不适合展开讨论怎么去管理线程,但这个估计仅仅是一个简单(可能很烂)的猜测。

请注意,async()不仅仅是专门用于并行计算、提高性能的机制。例如,它也能用于派生任务,从用户获取输入,让“主程序”忙其他事情。

2、建议

使用并发改善响应性和吞吐量
尽可能在最高级别的抽象上工作(比如优先考虑 asyncpackaged_task 而不是 threadmutex
考虑使用进程作为线程的替代方案
标准库的并发支持是类型安全的
内存模型把多数程序员从考虑机器架构的工作中解放出来
内存模型使得内存的表现和我们的预期基本一致
原子操作为无锁编程提供了可能性
把无锁编程留给专家
有时顺序操作比起并发更简单、更快
避免数据竞争(不受控地同时访问可变数据)
std::thread 是类型安全的系统线程接口
join() 等待一个线程结束
尽量避免显式共享数据
unique_lock 管理 mutexes
lock() 一次性获取多个锁
condition_variable 管理线程之间的通信
从(可以并行执行的)任务的角度思考,而非线程
不要低估“简单性”的价值
选择 packaged_task future,而不是直接使用 thread mutex
promise 返回结果,从 future 获取结果
packaged_task 处理任务抛出的异常或返回值
packaged_task future 来表示对外部服务的请求,以及等待其回复
async() 启动简单的任务

上一篇:  C++ 对多线程/并发的支持(上)


相关文章

猜您喜欢

  • Java 中的控制反转(IOC) Java 中的控制反转(IOC)详解

    想了解Java 中的控制反转(IOC)详解的相关内容吗,2cy-在本文为您仔细讲解Java 中的控制反转(IOC)的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Java,Spring,Spring控制反转,下面大家一起来学习吧。..
  • mysql自动插入数据 mysql自动插入百万模拟数据的操作代码

    想了解mysql自动插入百万模拟数据的操作代码的相关内容吗,void_main()在本文为您仔细讲解mysql自动插入数据的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:mysql自动插入数据,mysql自动插入百万模拟数据,下面大家一起来学习吧。..

网友评论

Copyright 2020 www.3a4a5a.com 【3A软件站】 版权所有 软件发布

声明:所有软件和文章来自软件开发商或者作者 如有异议 请与本站联系 点此查看联系方式