blocks|key|4430500|text|我将为线程提供一个条件变量和一个名为startRunning的布尔值(最初设置为false)。实际上，您可以在创建线程时立即启动线程，但是它要做的第一件事就是挂起自己(使用condition_variable)，然后仅当condition_variable从外部发出信号(并且startRunning标志设置为true)时才开始处理其实际任务。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|4430501|编辑:伪代码：|4430502|//+in+your+worker+thread
{
++++lock_guard+l(+theMutex+);

++++while+(+!+startRunning+)
++++{
++++++++cond_var.wait(+l+);
++++}
}

//+now+start+processing+task


//+in+your+main+thread+(after+creating+the+worker+thread)
{
++++lock_guard+l(+theMutex+);
++++startRunning+=+true;
++++cond_var.signal_one();
}|code-block|syntax|javascript|4430503|编辑#2:在上面的代码中，两个线程都必须可以访问变量theMutex、startRunning和cond_var。您是通过使它们成为全局的还是通过将它们封装在结构/类实例中来实现这一点，这取决于您。|4430504|entityMap^0|I|C|3U|C|0|0|0|Q|8|Z|C|1C|8|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|P|$]]

I would give the thread a condition variable and a boolean called startRunning (initially set to false). Effectively you would start the thread immediately upon creation, but the first thing it would do is suspend itself (using the condition_variable) and then only begin processing its actual task when the condition_variable is signaled from outside (and the startRunning flag set to true).

EDIT: PSEUDO CODE:

<pre><code>// in your worker thread
{
 lock_guard l( theMutex );

 while ( ! startRunning )
 {
 cond_var.wait( l );
 }
}

// now start processing task


// in your main thread (after creating the worker thread)
{
 lock_guard l( theMutex );
 startRunning = true;
 cond_var.signal_one();
}
</code></pre>

EDIT #2: In the above code, the variables theMutex, startRunning and cond_var must be accessible by both threads. Whether you achieve that by making them globals or by encapsulating them in a struct / class instance is up to you.

blocks|key|4430543|text|您可以使用singleton+pattern。或者我更愿意说反模式。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|4430544|在单例中，您将封装std::thread对象。在第一次访问单例时，你的线程将被创建并启动。|CODE|4430545|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Singleton_pattern^0|U|3|5|H|0|0|9|B|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@$9|T|A|U|1|V]]|E|$]]|$1|F|3|G|5|6|7|W|8|@$9|X|A|Y|B|H]]|D|@]|E|$]]|$1|I|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|J|$K|$5|L|M|N|E|$O|P]]]]

You could use <a href="http://en.wikipedia.org/wiki/Singleton_pattern" rel="nofollow">singleton pattern</a>. Or I would rather say antipattern. 

Inside a singleton you would have <code>std::thread</code> object encapsulated. Upon first access to singleton your thread will be created and started.

blocks|key|1779882|text|std::thread的默认构造函数在不启动或表示任何实际线程的情况下实例化std::thread。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1779883|std::thread+t;|code-block|syntax|javascript|1779884|赋值运算符移动线程对象的状态，并将赋值自线程对象设置为其默认初始化状态：|1779885|t+=+std::thread(/*+new+thread+code+goes+here+*/);|1779886|这首先构造表示新线程的临时线程对象，将新线程表示转移到具有默认状态的现有线程对象中，并将临时线程对象的状态设置为不表示任何正在运行的线程的默认状态。然后，临时线程对象被销毁，什么也不做。|1779887|下面是一个例子：|1779888|#include+<iostream>
#include+<thread>

void+thread_func(const+int+i)+{
++++std::cout+<<+"hello+from+thread:+"+<<+i+<<+std::endl;
}

int+main()+{
++++std::thread+t;
++++std::cout+<<+"t+exists"+<<+std::endl;

++++t+=+std::thread{+thread_func,+7+};
++++t.join();

++++std::cout+<<+"done!"+<<+std::endl;
}|1779889|entityMap^0|0|B|12|B|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|15|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|U|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|V|$]]

<code>std::thread</code>'s default constructor instantiates a <code>std::thread</code> without starting or representing any actual thread.

<pre><code>std::thread t;
</code></pre>

The assignment operator moves the state of a thread object, and sets the assigned-from thread object to its default-initialized state:

<pre><code>t = std::thread(/* new thread code goes here */);
</code></pre>

This first constructs a temporary thread object representing a new thread, transfers the new thread representation into the existing thread object that has a default state, and sets the temporary thread object's state to the default state that does not represent any running thread. Then the temporary thread object is destroyed, doing nothing.

Here's an example:

<pre><code>#include &lt;iostream&gt;
#include &lt;thread&gt;

