std::thread出现了奇怪的“可接合()”行为
std::thread是C++11标准库中的一个类，用于创建和管理线程。它提供了一种方便的方式来并发执行代码，并充分利用多核处理器的能力。
关于std::thread出现奇怪的“可接合()”行为，这可能是指在使用std::thread时遇到的一些问题或异常行为。具体的问题可能有多种原因，下面我将尝试给出一些可能的解释和解决方案。
- 可能的原因：
- 线程对象没有正确地加入或分离。
- 线程对象的生命周期管理不当。
- 线程对象的资源释放不正确。
- 解决方案：
- 确保在使用std::thread创建线程后，使用join()或detach()方法来管理线程对象的生命周期。join()方法会等待线程执行完毕，而detach()方法会将线程对象分离，使其在后台继续执行。
- 确保在使用join()方法时，线程对象确实是可接合的，即它是一个有效的线程对象。
- 确保在使用detach()方法时，线程对象确实是可分离的，即它不再与主线程相关联。
- 应用场景：
- std::thread可以用于任何需要并发执行的场景，例如多线程计算、并行处理、异步操作等。
- 它可以用于提高程序的性能和响应能力，特别是在处理大量数据或需要长时间运行的任务时。
- 推荐的腾讯云相关产品：
- 腾讯云提供了一系列云计算产品和服务，可以帮助开发者更好地利用云计算资源。以下是一些相关产品：
- 云服务器（CVM）：提供弹性的虚拟服务器实例，可用于部署和运行多线程应用程序。
- 云容器实例（CCI）：提供一种轻量级的容器化解决方案，可用于快速部署和管理容器化应用。
- 云函数（SCF）：提供无服务器计算服务，可用于按需执行代码片段，适用于一些短时且频繁的任务。
- 弹性MapReduce（EMR）：提供大数据处理和分析的解决方案，可用于并行处理和分布式计算。
- 腾讯云提供了一系列云计算产品和服务，可以帮助开发者更好地利用云计算资源。以下是一些相关产品：
以上是关于std::thread出现奇怪的“可接合()”行为的一些解释和解决方案，以及腾讯云相关产品的推荐。希望对您有所帮助。
相关·内容
如下所示：
void test()
{
std::chrono::seconds dura( 20 );
std::this_thread::sleep_for( dura );
}
int main()
{
std::thread th1(test);
std::chrono::seconds dura( 5 );
std::this_thread::sleep_for( dura );
return 0;
}
main将在5秒后退出，对仍在执行的th1会发生什么情况？
即使您在main中定义的th1线程对象超出作用域并被销毁，它是否会继续执行直到完成？
th1是
浏览 0提问于2014-12-10得票数 35
回答已采纳
我正在使用SynchronisedQueue在线程之间进行通信。我发现在附加线程等待条件变量时销毁线程对象会导致程序崩溃。这可以通过在线程销毁之前调用detach()来纠正。但是我想知道当一个等待条件变量的线程被终止时到底会发生什么。有没有其他方法可以使用条件变量来避免这种情况？
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
template <typename Type> class SynchronisedQue
浏览 0提问于2012-12-21得票数 10
回答已采纳
1回答
我有一个多线程代码。这是我的代码的一个简单示例：
void SomeClass::ExampleForThread2()
{
m_thread_ptr = std::make_unique<std::thread>([=]() {
while (! m_stop)
{
try
{
// ... do work
}
catch (...)
{
// ...
}
}
#pragma messsage(__DBG__"TODO: not known
浏览 6提问于2020-11-13得票数 0
我使用的是不分配任何局部变量的pthread。出于某些原因，我不会在这里讨论，我需要一个pthread_cancel()选项，并且我正在编写的线程应该能够支持它(没有要清理的资源，可以在任何时候停止执行)。目前，我遇到了一个问题，因为pthread_cancel在pthread实际运行完成之前返回，导致共享资源出现问题，我只想在线程取消后再接触它。
有没有办法让我知道我的pthread什么时候已经完结了？有没有一个我没有找到的函数，或者一个我不熟悉的参数？
将会
pthread_cancel(thread_handle);
pthread_join(thread_handle, NULL);
浏览 0提问于2011-08-07得票数 4
回答已采纳
我有一个使用许多分离boost::thread实例的代码库，如下所示
boost::thread th( boost::bind(&myFunc,var1, var2 ));
我是否可以简单地执行搜索、替换并开始使用std::thread
我是否也需要用std::bind替换boost::bind，或者这是不必要的？
(我发现我可以搜索一下，用std::shared_ptr替换boost::shared_ptr，用std::unique_ptr替换boost::scoped_ptr，到目前为止没有任何问题。
我的平台是Windows 7上的Visual Studio 11。
浏览 0提问于2012-11-16得票数 1
回答已采纳
考虑下面的示例代码，它创建一个线程并使用thread::interrupt调用从主线程中断它：
#include <iostream>
#include <boost/thread.hpp>
#include <boost/chrono.hpp>
#include <boost/ref.hpp>
int main()
{
boost::thread t([]{
int counter = 0;
while (1){
std::cout << "interrup
浏览 0提问于2015-06-18得票数 2
3回答
通常的做法是使用guards、RAII和try/catch块来确保线程在所有情况下最终都会被加入。但是，对于要分离的线程又该怎么办呢？
void aFunction() {
std::thread t {someOtherFunction}; // someOtherFunction may throw!!!
t.detach;
}
我是否应该使用某种异常处理机制来确保即使在出现异常的情况下也能正确分离t，或者这真的无关紧要吗？
浏览 3提问于2016-02-02得票数 3
class MyClass{
public :
void runBscGwThread(int);
private :
std::unique_ptr<std::thread> MyClass_;
}
MyClass::Myclass(int bcfId, A::AParam sctpParams):
bcfId_(bcfId),
{
Myclass_.reset(new std::thread([this](){ this->runBscGwThread(bcfId_);}));
}
浏览 34提问于2017-07-21得票数 0
令我惊讶的是，已经完成执行但尚未联接的C++11 std：：对象仍然是活动的执行线程。这在下面的代码示例中进行了说明(构建在带有g++ 4.7.3的xubuntu13.03上)。有没有人知道C++11标准是否提供了一种方法来检测std::thread对象是否仍在主动运行代码？
#include <thread>
#include <chrono>
#include <iostream>
#include <pthread.h>
#include <functional>
int main() {
auto lambdaThre
浏览 2提问于2013-08-06得票数 7
回答已采纳
下面是一个简单的线程跟踪程序。线程只打印前十个整数，然后显示“线程完成”消息。
#include <iostream>
#include <vector>
#include <numeric>
#include <thread>
void f();
int main(int argc, const char * argv[]) {
std::thread t(f);
std::cout << "Thread start" << std::endl;
t.detach();
浏览 0提问于2015-06-22得票数 5
回答已采纳
我无意中发现了一种我认为是很容易在不知不觉中射中自己脚的方法。
首先是一个小小的介绍
数据成员的初始化顺序是数据成员的声明顺序。所以这是违法的：
struct A
{
std::size_t i_;
std::size_t length_;
A(std::size_t length)
: i_{length_} // UB here. `length_` is uninitialized
length_{length}
{}
};
因为数据成员length_在i_的初始化器中使用时是未初始化的。幸运的是，gcc和clang都给出了
浏览 1提问于2018-11-15得票数 4
回答已采纳
所以我这里有个奇怪的情况。我有以下代码：
int main()
{
std::shared_ptr<MyClassA> classA = std::shared_ptr<MyClassA>(new MyClassA);
std::shared_ptr<MyClassB> classB = std::shared_ptr<MyClassB>(new MyClassB(classA));
boost::thread_group threadGroup;
// This thread is essentially a
浏览 1提问于2015-10-02得票数 1
回答已采纳
我的代码被分成两部分，一部分在主线程中运行，另一部分在单独的线程中运行。主线程在最后等待thread.join()。 现在，如果主线程抛出异常，即使我试图捕获异常，我的程序也会立即终止。我追踪到了std::~thread，如果线程仍在运行(可接合)，这是不愉快的。 在这种情况下，我希望异常等到线程自然退出，然后继续传播。我该怎么做？我是否需要用某种joining_thread包装std::thread，它的驱动程序会加入？ #include <iostream>
#include <thread>
class foo
{
public:
foo(const
浏览 14提问于2020-01-05得票数 1
回答已采纳
1回答
我有一个关于我想在QNX上运行的代码的问题：
class ConcreteThread : public Thread
{
public:
ConcreteThread(int test)
{
testNumber = test;
}
void *start_routine()
{
for(int i = 0; i < 10; i++)
{
sleep(1);
cout << testNumber << endl;
浏览 0提问于2009-01-11得票数 3
回答已采纳
我正在将从ZeroMQ指南手册移植到更高级别的czmq接口。
由于某些原因，使用zsock创建并连接到端点的std::thread总是崩溃。以下是使用C++编写的负载均衡代理的代码：
// Load-balancing broker
// Demonstrates use of the CZMQ API
#include <czmq.h>
#include <cstdio>
#include <thread>
#include <iostream>
#include <vector>
#define NBR_CLIENTS 1
浏览 48提问于2020-05-13得票数 0
2回答
这些天，我正在阅读pdf 。它解释了用户必须在C++0x中std::thread类的对象上显式调用detach()，然后该对象才会超出作用域。如果你不调用它，std::terminate()就会被调用，应用程序就会死亡。
在C++中，我通常使用boost::thread进行线程处理。如果我错了，请纠正我，但当boost::thread对象超出作用域时，它会自动分离。
在我看来，boost方法遵循RAII原则，而std并非如此。
你知道这有什么特别的原因吗？
浏览 0提问于2010-12-22得票数 13
回答已采纳
3回答
我模拟了C++中的线程之间的一个竞赛条件，在运行它时，它在“随机”循环迭代中出现错误。
我能用它作为随机数发生器吗？为什么？
#include<cstdio>
#include<thread>
static int counter = 0;
void increase() {
register int i = counter;
i++;
counter = i;
}
void decrease() {
register int i = counter;
i--;
coun
浏览 0提问于2018-08-31得票数 0
回答已采纳
我需要这样的东西：
void launch_task()
{
std::thread([](){ run_async_task(); });
}
除了线程的析构函数会终止我的任务。我不需要对任务进行任何控制，也不需要返回值。它只需要运行它自己的进程，然后线程应该终止，C++线程对象应该被释放。我需要哪些C++ 11工具？
我看过std::async，但找不到适用于我的情况的用法示例。这似乎是一个相当复杂的系统，我需要以某种方式存储和操作std::future，否则它就会变得同步(如果我的理解是正确的，我在std::async上没有找到一篇很好的清楚的文章)。
浏览 4提问于2014-05-04得票数 40
回答已采纳
3回答
(如何)我可以像这样启动多个线程：
for (i = 0; i < 10; i++) {
std::thread (myfunction, i, param2, param3);
}
不加入的话？
浏览 0提问于2014-01-31得票数 10
回答已采纳
我正在尝试从我正在构建的服务器接收消息。
在某个时刻，当客户端连接到服务器时，我启动了一个不断运行的接收线程。我从下面的代码开始：
std::thread receiveThread(&NetworkingLib::Base::Receive, this);
它是从接收()方法所在的同一个类中的方法中调用的。
现在，在那之后，它确实进入了接收()方法，但是当调用recv()方法( Winsock方法)时，它崩溃了。
if (ConnectSocket != INVALID_SOCKET)
{
iResult = recv(ConnectSocket, recvbuf, recv
浏览 5提问于2014-07-11得票数 4
1回答
这是一个非常简单的例子，请稍等片刻……
#include <boost/thread/thread.hpp>
struct foo {
boost::thread t;
void do_something() { std::cout << "foo\n"; }
void thread_fun(){
try {
boost::this_thread::sleep(boost::posix_time::seconds(2));
{
boo
浏览 2提问于2017-10-05得票数 2
我在一个开源软件中发现了一段奇怪的代码
for (i=0; i<store->scan_threads; i++) {
pthread_join(thread_ids[i], NULL);
pthread_detach(thread_ids[i]);
}
调用pthread_detach有什么意义吗？
浏览 10提问于2013-12-18得票数 0
我得到了以下使用pthread库实现的并发问题的场景：
我有个帖子随时都可能被取消。当该线程被取消时，它需要取消它的子线程，并确保它的子线程在终止之前已经被取消。
所以我最后在子线程上调用了两次pthread_join，一次是在线程例程中(因为当线程没有被取消时，我需要那个结果)，一次是在线程的取消清理处理程序中。
然而，pthread_join不允许两次加入同一个线程，那么会发生什么呢？
下面是伪代码：
void CleanupFunc(void* ChildThread)
{
pthread_cancel(*(pthread_t*)ChildThread);
pthread
浏览 0提问于2017-04-09得票数 0
1回答
我在stackoverflow上看到了一些从类中启动线程的想法。
我的函数-这个函数必须运行
//header.h
private:
void updateTime();
//cpp
void class::updateTime(){
while (true){
Sleep(1000);
}
}
来自我的类构造函数(这是QT类构造函数)
我试着这样做：
std::thread t1{&class::updateTime,this};
或者使用lambda样式
std::thread t1{ [this] { updateTime(); } };
但是我
浏览 2提问于2014-08-06得票数 0
我有一个多用户使用的多线程应用程序。对于某些用户，运行应用程序会导致
terminate called without an active exception
Aborted
使用GDB运行应用程序将产生以下输出：
Thread 1 ... received signal SIGABRT, Aborted.
__GI__raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:51
51 ../sysdeps/unix/sysv/linux/raise.c: No such file or directory.
(g
浏览 32提问于2021-05-15得票数 1
我的职能如下：
void threadProc(){
for (int i = 0; i < 5; ++i) {
std::cout << "\n thread #" << std::this_thread::get_id() << " says hi";
}
std::cout << "\n Finished executing thread #" << std::this_thread::get_id();
}
我使用它的方式如下：
浏览 2提问于2017-03-09得票数 15
回答已采纳
1回答
下面的程序对每个GROUPSIZE文件使用一个工作线程来处理nbFiles文件。并行运行的工作线程不会超过MAXNBRTHREADS工作线程。使用watchDog()线程(线程0)来引导PTHREAD_CANCEL_DEFERRED相同的工作进程。如果任何一个工作线程失败，它就会在全局互斥锁mtx的保护下对watchDog执行pthread_cond_signal(&errCv)操作，通过errIndc谓词传递它的线程ID。然后，watchDog取消所有正在运行的线程(全局oldest保留仍处于活动状态的最旧线程的ID，以帮助它完成此操作)，并退出程序。
// compile with
浏览 0提问于2017-10-19得票数 0
3回答
我正在学习C++中的多线程技术。我遵循了一个教程，该教程给出了使用移动语义从一个线程“移动”到另一个线程的方法：
std::thread thread_1( func_1 );
std::thread thread_2 = std::move( thread_1 );
thread_1 = std::thread(func_2);
std::thread thread_3 = std::move(thread_2);
thread_1 = std::move(thread_3);
最后一行thread_1 = std::move(thread_3);被认为不是正确的方法，因为(据我所
浏览 0提问于2017-11-21得票数 1
1回答
2013 std：：线程
、、、、
下面的程序在使用Visual 2013编译时会出现一些奇怪的编译/运行时行为：
#include "stdafx.h"
#include <thread>
#include <chrono>
#include <iostream>
int main()
{
{//works
std::thread([](){
std::cout << " thread running1\n";
});
}
{//compile but synst
浏览 3提问于2015-03-02得票数 2
回答已采纳
以下是C++参考网站上的示例代码
#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
std::mutex mtx;
std::condition_variable cv;
bool ready = false;
void print_id(int id) {
std::unique_lock<std::mutex> lck(mtx);
while (
浏览 4提问于2016-08-11得票数 0
回答已采纳
我得到一个关于线程的C++错误：
terminate called without an active exception
Aborted
代码如下：
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
template<typename TYPE>
class blocking_stream
{
public:
blocking_stream(size_t max_buffer_size_)
:
浏览 0提问于2011-09-12得票数 115
回答已采纳
1回答
我想把我的函数的两个部分分开，以使它更快。在每两个分离的部分中，都有我想在以后使用的数据(在//Do someting else.部分中)。
我想到了std::thread，但它似乎很慢，因为它需要太多的时间来设置。然后，我根据一个建议尝试了std::async，它比std::thread更好，但仍然比原始代码慢(没有线程，只是调用函数)。
示例代码：
Variables
INT a, INT b
Part1
a = 4 + 5
End of Part1
Part2
b = 2 + 6
End of Part2
Main
Loop (endless)
浏览 2提问于2017-07-23得票数 0
2回答
我写这段代码是为了测试boost asio和分离线程的一些行为。
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <iostream>
#include <string>
#include <thread>
class printer {
public:
printer(boost::asio::io_service &io)
浏览 3提问于2017-05-18得票数 0
2回答
在msvc上，如果你试图加入一个不可接合的线程，它将调用abort。因此，在调用join之前，您必须检查线程是否可接合，但这本身就是一个竞争条件。
void BaseThread::join()
{
auto thread = m_pPrivates->m_pThread;
if (!thread)
return;
if (thread->get_id() != std::thread::id() && thread->joinable())
thread->join();
}
如果线程不可接合
浏览 1提问于2014-03-12得票数 4
是boost：：作用域线程自动分离或必须手动分离。
#include <boost/thread.hpp>
#include <boost/thread/scoped_thread.hpp>
#include <iostream>
void thread()
{
for (int i = 0; i != 10000; ++i)
{
std::cout << i << std::endl;
}
}
int main()
{
boost::scoped_thread<>
浏览 4提问于2015-04-27得票数 0
1回答
我不明白为什么当“封装”到类中时，p线程只使用一个线程，而当使用普通的调用p线程函数时则使用所有的线程。在执行过程中应该有问题。
请参阅下列代码：
#include <iostream>
#include <vector>
#include <pthread.h>
#include <sys/time.h>
namespace {
class Functor {
public:
Functor(const std::vector<int> &v) :
m_v(v), m_res() {
浏览 3提问于2016-11-18得票数 1
回答已采纳
2回答
我最近一直在尝试使用boost。当我尝试创建一个简单的多线程回显服务器时，它在接收到错误代码3时退出。我已经多次查看了文档，但仍然没有成功。我知道这可能是我忽略的非常简单的事情。我有不错的winsock使用经验，但我想学习boost库。
下面是失败的代码，我去掉了
typedef boost::shared_ptr<tcp::socket> socket_ptr;
boost::asio::io_service io;
boost::array<char, 512> buf;
void startserver ( std::string host, std::stri
浏览 2提问于2012-09-24得票数 2
回答已采纳
2回答
我对异常的奇怪行为感到困惑，这些异常在生成另一个线程后抛到主线程中：
void thread_body(){
while(true) cout << "in thread" << endl;
}
int main(int argc, char** argv)
{
try{
auto t = std::thread( thread_body );
throw std::runtime_error("error!");
t.join();
} catch (cons
浏览 2提问于2017-08-20得票数 0
回答已采纳
我看到了thread::create创建线程和thread::send向其发送脚本的位置。但是thread::join没有脚本参数。在手册中，thread::join就像是thread::send的替代品一样，但是如果它是可接合的，我不知道如何将脚本发送到线程。
我看到它阻塞了，这对一些应用程序很有用，但我还没有看到thread::join中的value语句，请给出一个例子说明thread::join如何在单独的线程中运行脚本。或者更好地解释它的价值，以一种手册没有向我解释清楚的方式。
浏览 0提问于2019-05-15得票数 0
我才刚开始学习c++。我遇到了一个我无法理解的奇怪的情况。它是关于声明和打印一个double变量。
我的第一段代码如下：
#include <iostream>
int main ()
{
double wage;
std::cout << wage << std::endl;
return 0;
}
在我用g++编译了这个文件并运行它之后，在我的终端中打印了一个0，这很好。然后我继续添加代码行，现在如下所示：
#include <iostream>
int main ()
{
double wage;
浏览 2提问于2017-05-31得票数 0
回答已采纳
1回答
我遇到了从Poco::HTTPServer启动线程的奇怪行为
下面是我得到的信息：
class Worker : public Poco::Runnable {
public:
Worker(std::string request): _request(request) {};
void run();
std::string GetResult();
private:
std::string _request;
};
void Worker::run() {
// do something with _request;
}
class Request
浏览 0提问于2016-02-10得票数 0
我正在阅读Anthony Williams的“在行动中的C++并发”和第5章，其中讨论了新的多线程感知内存模型和原子操作，他说：
为了将std::atomic<UDT>用于某些用户定义的UDT，这种类型必须有一个简单的副本赋值操作符。
据我理解，这意味着如果以下内容返回true，我们可以使用std::atomic<UDT>：
std::is_trivially_copyable<UDT>::value
根据这个逻辑，我们不应该能够使用std::string作为std::atomic的模板参数，并使它正确工作。
但是，以下代码编译并运行预期输出：
#i
浏览 2提问于2013-06-01得票数 57
回答已采纳
1回答
我正在尝试制作一个秒表类，它有一个独立的线程，可以倒计时。这里的问题是，当我使用取消功能或尝试在超时后再次设置秒表时，我的程序崩溃。目前，我确信这是由于一些线程问题，可能是因为误用。有没有人可以告诉我为什么它不能工作，并能帮助我让它工作？
Stopwatch.h
class Stopwatch
{
public:
void Run(uint64_t ticks);
void Set(uint64_t ms);
void Cancel();
private:
std::thread mythread;
浏览 0提问于2019-11-18得票数 0
#include < iostream >
#include < pthread.h >
using namespace std;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* Func(void *)
{
pthread_mutex_lock(&mutex);
cout << "First thread execution" << endl;
pthread_mutex_unlock(&mu
浏览 1提问于2015-08-10得票数 3
我必须存储参数(参数包)，并将参数传递给另一个函数。
因此，我不能使用lambda。一个很好的选择是std::bind。
但是对于这段代码
struct A{};
void test(A &&){}
int main()
{
A a;
test(move(a)); //work
bind(test,a)(); //compile fail; copy a to std::bind, pass a to test
}
根据标准，所有存储在std::bind中的变量都将作为lvalue传递给函数。( C++标准并没有这么说，我想这就是它的意思。
浏览 2提问于2016-07-06得票数 0
下面的程序将以失败告终，并显示一条关于abort()被调用的消息。
我正在启动一个线程，简单地打印到cout。如果我使用std::this_thread::sleep_for()，我会得到错误。如果我删除它，我会得到错误。如果我在线程上调用join()，一切都会正常工作。
线程不应该在1000ms延迟之前很久就终止吗？为什么这会导致错误？我不敢相信调用join()是线程的一个要求。
#include <thread>
#include <iostream>
class ThreadTest
{
public:
ThreadTest() : _t{ &T
浏览 6提问于2014-03-28得票数 2
回答已采纳
我有一些函数试图锁定std::mutex，如果互斥锁成功，函数创建以lambda函数为线程函数参数的std::thread，并使用std::move()传递锁。
static std::mutex mtx;
// some mutex defended stuff
void someFunc() {
// try lock mutex using unique_lock
std::unique_lock<std::mutex> lock(mtx, std::try_to_lock);
if(!lock.owns_lock()) {
retu
浏览 0提问于2014-08-21得票数 4
回答已采纳
我试图在Visual 2013上编译以下代码：
std::unique_ptr<std::thread> threadPtr;
threadPtr.reset(std::make_unique<std::thread>([&]
{
//...
}));
如果出现错误，它将失败：
error C2664: 'void std::unique_ptr<std::thread,std::default_delete<_Ty>>::
reset(std::thread *) throw()' : cannot con
浏览 0提问于2015-01-12得票数 2
回答已采纳
1回答
当我调用joinThread时，偶尔会在join调用中抛出带有“无效参数”的std::system_error。这个错误似乎只有在我和gcc一起编译时才会出现，而且它并不总是可以重复的，也就是说，它偶尔会发生，而不是可以预测的。有人知道是什么导致了这样的错误吗？
下面是我代码的简化版本。
class exampleClass
{
public:
exampleClass()
{
}
~exampleClass()
{
joinThread();
}
void doWork()
{
joinThread()
浏览 3提问于2016-08-29得票数 0
我是多线程的初学者，在cpp标准多线程库中有些东西我不理解：
void func(){
//do something
}
int main(){
std::vector<std::thread> threads;
for(int i=0;i<std::thread::hardware_concurrency();i++)
threads.push_back(func);
for(auto& thread:threads)
thread.join();
//do it again
for(auto& thread:threads)
thread.join
浏览 3提问于2020-09-12得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
