调用async生成新的线程，那么作为调用者的原线程，是否必须调用future.get()或者wait_for()函数来保证async生成线程的结束早于async返回future对象的析构？
作为一个专家，我认为这个问题是关于C++中的异步编程和线程管理的。在这个问题中，提到了使用async生成新的线程，并讨论了调用者线程是否需要调用future.get()或wait_for()函数来保证新线程的结束时间早于async返回future对象的析构。
首先，async是C++11引入的一种异步编程机制，它可以帮助开发者更容易地编写并发代码。async接受一个可调用对象和一系列参数，并在后台线程中异步地执行该可调用对象。它返回一个std::future对象，该对象可用于查询任务的结果或等待任务完成。
在这个问题中，提到了async生成的新线程，这意味着一个独立于调用者线程的线程正在执行任务。如果调用者线程不等待新线程完成，那么新线程可能在调用者线程结束之前被异常终止。这可能导致未定义的行为或资源泄漏。
因此，为了确保新线程的正常结束，调用者线程应该使用future.get()或wait_for()等待新线程完成。future.get()将阻塞调用者线程，直到新线程完成并返回结果。wait_for()允许调用者线程等待一定时间，然后继续执行。如果新线程在指定时间内完成，wait_for()将返回std::future_status::ready，否则将返回std::future_status::timeout。
总之，为了确保async生成的新线程能够正常结束，调用者线程应该使用future.get()或wait_for()等待新线程完成。这可以避免在调用者线程结束之前意外终止新线程，从而导致未定义的行为或资源泄漏。
相关·内容
2回答
假设我们有一个简单的异步调用，希望在超时时终止/终止/消除
// future::wait_for
#include <iostream> // std::cout
#include <future> // std::async, std::future
#include <chrono> // std::chrono::milliseconds
// a non-optimized way of checking for prime numbers:
bool is_prime (int x) {
for
浏览 1提问于2015-07-05得票数 3
回答已采纳
我正在尝试理解在主线程上下文中初始化和销毁具有静态存储持续时间和线程本地存储持续时间的命名空间范围和块范围对象的排序规则。考虑这两类：
struct Foo {
Foo() { std::cout << "Foo\n"; }
~Foo() { std::cout << "~Foo\n"; }
static Foo &instance();
};
struct Bar {
Bar() { std::cout << "Bar\n"; }
~Bar() { std::c
浏览 1提问于2019-01-01得票数 7
回答已采纳
1回答
调度太多从不重叠的小线程有什么问题吗？
例如，在python中，应该期待什么样的“意想不到”的行为：
from threading import Timer
def print_num_thread(wait_for=0.1, num_thread=0):
t = Timer(0.1, print_num_thread, [wait_for, num_thread+1])
# do something really quick (do << wait_for) like:
print(f'thread number {num_thread}')
浏览 0提问于2020-04-20得票数 0
在“c++并发操作”第387页中。
template<typename Lockable, typename Rep, typename Period>
std::cv_status wait_for(
Lockable& lock,
std::chrono::duration<Rep, Period> const& relative_time);
注意，虚假的唤醒意味着调用wait_for()的线程可能会唤醒，即使没有线程调用notify_one()或notify_all()。因此，建议在可能的情况下优先使用作为谓词的
浏览 6提问于2020-07-22得票数 0
回答已采纳
我正在处理一个现有应用程序的大型重构和移植，该应用程序使用windows线程做一些非常壮观(非常可怕)的事情。
现在，有内部逻辑对一组正在运行的线程调用GetExitCodeThread(m_threadHandle, &exitCode);，然后检查exitCode == STILL_ACTIVE是否仍在执行或已经返回，然后使用该逻辑对某些内部逻辑进行排序。
如何检查std::thread是否仍在执行，或是否已返回/引发异常？
我知道std::async，std::promises和std::future。然而，使用这些代码将涉及大量的重构，而且我不认为我对代码库有足够的了解，不足以
浏览 2提问于2015-03-26得票数 2
回答已采纳
我很难理解为什么下面的代码块：
{
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
回答已采纳
1回答
使用Python 3.6.8
async def sleeper():
time.sleep(2)
async def asyncio_sleeper():
await asyncio.sleep(2)
await asyncio.wait_for(sleeper(), 1)
await asyncio.wait_for(asyncio_sleeper(), 1)
使用time.sleep不超时，asyncio.sleep执行超时。
我的直觉是，在协同线上调用wait_for将根据协同线所用的时间来确定超时时间，而不是基于协同线内的单个异步调用。究竟是什么在幕后导致了这种
浏览 2提问于2020-05-18得票数 3
回答已采纳
1回答
我有一个简单的队列，它使用threading.Condition来处理在空队列中等待的消费者。
我希望这个队列也被async代码使用。
这就是我添加get_async方法的原因。
问题现在出现在下面的consumer中。它使用asyncio.wait_for，因为我想看看我的队列是否可以安全地取消。现在的观察结果是，在我引发取消之后，我的消费者总是遇到超时。
我猜这是由阻止self.condition正确发布的CancellationError造成的。
有人能给我一个提示吗?这里出了什么问题？
import threading
import time
import asyncio
SENTI
浏览 24提问于2021-11-08得票数 1
与基于计时的计时器相比，我更喜欢使用condition_variable::wait_for作为计时器，因为我可以通过指定谓词来覆盖等待条件。因此，我编写了一个测试程序，以检查一旦等待过程已经启动，延迟持续时间是否会发生变化。condition_variable::wait_for似乎忽略了更改，而是完全脱离了等待过程。为什么会这样呢？我能在等待过程中更改它吗？
enum STATE {START,STOP,NONE};
STATE state ;
condition_variable cv;
mutex mu;
chrono::milliseconds delay;
void cv_w
浏览 2提问于2017-01-25得票数 1
3回答
条件变量超时未理解
、、、
我玩游戏是为了让线程超时。我尝试使用，但它的行为与我所期望的不同。
在这里，我的简单代码：
#include <iostream>
#include <thread>
#include <chrono>
#include <mutex>
#include <condition_variable>
std::mutex myMutex;
void waitSec(int seconds)
{
std::cout <<"t1 start" <<std::endl;
std::un
浏览 5提问于2016-05-19得票数 2
回答已采纳
我有一个需要与不同输入集(从列表)并行执行的java方法。基本上，我的业务逻辑方法有一些外部调用逻辑，这些逻辑只消耗很少的时间来响应。为了减少获得最终响应的总时间，我尝试使用Future和@ Async实现并行调用此方法。下面是我的示例代码：
控制器类：
List<Future<ResponseObj>> futuresResObj = new ArrayList<Future<ResponseObj>>();
Future<ResponseObj> report = null;
for(int i=0 ; i<idList.s
浏览 4提问于2017-05-02得票数 0
1回答
我使用下面提到的端点从api访问数据：
1.getProductList
2.getImageurlofProduct/productid
我应该创建一个哈希图的数组列表，其中包含每个线程的productid、productprice和productimageurl。主线程将product.From - A派生到第一个端点，并在解析结果时从线程A派生线程。
但是，这些线程响应threadA的顺序与它们启动时的顺序不同。所以我最终将product 2的imageurl与id为1的product相加。
我该怎么处理这个问题。一个算法对我来说应该做得很好。如果你还想让我澄清什么，请告诉我。
浏览 0提问于2012-07-30得票数 0
回答已采纳
1回答
我所创建的是一个CacheBuilder服务，它将在一个条目列表中传递，并将构建一个结果缓存。结果是通过调用另一个服务(AsyncService)产生的，它将花费可变的时间。
同时，其他使用者也可以检查结果缓存，以确定这些项是否存在。
所需经费如下：
对调用方来说，产生缓存的开始调用是非阻塞的.
当CacheBuilder收到一个结果时，它会对它执行一些处理(processResult(String str)。
结果存储在id ->结果查找中。(HashMap<String, String> resultsCache)
resultsCache可以被外部用户访问，即使它还没有
浏览 0提问于2016-03-02得票数 2
2回答
在我接下来的一个教程中，作者编写了一个程序，说明std::future的析构函数并不总是执行任务。在下面的程序中，使用std::async()创建的10个线程被移动到向量中，然后等待它们的析构函数运行。
#include <iostream>
#include <future>
#include <thread>
#include <chrono>
int main()
{
std::cout << "Main thread id: " << std::this_thread::get_id()
浏览 2提问于2014-12-04得票数 4
回答已采纳
这是来自的简单代码
如果我用启动线程注释行，为什么wait_for()会立即返回呢？
如下所示：
// condition_variable::wait_for example
#include <iostream> // std::cout
#include <thread> // std::thread
#include <chrono> // std::chrono::seconds
#include <mutex> // std::mutex,
浏览 0提问于2016-12-30得票数 2
1回答
我希望能够等待线程从对另一个类进行的计算中返回一个值。让我发布一些代码：
public class ClassA implements Runnable{
public boolean threadRunning ;
public String value ;
public ClassA() {
...
}
public String getValueFromServer() {
//call to a method in the server that does some calculation
ClassB.sendPetitionToServer
浏览 0提问于2014-02-11得票数 1
回答已采纳
我正在尝试使用ansible playbook同时启动几个作业。我必须发送到http才能启动作业；一旦作业排队，作业可能需要1-3分钟才能完成。我需要在后台并行启动几个作业，然后轮询日志中的成功消息或失败消息，而且还需要超时。我可以通过ssh访问SERVERNAME，所以正则表达式搜索部分可以正常工作；但是，当它在日志中发现“启动失败”时，我没有想出一种方法来使它失败。我尝试过state=absent，但它似乎也适用于其他wait_for组件。
在Ansible中这一切都是可行的吗？我想出了下面的yaml。
---
- hosts: localhost
connection: local
浏览 0提问于2017-10-06得票数 0
当我尝试回答另一个时，我意识到这个简单的C++11片段隐式地阻塞了调用线程：
std::async(std::launch::async, run_async_task)
对我来说，这似乎是一种规范的C++11方法，可以异步启动任务，而不关心结果。相反，为了实现这一点，人们必须显式地创建和分离线程(请参阅上述问题的 )。
所以我的问题是:在安全性/正确性方面，std::future的析构函数必须阻塞吗？如果它只在get上阻塞，这还不够吗?否则，如果我对返回值或异常不感兴趣，它只是触发并忘记？
浏览 1提问于2014-05-04得票数 52
回答已采纳
我想使用CloseableHttpAsyncClient在异步模式下发送http请求。但请求没有发出。当启用注释时，HttpResponse响应= future.get()。它起作用了。但是我想知道为什么我需要future.get()，即使我不关心响应。密码在这里
public class CloseableHttpAsyncClientTest {
@Test
public void whenUseHttpAsyncClient_thenCorrect() throws Exception {
CloseableHttpAsyncClient client
浏览 1提问于2019-12-26得票数 1
回答已采纳
1回答
在Scala (如List )中，我们有一个map方法将List[A]转换为List[B]，如下所示：
trait List[A] {
def map[B](f: (A) => B): List[B]
}
我有类似的东西，除了map方法只接受从A到A的函数，如下所示：
trait State[A] {
def map(f: (A) => A): State[A]
}
有像这样的退化map方法的monad的名称吗？它已经不是真正的单身汉了，是吗？
浏览 6提问于2015-10-28得票数 1
回答已采纳
考虑一下我的lamba foo，它只做一些事情，不需要返回任何东西。当我这样做的时候：
std::future<T> handle = std::async(std::launch::async, foo, arg1, arg2);
一切运行正常，lamba将在一个新线程中生成。但是，当我没有存储std::async返回的std::future时，foo将在主线程中运行并阻塞它。
std::async(std::launch::async, foo, arg1, arg2);
这里我漏掉了什么？
浏览 1提问于2012-02-29得票数 17
回答已采纳
为什么这不起作用
try:
async with asyncio.wait_for(aiohttp.get(url), 2) as resp:
print(resp.text())
except asyncio.TimeoutError as e:
pass
给出
async with asyncio.wait_for(aiohttp.get(url), 2) as resp:
AttributeError: __aexit__
据我理解，asyncio.wait_for()将传递aiohttp.get()的未来，后者有一个__aenter__和__aexit_
浏览 12提问于2016-01-09得票数 3
回答已采纳
1回答
我正在使用std::futures来并行处理我的算法。我将信息拆分到互斥的池中，然后在每个池各自的线程中执行相同的操作。代码如下所示：
class Processor
{
public:
Processor(const std::string &strVal) : m_strVal(strVal)
{
}
std::string GetVal() const {return m_strVal;}
std::vector<std::string> Do()
{
// do some processing -
浏览 2提问于2015-08-11得票数 13
1回答
请注意，这不同于调用valid()。valid()指示未来是否具有有效的共享状态，但是我想知道的是是否已经设置了未来的值(即通过std::promise::set_value)。
有一个wait_for方法，但是我根本不想让调用线程阻塞，我只想检查是否存在一个值。从理论上讲，我可以以零持续时间调用wait_for，但我不知道这是否实际上是执行此操作的首选方法，我也不确定以零持续时间调用wait_for时的预期行为是什么。
浏览 5提问于2015-02-02得票数 5
我有点困惑，在c++中，从异步函数返回大数据的正确方法是什么。
以这段代码为例。它在函数中创建一个大向量并返回分配的向量。
#include <unistd.h>
#include <iostream>
#include <chrono>
#include <future>
#include <vector>
using timepoint = std::chrono::time_point<std::chrono::system_clock>;
timepoint start_return;
std::vect
浏览 1提问于2015-07-24得票数 3
回答已采纳
3回答
我想使用volley库进行同步请求，我使用了以下代码：
RequestFuture<Long> future = RequestFuture.newFuture();
AuthenticatedJsonRequest request = new AuthenticatedJsonRequest(Method.GET,ServiceUrl,null,future,future);
requestQueue.add(request);
try {
Long response = future.get();
但
浏览 2提问于2014-01-20得票数 6
考虑以下代码：
template <typename func_t, typename ... Args>
auto waiter (func_t func, const Args &... args) -> decltype(func(args...)) {
const static std::chrono::milliseconds max_time(10);
auto task = std::packaged_task<decltype(func(args...))()>(std::bind(func, args...));
auto h
浏览 3提问于2016-01-08得票数 2
我正在寻找一个脚本来检查执行命令(ctx.message.author)的用户是否使用了一个复选标记来响应消息，应该如下所示：
@client.command()
async def test(ctx):
message = await ctx.send("Test")
for emoji in ('✅'):
await message.add_reaction(emoji)
# Here it should detect if the ctx.message.author has reacted
浏览 2提问于2020-06-01得票数 2
回答已采纳
3回答
我更喜欢将异常处理逻辑放在调用堆栈中更靠前的位置，靠近main方法。我喜欢这种方法..。但是，我创建了一个线程，其中run()中的一些方法调用可能会抛出异常。我真的很想看看是否有一种方法可以将这些异常抛回父线程？我能想到的最好办法就是在实现Runnable的对象中设置一个变量。这个变量是一个包含错误消息的字符串，然后它使用一个类加载器在父线程中正确地重新创建相同的异常。
我想知道的是，有没有一种不那么麻烦的方法来得到我想要的东西？(能够确保在子线程中抛出的任何异常都使用相同的异常处理逻辑进行处理，就像它在主线程/代码重用中运行一样)。
浏览 0提问于2010-04-14得票数 11
回答已采纳
我正在使用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
回答已采纳
这段代码应该打印3次"hi“，但并不总是打印。
我制作了一个gif，它显示正在执行的代码：
from asyncio import get_event_loop, wait_for, new_event_loop
from threading import Thread
class A:
def __init__(self):
self.fut = None
def start(self):
"""
Expects a future to be created and puts &#
浏览 2提问于2020-12-31得票数 0
回答已采纳
1回答
private static final ExecutorService ES = Executors.newWorkStealingPool();
public Future<List<String>> isThisSafe() {
List<String> a = new ArrayList<>();
a.add("a");
List<String> b = new ArrayList<>();
b.add("b");
return
浏览 9提问于2020-06-12得票数 3
回答已采纳
我有一个类似于这种结构的程序:一个线程接收任务并将它们写入输入队列，多个线程处理它们并写入输出队列，一个线程用输出队列的结果进行响应。当队列为空时，线程会休眠几毫微秒。队列中有互斥，推送执行锁()，弹出执行try_lock()，如果队列中没有任何内容，则返回。
这是处理线程，例如：
//working - atomic bool
while (working) {
if (!inputQue_->pop(msg)) {
std::this_thread::sleep_for(std::chrono::milliseconds(200));
cont
浏览 3提问于2019-11-22得票数 2
我正在试验STL算法，更具体的是使用for_each函数。我尝试了一个简单的用例来连接字符串向量。请注意，这可能不是一个好的和/或有效的代码。如果您真的想连接字符串向量，请看boost::algorithm::join函数。
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include "concatenator.h"
using namespace std;
int main(int argc, char **arg
浏览 7提问于2010-11-17得票数 1
对于一个机器人，我的discord.py命令应该在一个特定变量有一个特定值(其中包含一个wait_for()协同线)的条件下激活一个with循环：
cond = True
@bot.command()
async def test(ctx):
global cond
def check(m):
m.author == ctx.message.author and m.channel == ctx.message.channel
while cond is True:
try:
msg = await bot
浏览 1提问于2022-08-24得票数 1
回答已采纳
我对异步返回的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
回答已采纳
我使用std::future和boost::asio::async_connect，以便在超时时取消操作，如下所示：
但是，std::future::wait_for()立即返回std::future_status::deferred，即操作尚未启动。conn_result.get()稍后会阻塞，直到由于远程主机没有侦听而引发连接错误。我不想依赖它，因为它可能会持续很长时间，直到引发套接字错误。
如何正确地等待boost::asio创建的期货？
编辑: SSCCE
#include <iostream>
#include <future>
#include <th
浏览 4提问于2015-07-21得票数 2
回答已采纳
1回答
我创建了一个指向如下对象的唯一指针：
std::unique_ptr<MyClass> myObj(new MyClass(arg1, arg2));
有一个方法，我需要在一个并行线程中执行。我不想等它结束。它将运行一个for循环，等待一些东西，并在自己的时间内完成。
我试过这样称呼它：
std::async(std::launch::async, &MyClass::MyMethod, myObj.get(), someArg, anotherArg);
也是这样的：
std::async(std::launch::async, [&] {myObj->My
浏览 2提问于2014-04-18得票数 0
回答已采纳
1回答
我使用的函数(不是我的函数，来自我不控制的库)的签名与以下类似：
template<typename T, typename F>
void do_async(T const&, F); // the second parameter is a callable
它通常是这样使用的
do_async(obj, [this](){ ... });
我编写了一个类似于此的函数，它总是使用相同的回调lambda：
template<typename T>
void do_async_wrapper(T obj) {
do_async(obj, [this]()
浏览 4提问于2017-01-09得票数 1
回答已采纳
显示互斥锁在调用cond.notify_one()期间不必保持。这是否意味着boost::condition_variable是线程安全的？即，如果“准备数据”线程释放互斥锁并尝试调用cond.notify_one()，而另一个线程现在获取已释放的互斥锁并同时尝试调用cond.wait(...)，会发生什么情况
浏览 0提问于2013-04-03得票数 1
回答已采纳
3回答
参考以下代码。
for (Future<Long> future : list) {
try {
sum += future.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
现在，当我调
浏览 0提问于2012-10-14得票数 3
2回答
停止服务器请求
、、、
我有一个网络应用程序(java，tomcat)，允许用户通过水晶报表生成报告。问题是，如果用户请求一个需要几个小时才能完成的大型报告，我的整个应用程序就会陷入停顿。有没有办法停止这样的请求，比如5分钟后它还没有完成？除了优化速度和限制报告大小之外，还有其他解决方法吗？
浏览 1提问于2012-01-20得票数 1
回答已采纳
2回答
我有一个用于异步执行的应用程序。
我在get方法上设置了参数，当线程没有得到响应时，线程应该在10秒后被杀死：
Future<RecordMetadata> meta = producer.send(record, new ProducerCallBack());
RecordMetadata data = meta.get(10, TimeUnit.SECONDS);
但这条线在60秒后就死了：
java.util.concurrent.ExecutionException: org.apache.kafka.common.errors.TimeoutExcep
浏览 7提问于2017-11-17得票数 0
回答已采纳
3回答
我使用异步来同时运行一个方法，但是当我检查我的CPU时，它显示只有2/8在使用。我的CPU利用率一直在13%-16%之间。函数异步应该通过每次调用创建一个新线程，因此应该能够使用更多的处理器，或者我是否理解错误？
这是我的密码：
for (map<string, Cell>::iterator a = cells.begin(); a != cells.end(); ++a)
{
for (map<string, Cell>::iterator b = cells.begin(); b != cells.end(); ++b)
{
if
浏览 2提问于2014-06-05得票数 0
回答已采纳
异步阻塞我的UI线程，如下所示，这不是我所期望的。那么，std：：异步，std：：诺言和std::packaged_task的含义是什么？
#include <iostream>
#include <thread>
#include <future>
#include "widget.h"
#include "ui_widget.h"
void func_cb()
{
for ( int i = 0; i < 1000; ++i ) {
std::cout << "do so
浏览 0提问于2019-06-10得票数 1
回答已采纳
1回答
我正在为我的程序中经常出现的构造寻找一个pythonic异步的“模式”。
工作任务执行一些操作，通常由几个步骤组成。这些操作的详细信息由从控制函数发送到辅助任务的命令控制。在各个步骤之间有睡眠，并且只有在这些睡眠期间，工作人员才能接受新的命令。一个新的命令将立即从睡眠中唤醒工作任务。
这些命令表示所需的目标状态。我在用队列来沟通。但是，只能有一个目标，这就是为什么命令没有构建真正的队列，但是最后一个命令替换了之前的所有队列。队列最多只有一个项。
目前，我正在使用其他异步库。我想换成标准的asyncio。举个例子：
# warning: not asyncio code; not real co
浏览 0提问于2018-08-04得票数 1
回答已采纳
我们正在做一些操作，然后我们尝试将数据插入到elastic DB中。我的问题是，很少有记录被插入到索引中，也很少有记录丢失。我可以在我的日志文件中看到数据，而且我也没有弹性错误。因为没有错误，所以我也不能调试。即使没有插入，客户也会得到响应。下面是我的代码。
file.js
async function InsertModelES() {
var objn= {
PID: ID,
TID: MID,
UserID:userID,
HID: HrID,
};
await elasticClient.ind
浏览 0提问于2021-02-15得票数 3
当类负责管理线程时，在确保线程及时完成之后，在析构函数中加入该线程是一种常见的模式()。然而，正如链接线程中所概述的那样，这并不总是微不足道的，因为链接线程导致的程序如果做得不正确，就永远不会终止。以下是再现这种情况的一个例子：
#include <iostream>
#include <thread>
#include <chrono>
using namespace std::chrono_literals;
class Foo {
public:
Foo() {
mythread = std::thread([&]()
浏览 2提问于2020-11-27得票数 0
在实践中的Java并发性(Brian Goetz)中说明了这一点(重点是我的)：
当Future.get抛出InterruptedExcetion或TimeoutException，并且您知道程序不再需要结果时，用Future.cancel取消任务
Future.get的Javadoc声明(突出显示是我的)：
抛出InterruptedException --如果当前线程在等待时被中断
因此，据我所知:如果我得到一个InterruptedException，那么我的任务还没有启动(因为正在执行的线程在等待时被中断)。那我为什么要取消我的任务？
浏览 2提问于2015-08-13得票数 2
回答已采纳
1回答
在C++11中，线程对象可以被移动。众所周知，我们创建的每个线程都拥有一个函子。显然，移动一个未执行其函子的线程是合理的。但是，移动一个正在调用或已经执行了一段时间的函数的线程又如何呢？
为了更进一步，如果我实现了一个线程包装类，如：
//noncopyable is a tag class of which copy constructor and copy assignment are deleted.
class Thread:noncopyable{
private:
using ThreadFunc = std::function<void()>;
boo
浏览 0提问于2020-10-21得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
腾讯会议活动推荐
腾讯云开发者