void thread_func(const int i) {
 std::cout &lt;&lt; "hello from thread: " &lt;&lt; i &lt;&lt; std::endl;
}

int main() {
 std::thread t;
 std::cout &lt;&lt; "t exists" &lt;&lt; std::endl;

 t = std::thread{ thread_func, 7 };
 t.join();

 std::cout &lt;&lt; "done!" &lt;&lt; std::endl;
}
</code></pre>

blocks|key|1776688|text|没有创建线程“挂起”的“标准”，我想这就是您想要使用C%2B%2B线程库做的事情。因为并不是每个有线程的平台都支持它，所以C%2B%2B应用编程接口中也没有它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1776689|1776690|你可能想创建一个包含所有必需数据的类，而不是实际运行你的线程函数。这与创建线程不同，但可能是您想要的。|ordered-list-item|1776691|你可能需要你的线程的线程id。这意味着您确实需要启动线程函数。但是，它可以从等待条件变量开始。然后，当您希望该条件变量继续运行时，您可以向该条件变量发送信号或进行广播。当然，你可以让函数在它恢复后检查一个条件，以防你可能已经决定关闭它并不运行它(在这种情况下，它只会返回instantly).|1776692|You可能需要一个没有函数的std::thread对象)。您可以这样做，并在以后将其附加到一个函数，以便在新线程中run该函数。|offset|length|style|CODE|1776693|1776694|entityMap^0|0|0|0|0|E|B|1L|3|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|R|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|T|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|U|8|@$J|V|K|W|L|M]|$J|X|K|Y|L|M]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|P|$]]

There is no "standard" of creating a thread "suspended" which I assume is what you wanted to do with the C++ thread library. Because it is not supported on every platform that has threads, it is not there in the C++ API.

<ol>
<li>You might want to create a class with all the data it is required but not actually run your thread function. This is not the same as creating the thread but may be what you want. If so, create that, then later bind the object and its <code>operator()</code> or <code>start()</code> function or whatever to the thread.</li>
<li>You might want the thread id for your thread. That means you do actually need to start the thread function. However it can start by waiting on a condition variable. You then signal or broadcast to that condition variable later when you want it to continue running. Of course you can have the function check a condition after it resumes in case you might have decided to close it and not run it after all (in which case it will just return instantly).</li>
<li>You might want a <code>std::thread</code> object with no function. You can do that and attach it to a function later to <code>run</code> that function in a new thread.</li>
</ol>

