针对多个任务的C++ std::async与线程
C++中的std::async和线程都是用于实现并发编程的工具，可以帮助开发人员更好地利用多核处理器的性能。它们可以用于同时执行多个任务，提高程序的效率和响应性。
- C++ std::async：
- 概念：std::async是C++11引入的一个函数模板，用于创建异步任务。它返回一个std::future对象，可以用于获取异步任务的结果。
- 分类：std::async属于C++标准库中的future和promise机制，用于实现异步编程。
- 优势：
- 简化了并发编程：std::async可以方便地创建异步任务，无需手动管理线程的创建和销毁。
- 提高程序的响应性：通过异步执行任务，可以避免阻塞主线程，提高程序的响应性能。
- 灵活的任务调度：std::async可以根据系统资源和任务的优先级自动调度任务的执行。
- 应用场景：适用于需要并发执行多个独立任务的场景，例如并行计算、网络请求、IO操作等。
- 腾讯云相关产品：腾讯云提供了云函数SCF（Serverless Cloud Function）服务，可以用于实现无服务器的异步任务处理。详情请参考：腾讯云云函数SCF
- 线程：
- 概念：线程是操作系统中能够独立运行的最小单位，是进程中的一个执行流程。在C++中，可以使用std::thread类来创建和管理线程。
- 分类：线程属于操作系统和编程语言级别的并发编程机制。
- 优势：
- 并发执行：线程可以并发执行多个任务，充分利用多核处理器的性能。
- 共享内存：线程可以共享进程的内存空间，方便数据的共享和通信。
- 灵活性：线程可以通过同步机制（如互斥锁、条件变量）实现任务的协调与同步。
- 应用场景：适用于需要精细控制任务执行顺序、共享数据的场景，例如游戏开发、图像处理、并发服务器等。
- 腾讯云相关产品：腾讯云提供了弹性容器实例（Elastic Container Instance）服务，可以用于快速创建和管理容器实例，实现高效的任务并发处理。详情请参考：腾讯云弹性容器实例
综上所述，C++的std::async和线程都是用于实现并发编程的工具，各自具有不同的特点和适用场景。在选择使用时，可以根据具体需求和情况进行权衡和选择。腾讯云提供了云函数SCF和弹性容器实例ECI等相关产品，可以帮助开发人员更好地利用云计算资源进行并发编程。
相关·内容
考虑一下类似于这样的Connection TCP服务器程序中的boost::asio类。
#ifndef CONNECTION_HPP
#define CONNECTION_HPP
#include <iostream>
#include <boost/asio.hpp>
namespace Transmission
{
class Connection
{
public:
using SocketType = boost::asio::ip::tcp::socket;
explicit Connection(
浏览 4提问于2020-06-15得票数 1
回答已采纳
2回答
C++异步与OpenMP任务
、、、、
在In OpenMP中，我可以创建一组任务，如下所示，并使用一定数量的线程异步运行它们：
#pragma omp parallel
{
#pragma omp single
{
for (int i = 0; i < 1000; i++) {
#pragma omp task
f(i);
} } }
In C++11，我可以做一些不一样的std::async。
std::vector<std::future> futures;
for (int i = 0; i < 1000; i++) {
aut
浏览 4提问于2017-12-19得票数 11
回答已采纳
1回答
作为一名前C++程序员，Haskell线程的行为令人困惑。请参阅以下Haskell代码片段：
import Control.Concurrent
import Control.Concurrent.MVar
import Data.Functor.Compose
import System.Random
randomTill0 :: MVar () -> IO () -- Roll a die until 0 comes
randomTill0 mV = do
x <- randomRIO (0,65535) :: IO Int
if 0 == x
浏览 2提问于2019-10-26得票数 5
回答已采纳
2回答
在刚开始的时候，无论是C++还是以后，我都听说了一些关于std::async的问题。我有两个问题：
对于初级开发人员，在使用std::async时，是否有一套规则用于操作和避免？
这个视频中出现了什么问题？它们与有关吗？
浏览 7提问于2012-09-20得票数 18
回答已采纳
4回答
我在尝试一个程序：
#include <iostream>
#include <thread>
#include <future>
int foo() {
return 0;
}
int main(int argc, char* argv[]) {
for (auto i = 0L; i < 10000; ++i) {
auto f = std::async(foo);
f.get();
}
return 0;
}
编译器VS11 x64.
内部版本：
cl /EHsc /Zi async.cpp &&
浏览 4提问于2012-04-24得票数 12
3回答
在c++中使用异步函数总是一个好主意吗？
实际上，我的意思是，很多时候，我们可能需要做一些简单的事情，比如创建一个函数，返回是否为no是素数等等，那么它是使c++代码更快还是更慢呢？
//示例代码
#include <iostream>
#include <future>
using namespace std;
bool AsyncTest(int n){
//do some stuffs
return true;
}
int main(int argc, char *argv[])
{
for(int i=1;i<=10;i++
浏览 4提问于2021-04-13得票数 1
回答已采纳
我想检查Mysql连接是否是活动的。(使用Mysql-连接器-c++)
所以..。我每5分钟调用一次“检查函数”。
像这样
void checkConnection()
{
std::this_thread::sleep_for(std::chrono::minutes(5));
// -- check connection
std::async(std::launch::async, checkConnection); // Here
}
安全吗？
浏览 3提问于2016-02-24得票数 1
回答已采纳
2回答
C++是否有Wait+Wake同步线程的概念？等待事件、警报、物体等？比如WaitForSingleObject，WaitOnAddress，等等？我唯一能找到的东西是std::thread::join，以及锁和std::atomic等隔离/同步的东西。C++的线程还有更多吗?将来还会有更多的线程吗？
浏览 1提问于2014-10-22得票数 1
回答已采纳
4回答
在C++中，可以使用延迟或异步启动策略启动线程。有办法在Java中复制这个功能吗？
auto T1 = std::async(std::launch::deferred, doSomething());
auto T2 = std::async(std::launch::async, doSomething());
每项的描述--
异步：
如果设置了异步标志，那么异步将在一个新的执行线程上执行可调用对象f(所有线程局部变量初始化)，除非函数f返回一个值或抛出一个异常，它存储在通过std：：期货访问的共享状态中，异步将返回给调用方。
推迟：
如果设置了延迟标志，则异步转换f和args
浏览 7提问于2021-01-26得票数 6
3回答
我想多次调用具有异步的方法。下面是一个简化的例子：
size_t counter(std::string &s)
{
return s.size();
}
void stringCountAccumulator()
{
std::vector<std::string> foos = {"this", "is", "spartaa"};
size_t total = 0;
for (std::string &s : foos)
{
std::future<s
浏览 5提问于2017-02-18得票数 8
回答已采纳
我正试图在C++中使用Coroutines和多线程。
在许多coroutine示例中，它们在co_await操作符的co_await中创建了一个新线程。我想在这个函数中提交一个线程池。
在这里，我为future<int>定义了一个future<int>。
void await_suspend(std::coroutine_handle<> handle) {
this->wait();
handle.resume();
}
我想修改这段代码，以提交一个指向线程池的lambda/function指针
浏览 11提问于2022-11-21得票数 0
我正在包装一个C++库，以便从.NET中使用。C++ API中有一些函数返回std::future。我希望.NET代理类返回System.Threading.Tasks.Task。
我考虑在C++端添加一个替换方法，该方法除了方法参数外，还包含一个函数指针。然后，我可以启动一个新线程(例如，使用std::async )，并在std::future::get上等待。一旦std::future::get返回，我就可以调用传入的函数指针。在C#端，我将传递一个指向函数的指针，该函数将完成返回的任务。类似于：
Task CallCpp(int a, int b) {
TaskCompletionS
浏览 0提问于2019-05-15得票数 7
1回答
目前，我正在使用C++ 11异步特性创建额外的线程来运行我的计算内核。计算内核是完全独立的，相互独立的。我想知道两件事。
这个计算模型是否适合于使用GPU进行优化？
如果问题1是真的，这种优化的基本做法是什么？
伪码代码如下：
vector<std::future<ResultType>> futureVector;
for (int i = 0; i < std::thread::hardware_concurrency(); i ++) {
auto future = std::async(
std::launch::async
浏览 0提问于2018-02-23得票数 2
回答已采纳
我对异步返回的std::launch::async策略和std::future对象的std::async函数的行为有一些疑问。
在下面的代码中，主线程等待async调用创建的线程上的foo()完成。
#include <thread>
#include <future>
#include <iostream>
void foo()
{
std::cout << "foo:begin" << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(
浏览 16提问于2012-03-16得票数 17
回答已采纳
1回答
超时TBB管道过滤器
、、、
这就是我想要达到的目标：
我正在使用TBB's管道进行处理。我有几个过滤器在管道中，我需要过滤器尽可能快，因为这是一个实时应用程序。其中一个过滤器有时会花费我负担不起的时间，所以我想在特定的过滤器上设置一个超时。
在寻找了一段时间之后，我找到了以下解决方案，该解决方案一般有效，但有其问题：
创建过滤器时，我将创建一个事件HANDLE。
m_Event = CreateEvent(NULL, FALSE, FALSE, NULL);
然后，过滤器使用异步调用一个函数，并等待事件。
...
auto funcBind = std::bind(&MyFunc, ...)
auto f
浏览 2提问于2016-11-24得票数 1
回答已采纳
1回答
我在实践std::asyn函数时引入了c++11，我编写了一个简单的示例
#include<future>
#include<iostream>
using namespace std;
void check()
{
cout<<"some"<<endl;
}
int main()
{
auto p=std::async(std::launch::async,check);
p.get();
}
是的，一开始很简单，我正在用GCC 5.3.0编译它
g++ -std=c++11 practise.
浏览 3提问于2016-04-24得票数 0
回答已采纳
我有一个Python方法，实现方式如下：
def start(self):
try:
self.is_running = True
self._main_loop()
except Exception as ex:
path='exceptions-servicecore.log'
track = traceback.format_exc()
exception_time = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
浏览 0提问于2020-04-12得票数 0
回答已采纳
我正在使用std::async和C++ 11中的std::future的组合。我使用它在代码中执行time_out，在尝试连接到服务器时可能需要时间。
以下是守则的内容：
#include <future>
#include <chrono>
std::size_t PotentiallyLongRunningActivity() {
using namespace std::chrono_literals;
std::this_thread::sleep_for(10000s);
return 10;
}
bool DoActivity()
浏览 4提问于2017-02-16得票数 2
回答已采纳
按照C++标准的未来。异步/3项目1，当一个函数f被传递给带有std::launch::async启动策略的std::async时，f将运行“就像在一个新的执行线程中”。
既然f可以做任何事情，包括无限循环和永久阻塞，那么一个实现如何提供运行在自己线程上的f行为，而不实际在自己的线程上运行它呢？也就是说，实现如何利用标准提供的“好像”的回旋空间？
浏览 6提问于2018-05-07得票数 19
回答已采纳
2回答
我对现代C++库非常陌生，并试图学习如何使用std：：异步对一个大指针数组执行一些操作。我编写的示例代码在异步任务启动的时候崩溃了。
样本代码：
#include <iostream>
#include <future>
#include <tuple>
#include <numeric>
#define maximum(a,b) (((a) > (b)) ? (a) : (b))
class Foo {
bool flag;
public:
Foo(bool b) : flag(b) {}
浏览 0提问于2018-05-09得票数 1
回答已采纳
当时我正在阅读“现代C++编程手册，第二版”关于并发性的第8章，偶然发现了一些令我困惑的东西。
作者使用std::thread和std::async实现了不同版本的并行映射和精简函数。实现非常接近；例如，parallel_map函数的核心是
// parallel_map using std::async
...
tasks.emplace_back(std::async(
std::launch::async,
[=, &f] {std::transform(begin, last, begin, std::forward<F>(f)); }));
...
//
浏览 2提问于2021-04-10得票数 27
回答已采纳
2回答
我有个强化学习项目。为此，我在C++中创建了一个矢量化环境，它是一个简单游戏的多个实例的处理程序。它具有高度可并行性。每个员工都可以在自己的一批实例上工作，它们之间没有信息交换。(在大多数情况下)
我目前的方法是以以下方式使用std：：异步：
[...]
auto foo = [&](int thread_id) {
size_t chunk_size = env_count / (worker_count) + 1;
size_t my_start = thread_id * chunk_size;
size_t my_end = std::min(my_s
浏览 0提问于2021-02-03得票数 0
回答已采纳
这里是一个很好的工作多线程代码。它使用std::async :-
class C{ public: int d=35; };
class B{
public: C* c;
public: void test(){
std::vector<std::future<void>> cac;
for(int n=0;n<5;n++){
cac.push_back(
std::async(std::launch::async,[&](){
浏览 5提问于2017-12-13得票数 3
回答已采纳
1回答
我对C#还比较陌生，我正在尝试复制已经用C++编写的异步调用。这有点困难，因为虽然我可以轻松地理解C#中的异步/等待关键字，但我仍然停留在该语言中延迟启动的概念上。这是原始代码：
bool runMethod(const cv::Mat& param1,
float& param2,
std::pair<float, float>& param3,
std::pair<int, int>& param4)
{
auto async_lazy{ std::a
浏览 4提问于2022-04-13得票数 0
回答已采纳
我有以下程序，取自
#include <iostream>
#include <boost/asio.hpp>
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
class Printer {
private:
boost::asio::io_service::strand strand_;
boost::asio::deadline_timer
浏览 1提问于2017-11-08得票数 2
3回答
我正在学习C++中的互斥，下面的代码有问题(取自N.Josuttis的“C++标准库”)。
我不明白为什么它会阻塞/抛出，除非我在主线程中添加this_thread::sleep_for (然后它不会阻塞，所有三个调用都会执行)。
编译器是从命令行使用的cl.exe。
#include <future>
#include <mutex>
#include <iostream>
#include <string>
#include <thread>
#include <chrono>
std::mutex printMut
浏览 2提问于2014-10-09得票数 9
回答已采纳
1回答
我正在尝试创建一个自定义游戏引擎的物理引擎。目前，一切正常，然而，当引擎必须处理大约4000个物理体时，我遇到了一些性能问题。我非常确定这不是渲染引擎的错误，因为它使用实例化渲染粒子效果(我目前正在测试)，如果它们都是静态的，可以处理大约200K粒子。
到目前为止，一旦所有的碰撞都被解决了，我通过施加一个重力并用这个速度平移物体来更新场景中的所有物理体。
该函数如下所示：
void mint::physics::PhysicsEngine::SymplecticEuler(mint::physics::PhysicsBody* body)
{
mint::graphics::Entity
浏览 5提问于2020-04-22得票数 2
1回答
我指的是野兽存储库中的这个示例程序：
我对代码做了一些修改，以检查同时处理多个请求的能力。
boost::asio::io_context ioc{1};
tcp::acceptor acceptor{ioc, {address, port}};
std::list<http_worker> workers;
for (int i = 0; i < 10; ++i)
{
workers.emplace_back(acceptor, doc_root);
workers.back().start();
}
ioc.run();
我对上面的理
浏览 4提问于2020-09-03得票数 0
回答已采纳
我不明白为什么使用带有std::async标志的std::lauch::async，而不是简单地调用传递给std::async的函数。有特价担保吗？
浏览 3提问于2013-11-21得票数 4
回答已采纳
2回答
过去我已经成功地使用了std：：异步，但是最近在检查一些新代码的保真度时，我遇到了一个令我困惑的奇怪之处。我相信应该有一个简单的解释和适当的解决方案，但我在任何地方都找不到关于它的讨论。
下面的一些最小代码说明了这一问题：
#include <functional>
#include <thread>
#include <future>
#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>
int main
浏览 1提问于2015-02-26得票数 1
回答已采纳
2回答
为了提供一些背景信息，我正在处理一个已保存的文件，在使用正则表达式将该文件拆分为其组件对象之后，我需要根据对象的类型来处理该对象的数据。
我现在的想法是使用并行性来获得一点性能提升，因为加载每个对象都是相互独立的。所以我打算定义一个LoadObject函数，为我将要处理的每种对象类型接受一个std::string，然后调用std::async，如下所示：
void LoadFromFile( const std::string& szFileName )
{
static const std::regex regexObject( "=== ([^=]+) ===\\
浏览 0提问于2013-06-20得票数 24
回答已采纳
4回答
从Herb Sutter的运行这段代码。这在gcc 4.6.3下的linux下工作得很好。我认为在mingw中不支持future.h，但是这个错误真的很难理解！
#include <iostream>
#include <vector>
#include <string>
#include <future>
#include <algorithm>
using namespace std;
string flip( string s ) {
reverse( begin(s), end(s) );
return s;
}
浏览 0提问于2012-04-18得票数 11
回答已采纳
2回答
通过std::async执行的函数的参数似乎共享未来的生存期：
#include <iostream>
#include <future>
#include <thread>
struct S
{
S() {
std::cout << "S() " << (uintptr_t)this << std::endl;
}
S(S&& s) {
std::cout << "S(&&) " <
浏览 0提问于2018-03-27得票数 6
回答已采纳
3回答
析构函数和异步任务
、、、
我有一个类，它使用构造函数中的std::async调用异步任务来加载其内容。(我希望异步加载对象)
代码如下所示：
void loadObject(Object* object)
{
// ... load object
}
Object::Object():
{
auto future = std::async(std::launch::async, loadObject, this);
}
在我的主线程中有几个这些对象被创建和删除的实例，它们可以在任何时候被删除，甚至在加载完成之前。
我想知道，当对象在另一个线程上被处理时，让它被销毁是否是危险的。如果对象被销毁，我如何停止线
浏览 3提问于2015-04-11得票数 2
回答已采纳
2回答
C++每秒运行异步函数
、、、
我正在使用Qt开发一个C++应用程序，我需要每秒钟异步运行一个函数。
应用程序的工作方式如下：
用户启动功能；
应用程序异步调用特定函数，同时允许用户执行其他操作；
当用户停止功能时，应用程序停止调用该函数。
对于其他函数，我使用Qt集成插槽和信号，如下所示：
connect(timer, SIGNAL(timeout()), this, SLOT(updateView()));
timer->start(200);
但是对于这个特殊的函数，我只想使用C++功能，比如线程、互斥、未来、承诺和异步。
我试过这样的方法：
if(cmd == start) {
st
浏览 0提问于2018-11-21得票数 1
回答已采纳
2回答
我一直在考虑如何在将来的编译器实现中使用std::async。然而，现在我有点被某种感觉像是设计缺陷的东西困住了。
std::async很大程度上依赖于实现，可能有两个launch::async变体，一个将任务启动到一个新线程，另一个使用线程池/任务调度器。
但是，根据用于实现std::async的这些变体中的哪一种，使用情况会有很大差异。
对于基于“线程池”的变体，您可以启动许多小任务，而不必担心开销，但是，如果其中一个任务在某个时候阻塞了怎么办？
另一方面，“启动新线程”变体不会遇到阻塞任务的问题，另一方面，启动和执行任务的开销将非常高。
线程池：+低开销，-never一直阻塞
启动新线程
浏览 2提问于2012-02-20得票数 12
回答已采纳
1回答
基于任务的异步并发
、、、
int
main()
{
std::mutex io;
std::vector<std::future<void>> futures;
std::cout << "Main id: " << std::this_thread::get_id() << std::endl;
for (int i = 0; i < 12; ++i) {
std::future<void> f = std::async(std::launch::async, [&]{
std::
浏览 3提问于2015-12-22得票数 0
1回答
在非递归情况下，线程池为我提供了一个很好的服务问题，它将从任务(赋予池的工作/函数)能够向池中添加更多任务中获益良多。我的线程池实现的问题是，第一级任务填充所有工作线程，创建第二级任务，然后在等待第二级任务完成时阻塞。由于所有工作线程都被阻塞，等待第二级任务完成，所以第二级任务永远不会执行，从而导致整个程序死锁。
对此有什么一般性的解决办法吗？可能是先发制人的线程池(如果可能的话)。我确实想过要显式地为任务排序，但问题是它不能自动处理依赖关系；它需要对API用户进行更多的工作。
提前感谢您的任何见解或建议。
编辑:线程池类def
class{
public:
thread_pool()
浏览 4提问于2013-10-16得票数 0
回答已采纳
我需要使用以下算法(在Python中)为我的项目收集一些统计数据：
stats = defaultdict(list)
for s in L:
current = []
for q in L:
stats[s, q] = copy(current)
current = f(current, s, q)
由于list L很大，f()和复制current需要一些时间，而项目的主要语言是C++，所以我决定选择C++并使用它的多线程功能来实现我的算法。
我把那部分移到：
stats[s, q] = copy(current)
浏览 0提问于2015-03-12得票数 1
回答已采纳
2回答
我试图做一个样例线程程序，其中产生的线程在一个while循环中。我不想生成多个线程。while循环应该继续运行，不管线程是否完成了执行。在while循环中调用上述线程的.get()函数。同样，这只能在线程正确执行时调用。
我的代码如下：
#include <iostream>
#include <future>
#include <thread>
#include <chrono>
int thread(int varJ)
{
std::cout<<"\t\t"<<varJ<<std:
浏览 0提问于2016-04-07得票数 1
回答已采纳
标准C++库中是否存在线程安全的引用计数器类(或者作为Visual中的扩展)，还是需要从头编写此类对象？
我希望有一个纯粹像shared_ptr那样执行引用计数的对象，但它可以在多个线程之间准确地执行引用计数，而不需要管理任何内容。shared_ptr和它的表亲结构很好，因为它们定义了您需要的所有复制构造函数和赋值运算符，这些.对我来说，这是C++最容易出错的部分；C++建设者对于C++来说，就像美国足球的开场白一样。
struct Fun {
// this member behaves in a way I appreciate, save for 2 short-comings
浏览 3提问于2021-08-26得票数 4
回答已采纳
我很难理解为什么下面的代码块：
{
std::async(std::launch::async, [] { std::this_thread::sleep_for(5s);
// this line will not execute until above task finishes?
}
我怀疑std::async将std::future作为临时的返回，在析构函数中，它将在任务线程上联接。有可能吗？
完整代码如下：
int main() {
using namespace std::literals;
{
auto fut1 = std::asyn
浏览 2提问于2017-04-22得票数 1
回答已采纳
我正在尝试从tokio::spawn生成的异步任务中读取stdin。遗嘱执行人作为
let mut executor = tokio::runtime::current_thread::Runtime::new().unwrap();
然后，使用executor.task(...)运行主要任务，这会产生tokio::spawn()的其他任务。
然后，fn main调用executor.run().unwrap();等待所有任务完成。
问题是当我做的时候
let mut stdin = tokio::io::stdin();
let mut read_buf: [u8; 1024] = [0;
浏览 0提问于2019-08-21得票数 1
回答已采纳
C#有一个很好的Process.OutputDataReceived()方法，每当进程向stdout写一行时就会出现这种方法，出于某种原因，我需要在C++中实现它，只用于。我尝试了使用异步的boost::process，类似于
boost::asio::async_read(ap, boost::asio::buffer(buf),
[&](const boost::system::error_code& ec, std::size_t size)
{
std::cout << buf.data() &
浏览 7提问于2022-11-18得票数 0
假设我们有以下代码：
#include <iostream>
#include <future>
int main() {
auto packagedTask = std::packaged_task<int()>([] {
std::cout << "hello!\n";
return 10;
});
auto packagedTaskFuture = packagedTask.get_future();
auto packagedTaskPtr = s
浏览 2提问于2019-06-27得票数 4
回答已采纳
2回答
我已经被告知过几次，我应该使用std::async来触发&忘记带有std::launch::async参数的任务类型(所以它在一个新的执行线程上是很神奇的，最好是)。
受到这些声明的鼓舞，我想看看std::async与以下几个方面的比较：
顺序执行
一个简单分离的std::thread
我的简单异步“实现”
我的幼稚异步实现如下所示：
template <typename F, typename... Args>
auto myAsync(F&& f, Args&&... args) -> std::future&l
浏览 0提问于2016-05-21得票数 20
回答已采纳
1回答
我正在为异步函数调用编写一个受node.js启发的C++库。
我的代码看起来有多高效和稳定？
如果需要，您可以看到一些WIP代码和演示代码这里。(net.hpp是用于POSIX套接字的，还远未完成。它没有编写任何IO函数)
/* ASYNC.HPP
* Defines some functions for calling other functions in the background
* This gives the ability to create callback based functions easily,
* similar to node.js (But I hate
浏览 0提问于2017-04-22得票数 4
回答已采纳
1回答
我正在尝试使用std::async。我已经写了这段代码
template<transport_type tt>
void stop_update_distances(const std::vector<stop>& stops, stop& from, const general_s& s, const osrm_machine& machine){
//...not important code...
}
void tt_map::update_distances(pqxx::connection& conn, const g
浏览 30提问于2019-08-19得票数 0
回答已采纳
2回答
我目前正在处理类中的一些异步任务。实际上，我需要将几个任务委托给异步执行，并确保所有这些任务都在类被销毁之前完成，我正在考虑等待所有的任务直到类析构函数中的任务完成。同时研究了C++语言std库中使用的现有方法。我对异步实现的不同方式很好奇。
例如，std::thread不会在析构函数中等待任何东西。下列代码在可执行终止时将失败：
void sleep() {
std::this_thread::sleep_for(std::chrono::seconds(5));
}
void execute_thead() {
auto thread = std::thread(&
浏览 0提问于2019-12-11得票数 5
如果我使用std:: launch ::async策略启动std::async，它不应该在新线程中启动每个异步任务吗？目前看来，新的异步任务将移动到刚刚完成其工作的线程中。我使用VC11作为我的编译器。从输出中可以看出，当使用std::async启动新的工作线程(例如，一个工作进程多次获得ID为34500的线程)时，它将在之前完成的线程中启动。我对std::async的理解是错误的，还是有一个底层的工作窃取队列或类似的东西？
Worker (ID=24072) starting.
Worker (ID=34500) starting.
Worker (ID=32292) starting.
W
浏览 2提问于2012-07-14得票数 4
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