blocks|key|1779928|text|正如antred在his+answer中所说，您可以使用条件变量使线程在其例程开始时等待。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1779929|Scott+Meyer在他的书“Effective+Modern+C%2B%2B”(在“项目39:考虑将void期货用于单次事件通信”中)建议使用void-future代替较低级别的实体(布尔标志、条件变量和互斥锁)。所以这个问题可以这样解决：|style|CODE|1779930|auto+thread_starter+=+std::promise<void>;
auto+thread+=+std::thread([starter_future+=+thread_starter.get_future()]()+mutable+{
++++starter_future.wait();+//wait+before+starting+actual+work
++++…;+//do+actual+work
});
…;+//you+can+do+something,+thread+is+like+“paused”+here
thread_starter.set_value();+//“start”+the+thread+(break+its+initial+waiting)|code-block|syntax|javascript|1779931|Scott+Meyer还警告了第二个…中的异常(由you+can+do+something,+thread+is+like+“paused”+here注释标记)。如果由于某些原因thread_starter.set_value()从未被调用(例如，由于第二个…中的异常抛出)，线程将永远等待，并且任何连接它的尝试都将导致死锁。|1779932|由于这两种方法(基于condvar和基于未来)都包含隐藏的不安全因素，而第一种方法(基于condvar)需要一些样板代码，因此我建议围绕std::thread编写一个包装类。它的接口应该类似于std::thread的接口(除了它的实例应该可以从相同类的其他实例赋值，而不是从std::thread赋值)，但包含额外的void+start()方法。|1779933|基于未来的线程包装器|1779934|class+initially_suspended_thread+{
++++std::promise<bool>+starter;
++++std::thread+impl;
public:
++++template<class+F,+class+...Args>
++++explicit+initially_suspended_thread(F+&&f,+Args+&&...args):
++++++++starter(),
++++++++impl([
++++++++++++starter_future+=+starter.get_future(),
++++++++++++routine+=+std::bind(std::forward<F>(f),+std::forward<Args>(args)...)
++++++++]()+mutable+{if+(starter_future.get())+routine();})
++++{}
++++void+start()+{starter.set_value(true);}
++++~initially_suspended_thread()+{
++++++++try+{starter.set_value(false);}
++++++++catch+(const+std::future_error+&exc)+{
++++++++++++if+(exc.code()+!=+std::future_errc::promise_already_satisfied)+throw;
++++++++++++return;+//already+“started”,+no+need+to+do+anything
++++++++}
++++++++impl.join();+//auto-join+not-yet-“started”+threads
++++}
++++…;+//other+methods,+trivial
};|1779935|基于Condvar的线程包装器|1779936|class+initially_suspended_thread+{
++++std::mutex+state_mutex;
++++enum+{INITIAL,+STARTED,+ABORTED}+state;
++++std::condition_variable+state_condvar;
++++std::thread+impl;
public:
++++template<class+F,+class+...Args>
++++explicit+initially_suspended_thread(F+&&f,+Args+&&...args):
++++++++state_mutex(),+state(INITIAL),+state_condvar(),
++++++++impl([
++++++++++++&state_mutex+=+state_mutex,+&state+=+state,+&state_condvar+=+state_condvar,
++++++++++++routine+=+std::bind(std::forward<F>(f),+std::forward<Args>(args)...)
++++++++]()+{
++++++++++++{
++++++++++++++++std::unique_lock+state_mutex_lock(state_mutex);
++++++++++++++++state_condvar.wait(
++++++++++++++++++++state_mutex_lock,
++++++++++++++++++++[&state]()+{return+state+!=+INITIAL;}
++++++++++++++++);
++++++++++++}
++++++++++++if+(state+==+STARTED)+routine();
++++++++})
++++{}
++++void+start()+{
++++++++{
++++++++++++std::lock_guard+state_mutex_lock(state_mutex);
++++++++++++state+=+STARTED;
++++++++}
++++++++state_condvar.notify_one();
++++}
++++~initially_suspended_thread()+{
++++++++{
++++++++++++std::lock_guard+state_mutex_lock(state_mutex);
++++++++++++if+(state+==+STARTED)+return;+//already+“started”,+no+need+to+do+anything
++++++++++++state+=+ABORTED;
++++++++}
++++++++impl.join();+//auto-join+not-yet-“started”+threads
++++}
++++…;+//other+methods,+trivial
};|1779937|entityMap|0|LINK|mutability|MUTABLE|url|/a/25525314^0|9|A|0|0|1C|4|1X|4|0|0|I|1|P|1E|2H|Q|3L|1|0|1W|B|2O|B|3T|B|4E|C|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|D|3|E|5|6|7|1A|8|@$A|1B|B|1C|F|G]|$A|1D|B|1E|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|1F|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1G|8|@$A|1H|B|1I|F|G]|$A|1J|B|1K|F|G]|$A|1L|B|1M|F|G]|$A|1N|B|1O|F|G]]|9|@]|C|$]]|$1|O|3|P|5|6|7|1P|8|@$A|1Q|B|1R|F|G]|$A|1S|B|1T|F|G]|$A|1U|B|1V|F|G]|$A|1W|B|1X|F|G]]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|S|3|T|5|J|7|1Z|8|@]|9|@]|C|$K|L]]|$1|U|3|V|5|6|7|20|8|@]|9|@]|C|$]]|$1|W|3|X|5|J|7|21|8|@]|9|@]|C|$K|L]]|$1|Y|3|-4|5|6|7|22|8|@]|9|@]|C|$]]]|Z|$10|$5|11|12|13|C|$14|15]]]]

As antred says in <a href="/a/25525314">his answer</a>, you can use a condition variable to make the thread to wait in the beginning of its routine.

Scott Meyers in his book “Effective Modern C++” (in the “Item 39: Consider <code>void</code> futures for one-shot event communication”) proposes to use <code>void</code>-future instead of lower level entities (boolean flag, conditional variable and mutex). So the problem can be solved like this:

<pre><code>auto thread_starter = std::promise&lt;void&gt;;
auto thread = std::thread([starter_future = thread_starter.get_future()]() mutable {
 starter_future.wait(); //wait before starting actual work
 …; //do actual work
});
…; //you can do something, thread is like “paused” here
thread_starter.set_value(); //“start” the thread (break its initial waiting)
</code></pre>

Scott Meyers also warns about exceptions in the second <code>…</code> (marked by the <code>you can do something, thread is like “paused” here</code> comment). If <code>thread_starter.set_value()</code> is never called for some reasons (for example, due to exception throws in the second <code>…</code>), the thread will wait forever, and any attempt to join it would result in deadlock.

As both ways (condvar-based and future-based) contain hidden unsafety, and the first way (condvar-based) needs some boilerplate code, I propose to write a wrapper class around <code>std::thread</code>. Its interface should be similar to the one of <code>std::thread</code> (except that its instances should be assignable from other instances of the same class, not from <code>std::thread</code>), but contain additional <code>void start()</code> method.

<h1>Future-based thread-wrapper</h1>

<pre><code>class initially_suspended_thread {
 std::promise&lt;bool&gt; starter;
 std::thread impl;
public:
 template&lt;class F, class ...Args&gt;
 explicit initially_suspended_thread(F &amp;&amp;f, Args &amp;&amp;...args):
 starter(),
 impl([
 starter_future = starter.get_future(),
 routine = std::bind(std::forward&lt;F&gt;(f), std::forward&lt;Args&gt;(args)...)
 ]() mutable {if (starter_future.get()) routine();})
 {}
 void start() {starter.set_value(true);}
 ~initially_suspended_thread() {
 try {starter.set_value(false);}
 catch (const std::future_error &amp;exc) {
 if (exc.code() != std::future_errc::promise_already_satisfied) throw;
 return; //already “started”, no need to do anything
 }
 impl.join(); //auto-join not-yet-“started” threads
 }
 …; //other methods, trivial
};
</code></pre>

<h1>Condvar-based thread-wrapper</h1>

<pre><code>class initially_suspended_thread {
 std::mutex state_mutex;
 enum {INITIAL, STARTED, ABORTED} state;
 std::condition_variable state_condvar;
 std::thread impl;
public:
 template&lt;class F, class ...Args&gt;
 explicit initially_suspended_thread(F &amp;&amp;f, Args &amp;&amp;...args):
 state_mutex(), state(INITIAL), state_condvar(),
 impl([
 &amp;state_mutex = state_mutex, &amp;state = state, &amp;state_condvar = state_condvar,
 routine = std::bind(std::forward&lt;F&gt;(f), std::forward&lt;Args&gt;(args)...)
 ]() {
 {
 std::unique_lock state_mutex_lock(state_mutex);
 state_condvar.wait(
 state_mutex_lock,
 [&amp;state]() {return state != INITIAL;}
 );
 }
 if (state == STARTED) routine();
 })
 {}
 void start() {
 {
 std::lock_guard state_mutex_lock(state_mutex);
 state = STARTED;
 }
 state_condvar.notify_one();
 }
 ~initially_suspended_thread() {
 {
 std::lock_guard state_mutex_lock(state_mutex);
 if (state == STARTED) return; //already “started”, no need to do anything
 state = ABORTED;
 }
 impl.join(); //auto-join not-yet-“started” threads
 }
 …; //other methods, trivial
};
</code></pre>

blocks|key|2317813|text|第一次在类中声明的m_grabber不运行任何东西。我们在launch_grabber方法中使用lambda函数为成员类对象分配新的成员类对象，而使用lambda函数的线程在source类上下文中运行。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2317814|class++source+{
...
+std::thread+m_grabber;
+bool+m_active;
...
}


bool+source::launch_grabber()+{
++++//+start+grabber
++++m_grabber+=+std::thread{+
++++++++[&]+()+{
++++++++++++m_active+=+true;
++++++++++++while+(true)
++++++++++++{
++++++++++++++++if(!m_active)
++++++++++++++++++++break;
++++++++++++++++//+TODO:+something+in+new+thread

++++++++++++}
++++++++}
++++};

++++m_grabber.detach();
++++return+true;
}|code-block|syntax|javascript|2317815|entityMap^0|9|9|T|E|2F|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

first declared in class <code>m_grabber</code> runs nothing. We assign member class object with new one with lambda function in <code>launch_grabber</code> method and thread with lambda runs within <code>source</code> class context.

<pre><code>class source {
...
 std::thread m_grabber;
 bool m_active;
...
}


bool source::launch_grabber() {
 // start grabber
 m_grabber = std::thread{ 
 [&amp;] () {
 m_active = true;
 while (true)
 {
 if(!m_active)
 break;
 // TODO: something in new thread

 }
 }
 };

 m_grabber.detach();
 return true;
}
</code></pre>

I'm getting into C++11 threads and have run into a problem.

I want to declare a thread variable as global and start it later.

However all the examples I've seen seem to start the thread immediately for example

<pre><code>thread t(doSomething);
</code></pre>

What I want is 

<pre><code>thread t;
</code></pre>

and start the thread later.

What I've tried is 

<pre><code>if(!isThreadRunning)
{
 thread t(readTable);
}
</code></pre>

but now t is block scope. So I want to declare t and then start the thread later so that t is accessible to other functions.

Thanks for any help.

Delayed start of a thread in C++ 11

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我遇到了C++11线程，遇到了一个问题。我希望将线程变量声明为全局变量，并在稍后启动它。然而，我所见过的所有示例似乎都是立即启动线程的，例如thread t(doSomething);我想要的是thread t;并稍后启动该线程。我试过的是if(!isThreadRunning){    thread t(readTa...

问C++ 11中线程的延迟启动
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++ 11中线程的延迟启动EN