blocks|key|2815609|text|线程池意味着所有线程都在运行-换句话说，线程函数永远不会返回。要让线程做一些有意义的事情，您必须设计一个线程间通信系统，用于告诉线程有事情要做，以及用于传递实际的工作数据。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2815610|通常，这将涉及某种并发数据结构，每个线程可能会在某种条件变量上休眠，当有工作要做时会通知该变量。在接收到通知时，一个或几个线程被唤醒，从并发数据结构中恢复任务，处理它，并以类似的方式存储结果。|2815611|然后线程将继续检查是否还有更多的工作要做，如果没有，则返回睡眠。|2815612|结果是，你必须自己设计所有这些，因为没有一个普遍适用的“工作”的自然概念。这是一个相当多的工作，有一些微妙的问题，你必须正确的。(如果你喜欢一个在后台为你管理线程的系统，你可以在Go中编程。)|2815613|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

A pool of threads means that all your threads are running, all the time &ndash; in other words, the thread function never returns. To give the threads something meaningful to do, you have to design a system of inter-thread communication, both for the purpose of telling the thread that there's something to do, as well as for communicating the actual work data.

Typically this will involve some kind of concurrent data structure, and each thread would presumably sleep on some kind of condition variable, which would be notified when there's work to do. Upon receiving the notification, one or several of the threads wake up, recover a task from the concurrent data structure, process it, and store the result in an analogous fashion.

The thread would then go on to check whether there's even more work to do, and if not go back to sleep.

The upshot is that you have to design all this yourself, since there isn't a natural notion of "work" that's universally applicable. It's quite a bit of work, and there are some subtle issues you have to get right. (You can program in Go if you like a system which takes care of thread management for you behind the scenes.)

blocks|key|190484|text|编辑:现在需要C%2B%2B17和concepts。(截至16年9月12日，只有g%2B%2B+6.0%2B是足够的。)|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|190485|但是，由于模板推导更加准确，因此值得为获得更新的编译器而努力。我还没有找到需要显式模板参数的函数。|190486|它现在还接受任何适当的可调用对象(并且仍然是静态类型安全的！)。|190487|它现在还包括一个可选的绿色线程优先级线程池，使用相同的API。不过，这个类仅适用于POSIX。它使用ucontext_t应用程序接口进行用户空间任务切换。|CODE|190488|190489|为此，我创建了一个简单的库。下面给出了一个用法示例。(我之所以回答这个问题，是因为它是我在决定有必要自己编写它之前发现的东西之一。)|190490|bool+is_prime(int+n){
++//+Determine+if+n+is+prime.
}

int+main(){
++thread_pool+pool(8);+//+8+threads

++list<future<bool>>+results;
++for(int+n+=+2;n+<+10000;n%2B%2B){
++++//+Submit+a+job+to+the+pool.
++++results.emplace_back(pool.async(is_prime,+n));
++}

++int+n+=+2;
++for(auto+i+=+results.begin();i+!=+results.end();i%2B%2B,+n%2B%2B){
++++//+i+is+an+iterator+pointing+to+a+future+representing+the+result+of+is_prime(n)
++++cout+<<+n+<<+"+";
++++bool+prime+=+i->get();+//+Wait+for+the+task+is_prime(n)+to+finish+and+get+the+result.
++++if(prime)
++++++cout+<<+"is+prime";
++++else
++++++cout+<<+"is+not+prime";
++++cout+<<+endl;
++}++
}|code-block|syntax|javascript|190491|你可以用任何(或空的)返回值和任何(或不带)参数向async传递任何函数，它将返回一个相应的std::future。要获得结果(或者只是等待任务完成)，您可以在将来调用get()。|190492|这里是github：https://github.com/Tyler-Hardin/thread_pool。|190493|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/Tyler-Hardin/thread_pool^0|0|1E|0|0|0|1E|A|0|0|0|0|P|5|1A|B|2C|5|0|A|17|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|19|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1A|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1B|8|@$9|1C|A|1D|B|L]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1F|8|@]|D|@]|E|$]]|$1|P|3|Q|5|R|7|1G|8|@]|D|@]|E|$S|T]]|$1|U|3|V|5|6|7|1H|8|@$9|1I|A|1J|B|L]|$9|1K|A|1L|B|L]|$9|1M|A|1N|B|L]]|D|@]|E|$]]|$1|W|3|X|5|6|7|1O|8|@]|D|@$9|1P|A|1Q|1|1R]]|E|$]]|$1|Y|3|-4|5|6|7|1S|8|@]|D|@]|E|$]]]|Z|$10|$5|11|12|13|E|$14|15]]]]

Edit: This now requires C++17 and concepts. (As of 9/12/16, only g++ 6.0+ is sufficient.)

The template deduction is a lot more accurate because of it, though, so it's worth the effort of getting a newer compiler. I've not yet found a function that requires explicit template arguments.

It also now takes any appropriate callable object (and is still statically typesafe!!!).

It also now includes an optional green threading priority thread pool using the same API. This class is POSIX only, though. It uses the <code>ucontext_t</code> API for userspace task switching.

<hr>

I created a simple library for this. An example of usage is given below. (I'm answering this because it was one of the things I found before I decided it was necessary to write it myself.)

<pre><code>bool is_prime(int n){
 // Determine if n is prime.
}

int main(){
 thread_pool pool(8); // 8 threads

 list&lt;future&lt;bool&gt;&gt; results;
 for(int n = 2;n &lt; 10000;n++){
 // Submit a job to the pool.
 results.emplace_back(pool.async(is_prime, n));
 }

 int n = 2;
 for(auto i = results.begin();i != results.end();i++, n++){
 // i is an iterator pointing to a future representing the result of is_prime(n)
 cout &lt;&lt; n &lt;&lt; " ";
 bool prime = i-&gt;get(); // Wait for the task is_prime(n) to finish and get the result.
 if(prime)
 cout &lt;&lt; "is prime";
 else
 cout &lt;&lt; "is not prime";
 cout &lt;&lt; endl;
 } 
}
</code></pre>

You can pass <code>async</code> any function with any (or void) return value and any (or no) arguments and it will return a corresponding <code>std::future</code>. To get the result (or just wait until a task has completed) you call <code>get()</code> on the future.

Here's the github: <a href="https://github.com/Tyler-Hardin/thread_pool" rel="nofollow noreferrer">https://github.com/Tyler-Hardin/thread_pool</a>.

blocks|key|194756|text|您可以使用C%2B%2B线程池库https://github.com/vit-vit/ctpl。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|194757|然后，您编写的代码可以替换为以下代码|194758|#include+<ctpl.h>++//+or+<ctpl_stl.h>+if+ou+do+not+have+Boost+library

int+main+(int+argc,+char+*argv[])+{
++++ctpl::thread_pool+p(2+/*+two+threads+in+the+pool+*/);
++++int+arr[4]+=+{0};
++++std::vector<std::future<void>>+results(4);
++++for+(int+i+=+0;+i+<+8;+%2B%2Bi)+{+//+for+8+iterations,
++++++++for+(int+j+=+0;+j+<+4;+%2B%2Bj)+{
++++++++++++results[j]+=+p.push([&arr,+j](int){+arr[j]+%2B=2;+});
++++++++}
++++++++for+(int+j+=+0;+j+<+4;+%2B%2Bj)+{
++++++++++++results[j].get();
++++++++}
++++++++arr[4]+=+std::min_element(arr,+arr+%2B+4);
++++}
}|code-block|syntax|javascript|194759|您将获得所需的线程数量，并且不会在迭代中一次又一次地创建和删除它们。|194760|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/vit-vit/ctpl^0|C|V|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

You can use C++ Thread Pool Library, <a href="https://github.com/vit-vit/ctpl" rel="noreferrer">https://github.com/vit-vit/ctpl</a>.

Then the code your wrote can be replaced with the following

<pre><code>#include &lt;ctpl.h&gt; // or &lt;ctpl_stl.h&gt; if ou do not have Boost library

int main (int argc, char *argv[]) {
 ctpl::thread_pool p(2 /* two threads in the pool */);
 int arr[4] = {0};
 std::vector&lt;std::future&lt;void&gt;&gt; results(4);
 for (int i = 0; i &lt; 8; ++i) { // for 8 iterations,
 for (int j = 0; j &lt; 4; ++j) {
 results[j] = p.push([&amp;arr, j](int){ arr[j] +=2; });
 }
 for (int j = 0; j &lt; 4; ++j) {
 results[j].get();
 }
 arr[4] = std::min_element(arr, arr + 4);
 }
}
</code></pre>

You will get the desired number of threads and will not create and delete them over and over again on the iterations.

blocks|key|2815678|text|这是从我的答案复制到另一个非常类似的帖子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2815679|2815680|以系统可支持的最大线程数启动：|ordered-list-item|2815681|2815682|std::thread::hardware_concurrency();+num_threads+=+int|2815683|2815684|为了实现高效的线程池，一旦根据num_threads创建了线程，最好不要创建新线程或销毁旧线程(通过连接)。这会带来性能上的损失，甚至会使你的应用程序比串行版本运行得更慢。|offset|length|style|CODE|2815685|2815686|每个C%2B%2B11线程都应该以无限循环的方式在其函数中运行，不断等待新任务的获取和运行。|2815687|下面是如何将这样的函数附加到线程池中：|2815688|int+num_threads+=+std::thread::hardware_concurrency();
std::vector<std::thread>+threads;
for+(int+i+=+0;+i+<+num_threads;+i%2B%2B)
{
++++pool.push_back(std::thread(Infinite_loop_function));
}|code-block|syntax|javascript|2815689|2815690|无限循环函数。这是一个等待任务队列的while+(true)循环。|2815691|2815692|void+Pool::Infinite_loop_function()
{
++++while+(true)
++++{
++++++++{
++++++++++++std::unique_lock<std::mutex>+lock(queue_mutex);

++++++++++++condition.wait(lock,+[this](){
++++++++++++++++return+!queue.empty()+%7C%7C+terminate_pool;
++++++++++++});
++++++++++++Job+=+queue.front();
++++++++++++queue.pop();
++++++++}

++++++++Job();+//+function<void()>+type
++++}
};|2815693|2815694|生成一个将作业添加到queue|2815695|的函数|2815696|void+Pool::Add_Job(function<void()>+New_Job)
{
++++{
++++++++std::unique_lock<std::mutex>+lock(queue_mutex);
++++++++queue.push(New_Job);
++++}

++++condition.notify_one();
}|2815697|2815698|将任意函数绑定到您的queue|2815699|2815700|Pool_Obj.Add_Job(std::bind(&Some_Class::Some_Method,+&Some_object));|2815701|一旦你整合了这些元素，你就拥有了自己的动态线程池。这些线程总是在运行，等待作业完成。|2815702|如果有一些语法错误，我很抱歉，我输入了这段代码，并且我的记忆力很差。很抱歉，我不能提供给你完整的线程池代码；这将违反我的工作完整性。|2815703|编辑:要终止池，请调用shutdown()方法：|2815704|Pool::shutdown()
{
++++{
++++++++std::unique_lock<std::mutex>+lock(threadpool_mutex);
++++++++terminate_pool+=+true;+//+use+this+flag+in+condition.wait
++++}

++++condition.notify_all();+//+wake+up+all+threads.

++++//+Join+all+threads.
++++for+(std::thread+&th+:+threads)
++++{
++++++++th.join();
++++}

++++pool.clear();++
++++stopped+=+true;+//+use+this+flag+in+destructor,+if+not+set,+call+shutdown()+
}|2815705|注意:使用匿名代码块是为了在退出时，在其中创建的std::unique_lock变量超出作用域，从而解锁互斥锁。|2815706|entityMap^0|0|0|0|0|0|0|F|B|0|0|0|0|0|0|I|C|0|0|0|0|0|0|0|0|0|0|0|0|0|B|A|0|0|O|G|0^^$0|@$1|2|3|4|5|6|7|1U|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1W|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|20|8|@$L|21|M|22|N|O]]|9|@]|A|$]]|$1|P|3|-4|5|6|7|23|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|24|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|25|8|@]|9|@]|A|$]]|$1|U|3|V|5|W|7|26|8|@]|9|@]|A|$X|Y]]|$1|Z|3|-4|5|6|7|27|8|@]|9|@]|A|$]]|$1|10|3|11|5|E|7|28|8|@$L|29|M|2A|N|O]]|9|@]|A|$]]|$1|12|3|-4|5|6|7|2B|8|@]|9|@]|A|$]]|$1|13|3|14|5|W|7|2C|8|@]|9|@]|A|$X|Y]]|$1|15|3|-4|5|6|7|2D|8|@]|9|@]|A|$]]|$1|16|3|17|5|E|7|2E|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2F|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|W|7|2G|8|@]|9|@]|A|$X|Y]]|$1|1C|3|-4|5|6|7|2H|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|E|7|2I|8|@]|9|@]|A|$]]|$1|1F|3|-4|5|6|7|2J|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|W|7|2K|8|@]|9|@]|A|$X|Y]]|$1|1I|3|1J|5|6|7|2L|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|6|7|2M|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|6|7|2N|8|@$L|2O|M|2P|N|O]]|9|@]|A|$]]|$1|1O|3|1P|5|W|7|2Q|8|@]|9|@]|A|$X|Y]]|$1|1Q|3|1R|5|6|7|2R|8|@$L|2S|M|2T|N|O]]|9|@]|A|$]]|$1|1S|3|-4|5|6|7|2U|8|@]|9|@]|A|$]]]|1T|$]]

This is copied from my answer to another very similar post:
<ol>
<li>Start with maximum number of threads the system can support:
<pre class="lang-cpp prettyprint-override"><code>int num_threads = std::thread::hardware_concurrency();
</code></pre>
</li>
<li>For an efficient threadpool implementation, once threads are created according to <code>num_threads</code>, it's better not to create new ones, or destroy old ones (by joining). There will be a performance penalty, an it might even make your application go slower than the serial version.
</li>
</ol>
Each C++11 thread should be running in their function with an infinite loop, constantly waiting for new tasks to grab and run.
Here is how to attach such a function to the thread pool:
<pre class="lang-cpp prettyprint-override"><code>int num_threads = std::thread::hardware_concurrency();
std::vector&lt;std::thread&gt; threads;
for (int i = 0; i &lt; num_threads; i++)
{
 pool.push_back(std::thread(Infinite_loop_function));
}
</code></pre>
<ol start="3">
<li>The infinite loop function. This is a <code>while (true)</code> loop waiting for the task queue.</li>
</ol>
<pre class="lang-cpp prettyprint-override"><code>void Pool::Infinite_loop_function()
{
 while (true)
 {
 {
 std::unique_lock&lt;std::mutex&gt; lock(queue_mutex);

 condition.wait(lock, [this](){
 return !queue.empty() || terminate_pool;
 });
 Job = queue.front();
 queue.pop();
 }

 Job(); // function&lt;void()&gt; type
 }
};
</code></pre>
<ol start="4">
<li>Make a function to add job to your queue</li>
</ol>
<pre class="lang-cpp prettyprint-override"><code>void Pool::Add_Job(function&lt;void()&gt; New_Job)
{
 {
 std::unique_lock&lt;std::mutex&gt; lock(queue_mutex);
 queue.push(New_Job);
 }

 condition.notify_one();
}
</code></pre>
<ol start="5">
<li>Bind an arbitrary function to your queue</li>
</ol>
<pre class="lang-cpp prettyprint-override"><code>Pool_Obj.Add_Job(std::bind(&amp;Some_Class::Some_Method, &amp;Some_object));
</code></pre>
Once you integrate these ingredients, you have your own dynamic threading pool. These threads always run, waiting for job to do.
I apologize if there are some syntax errors, I typed this code and and I have a bad memory. Sorry that I cannot provide you the complete thread pool code; that would violate my job integrity.
Edit: to terminate the pool, call the <code>shutdown()</code> method:
<pre class="lang-cpp prettyprint-override"><code>Pool::shutdown()
{
 {
 std::unique_lock&lt;std::mutex&gt; lock(threadpool_mutex);
 terminate_pool = true; // use this flag in condition.wait
 }

 condition.notify_all(); // wake up all threads.

 // Join all threads.
 for (std::thread &amp;th : threads)
 {
 th.join();
 }

 pool.clear(); 
 stopped = true; // use this flag in destructor, if not set, call shutdown() 
}
</code></pre>
Note: the anonymous code blocks are used so that when they are exited, the <code>std::unique_lock</code> variables created within them go out of scope, unlocking the mutex.

blocks|key|190530|text|像这样的东西可能会有帮助(取自一个正常工作的应用程序)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|190531|#include+<memory>
#include+<boost/asio.hpp>
#include+<boost/thread.hpp>

struct+thread_pool+{
++typedef+std::unique_ptr<boost::asio::io_service::work>+asio_worker;

++thread_pool(int+threads)+:service(),+service_worker(new+asio_worker::element_type(service))+{
++++for+(int+i+=+0;+i+<+threads;+%2B%2Bi)+{
++++++auto+worker+=+[this]+{+return+service.run();+};
++++++grp.add_thread(new+boost::thread(worker));
++++}
++}

++template<class+F>
++void+enqueue(F+f)+{
++++service.post(f);
++}

++~thread_pool()+{
++++service_worker.reset();
++++grp.join_all();
++++service.stop();
++}

private:
++boost::asio::io_service+service;
++asio_worker+service_worker;
++boost::thread_group+grp;
};|code-block|syntax|javascript|190532|你可以这样使用它：|190533|thread_pool+pool(2);

pool.enqueue([]+{
++std::cout+<<+"Hello+from+Task+1\n";
});

pool.enqueue([]+{
++std::cout+<<+"Hello+from+Task+2\n";
});|190534|请记住，重新发明一个有效的异步队列机制并不是微不足道的。|190535|Boost::asio::io_service是一个非常高效的实现，或者实际上是特定于平台的包装器的集合(例如，它包装了Windows上的I/O完成端口)。|190536|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Something like this might help (taken from a working app).

<pre><code>#include &lt;memory&gt;
#include &lt;boost/asio.hpp&gt;
#include &lt;boost/thread.hpp&gt;

struct thread_pool {
 typedef std::unique_ptr&lt;boost::asio::io_service::work&gt; asio_worker;

 thread_pool(int threads) :service(), service_worker(new asio_worker::element_type(service)) {
 for (int i = 0; i &lt; threads; ++i) {
 auto worker = [this] { return service.run(); };
 grp.add_thread(new boost::thread(worker));
 }
 }

 template&lt;class F&gt;
 void enqueue(F f) {
 service.post(f);
 }

 ~thread_pool() {
 service_worker.reset();
 grp.join_all();
 service.stop();
 }

private:
 boost::asio::io_service service;
 asio_worker service_worker;
 boost::thread_group grp;
};
</code></pre>

You can use it like this:

<pre><code>thread_pool pool(2);

pool.enqueue([] {
 std::cout &lt;&lt; "Hello from Task 1\n";
});

pool.enqueue([] {
 std::cout &lt;&lt; "Hello from Task 2\n";
});
</code></pre>

Keep in mind that reinventing an efficient asynchronous queuing mechanism is not trivial.

Boost::asio::io_service is a very efficient implementation, or actually is a collection of platform-specific wrappers (e.g. it wraps I/O completion ports on Windows).

blocks|key|194788|text|在STL之外没有依赖项的线程池是完全可能的。我最近写了一个小的header-only+threadpool+library来解决完全相同的问题。它支持动态池大小调整(在运行时更改工作进程的数量)、等待、停止、暂停、恢复等。我希望你会发现它是有用的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|194789|entityMap|0|LINK|mutability|MUTABLE|url|https://gitlab.com/cantordust/threadpool^0|V|U|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

A threadpool with no dependencies outside of STL is entirely possible. I recently wrote a small <a href="https://gitlab.com/cantordust/threadpool" rel="nofollow noreferrer">header-only threadpool library</a> to address the exact same problem. It supports dynamic pool resizing (changing the number of workers at runtime), waiting, stopping, pausing, resuming and so on. I hope you find it useful.

blocks|key|192384|text|这是另一个线程池实现，它非常简单，易于理解和使用，只使用C%2B%2B11标准库，并且可以根据您的使用进行查看或修改，如果您想要开始使用线程池，应该是一个很好的入门级：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|192385|https://github.com/progschj/ThreadPool|offset|length|192386|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|12|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

This is another thread pool implementation that is very simple, easy to understand and use, uses only C++11 standard library, and can be looked at or modified for your uses, should be a nice starter if you want to get into using thread pools: 

<a href="https://github.com/progschj/ThreadPool" rel="nofollow noreferrer">https://github.com/progschj/ThreadPool</a>

blocks|key|3028289|text|Follwoing+[PhD+EcE](https://stackoverflow.com/users/3818417/phd-ece)+suggestion,+I+implemented+the+thread+pool:|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3028290|unstyled|3028291|+function_pool.h|blockquote|3028292|3028293|3028294|#pragma+once
#include+<queue>
#include+<functional>
#include+<mutex>
#include+<condition_variable>
#include+<atomic>
#include+<cassert>

class+Function_pool
{

private:
++++std::queue<std::function<void()>>+m_function_queue;
++++std::mutex+m_lock;
++++std::condition_variable+m_data_condition;
++++std::atomic<bool>+m_accept_functions;

public:

++++Function_pool();
++++~Function_pool();
++++void+push(std::function<void()>+func);
++++void+done();
++++void+infinite_loop_func();
};|3028295|3028296|+function_pool.cpp|3028297|3028298|3028299|#include+"function_pool.h"

Function_pool::Function_pool()+:+m_function_queue(),+m_lock(),+m_data_condition(),+m_accept_functions(true)
{
}

Function_pool::~Function_pool()
{
}

void+Function_pool::push(std::function<void()>+func)
{
++++std::unique_lock<std::mutex>+lock(m_lock);
++++m_function_queue.push(func);
++++//+when+we+send+the+notification+immediately,+the+consumer+will+try+to+get+the+lock+,+so+unlock+asap
++++lock.unlock();
++++m_data_condition.notify_one();
}

void+Function_pool::done()
{
++++std::unique_lock<std::mutex>+lock(m_lock);
++++m_accept_functions+=+false;
++++lock.unlock();
++++//+when+we+send+the+notification+immediately,+the+consumer+will+try+to+get+the+lock+,+so+unlock+asap
++++m_data_condition.notify_all();
++++//notify+all+waiting+threads.
}

void+Function_pool::infinite_loop_func()
{
++++std::function<void()>+func;
++++while+(true)
++++{
++++++++{
++++++++++++std::unique_lock<std::mutex>+lock(m_lock);
++++++++++++m_data_condition.wait(lock,+[this]()+{return+!m_function_queue.empty()+%7C%7C+!m_accept_functions;+});
++++++++++++if+(!m_accept_functions+&&+m_function_queue.empty())
++++++++++++{
++++++++++++++++//lock+will+be+release+automatically.
++++++++++++++++//finish+the+thread+loop+and+let+it+join+in+the+main+thread.
++++++++++++++++return;
++++++++++++}
++++++++++++func+=+m_function_queue.front();
++++++++++++m_function_queue.pop();
++++++++++++//release+the+lock
++++++++}
++++++++func();
++++}
}|3028300|3028301|+main.cpp|3028302|3028303|3028304|#include+"function_pool.h"
#include+<string>
#include+<iostream>
#include+<mutex>
#include+<functional>
#include+<thread>
#include+<vector>

Function_pool+func_pool;

class+quit_worker_exception+:+public+std::exception+{};

void+example_function()
{
++++std::cout+<<+"bla"+<<+std::endl;
}

int+main()
{
++++std::cout+<<+"stating+operation"+<<+std::endl;
++++int+num_threads+=+std::thread::hardware_concurrency();
++++std::cout+<<+"number+of+threads+=+"+<<+num_threads+<<+std::endl;
++++std::vector<std::thread>+thread_pool;
++++for+(int+i+=+0;+i+<+num_threads;+i%2B%2B)
++++{
++++++++thread_pool.push_back(std::thread(&Function_pool::infinite_loop_func,+&func_pool));
++++}

++++//here+we+should+send+our+functions
++++for+(int+i+=+0;+i+<+50;+i%2B%2B)
++++{
++++++++func_pool.push(example_function);
++++}
++++func_pool.done();
++++for+(unsigned+int+i+=+0;+i+<+thread_pool.size();+i%2B%2B)
++++{
++++++++thread_pool.at(i).join();
++++}
}|3028305|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|14|8|@]|9|@]|A|$]]|$1|I|3|-4|5|E|7|15|8|@]|9|@]|A|$]]|$1|J|3|-4|5|E|7|16|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|17|8|@]|9|@]|A|$B|C]]|$1|M|3|-4|5|E|7|18|8|@]|9|@]|A|$]]|$1|N|3|O|5|H|7|19|8|@]|9|@]|A|$]]|$1|P|3|-4|5|E|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|E|7|1B|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1C|8|@]|9|@]|A|$B|C]]|$1|T|3|-4|5|E|7|1D|8|@]|9|@]|A|$]]|$1|U|3|V|5|H|7|1E|8|@]|9|@]|A|$]]|$1|W|3|-4|5|E|7|1F|8|@]|9|@]|A|$]]|$1|X|3|-4|5|E|7|1G|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1H|8|@]|9|@]|A|$B|C]]|$1|10|3|-4|5|E|7|1I|8|@]|9|@]|A|$]]]|11|$]]

<pre><code>Follwoing [PhD EcE](https://stackoverflow.com/users/3818417/phd-ece) suggestion, I implemented the thread pool:
</code></pre>

<blockquote>
 function_pool.h
</blockquote>

<pre><code>#pragma once
#include &lt;queue&gt;
#include &lt;functional&gt;
#include &lt;mutex&gt;
#include &lt;condition_variable&gt;
#include &lt;atomic&gt;
#include &lt;cassert&gt;

class Function_pool
{

private:
 std::queue&lt;std::function&lt;void()&gt;&gt; m_function_queue;
 std::mutex m_lock;
 std::condition_variable m_data_condition;
 std::atomic&lt;bool&gt; m_accept_functions;

public:

 Function_pool();
 ~Function_pool();
 void push(std::function&lt;void()&gt; func);
 void done();
 void infinite_loop_func();
};
</code></pre>

<blockquote>
 function_pool.cpp
</blockquote>

<pre><code>#include "function_pool.h"

Function_pool::Function_pool() : m_function_queue(), m_lock(), m_data_condition(), m_accept_functions(true)
{
}

Function_pool::~Function_pool()
{
}

void Function_pool::push(std::function&lt;void()&gt; func)
{
 std::unique_lock&lt;std::mutex&gt; lock(m_lock);
 m_function_queue.push(func);
 // when we send the notification immediately, the consumer will try to get the lock , so unlock asap
 lock.unlock();
 m_data_condition.notify_one();
}

void Function_pool::done()
{
 std::unique_lock&lt;std::mutex&gt; lock(m_lock);
 m_accept_functions = false;
 lock.unlock();
 // when we send the notification immediately, the consumer will try to get the lock , so unlock asap
 m_data_condition.notify_all();
 //notify all waiting threads.
}

void Function_pool::infinite_loop_func()
{
 std::function&lt;void()&gt; func;
 while (true)
 {
 {
 std::unique_lock&lt;std::mutex&gt; lock(m_lock);
 m_data_condition.wait(lock, [this]() {return !m_function_queue.empty() || !m_accept_functions; });
 if (!m_accept_functions &amp;&amp; m_function_queue.empty())
 {
 //lock will be release automatically.
 //finish the thread loop and let it join in the main thread.
 return;
 }
 func = m_function_queue.front();
 m_function_queue.pop();
 //release the lock
 }
 func();
 }
}
</code></pre>

<blockquote>
 main.cpp
</blockquote>

<pre><code>#include "function_pool.h"
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;mutex&gt;
#include &lt;functional&gt;
#include &lt;thread&gt;
#include &lt;vector&gt;

Function_pool func_pool;

class quit_worker_exception : public std::exception {};

void example_function()
{
 std::cout &lt;&lt; "bla" &lt;&lt; std::endl;
}

int main()
{
 std::cout &lt;&lt; "stating operation" &lt;&lt; std::endl;
 int num_threads = std::thread::hardware_concurrency();
 std::cout &lt;&lt; "number of threads = " &lt;&lt; num_threads &lt;&lt; std::endl;
 std::vector&lt;std::thread&gt; thread_pool;
 for (int i = 0; i &lt; num_threads; i++)
 {
 thread_pool.push_back(std::thread(&amp;Function_pool::infinite_loop_func, &amp;func_pool));
 }

 //here we should send our functions
 for (int i = 0; i &lt; 50; i++)
 {
 func_pool.push(example_function);
 }
 func_pool.done();
 for (unsigned int i = 0; i &lt; thread_pool.size(); i++)
 {
 thread_pool.at(i).join();
 }
}
</code></pre>

blocks|key|3028318|text|您可以使用boost库中的thread_pool：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3028319|void+my_task(){...}

int+main(){
++++int+threadNumbers+=+thread::hardware_concurrency();
++++boost::asio::thread_pool+pool(threadNumbers);

++++//+Submit+a+function+to+the+pool.
++++boost::asio::post(pool,+my_task);

++++//+Submit+a+lambda+object+to+the+pool.
++++boost::asio::post(pool,+[]()+{
++++++...
++++});
}|code-block|syntax|javascript|3028320|3028321|您也可以使用开源社区中的threadpool：|3028322|void+first_task()+{...}++++
void+second_task()+{...}

int+main(){
++++int+threadNumbers+=+thread::hardware_concurrency();
++++pool+tp(threadNumbers);

++++//+Add+some+tasks+to+the+pool.
++++tp.schedule(&first_task);
++++tp.schedule(&second_task);
}|3028323|entityMap|0|LINK|mutability|MUTABLE|url|https://www.boost.org/doc/libs/1_66_0/doc/html/boost_asio/reference/thread_pool.html|1|http://threadpool.sourceforge.net/^0|D|B|0|0|0|0|C|A|1|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|12|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|13|8|@]|9|@$A|14|B|15|1|16]]|C|$]]|$1|L|3|M|5|F|7|17|8|@]|9|@]|C|$G|H]]|$1|N|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|O|$P|$5|Q|R|S|C|$T|U]]|V|$5|Q|R|S|C|$T|W]]]]

You can use <a href="https://www.boost.org/doc/libs/1_66_0/doc/html/boost_asio/reference/thread_pool.html" rel="noreferrer">thread_pool</a> from boost library:

<pre><code>void my_task(){...}

int main(){
 int threadNumbers = thread::hardware_concurrency();
 boost::asio::thread_pool pool(threadNumbers);

 // Submit a function to the pool.
 boost::asio::post(pool, my_task);

 // Submit a lambda object to the pool.
 boost::asio::post(pool, []() {
 ...
 });
}
</code></pre>

<hr>

You also can use <a href="http://threadpool.sourceforge.net/" rel="noreferrer">threadpool</a> from open source community:

<pre><code>void first_task() {...} 
void second_task() {...}

int main(){
 int threadNumbers = thread::hardware_concurrency();
 pool tp(threadNumbers);

 // Add some tasks to the pool.
 tp.schedule(&amp;first_task);
 tp.schedule(&amp;second_task);
}
</code></pre>

blocks|key|2815958|text|看起来线程池是非常流行的问题/练习:-)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2815959|我最近用现代的C%2B%2B写了一个；它归我所有，可以在这里公开使用--+https://github.com/yurir-dev/threadpool|offset|length|2815960|它支持模板化的返回值，核心钉住，一些任务的排序。所有实现都在两个.h文件中。|2815961|所以，最初的问题是这样的：|2815962|#include+"tp/threadpool.h"

int+arr[5]+=+{+0+};

concurency::threadPool<void>+tp;
tp.start(std::thread::hardware_concurrency());

std::vector<std::future<void>>+futures;
for+(int+i+=+0;+i+<+8;+%2B%2Bi)+{+//+for+8+iterations,
++++for+(int+j+=+0;+j+<+4;+%2B%2Bj)+{
++++++++futures.push_back(tp.push([&arr,+j]()+{
+++++++++++++++arr[j]+%2B=+2;
++++++++++++}));
++++}
}

//+wait+until+all+pushed+tasks+are+finished.
for+(auto&+f+:+futures)
++++f.get();
//+or+just+tp.end();+//+will+kill+all+the+threads

arr[4]+=+*std::min_element(arr,+arr+%2B+4);|code-block|syntax|javascript|2815963|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/yurir-dev/threadpool^0|0|X|13|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

looks like threadpool is very popular problem/exercise :-)
I recently wrote one in modern C++; it’s owned by me and publicly available here - <a href="https://github.com/yurir-dev/threadpool" rel="nofollow noreferrer">https://github.com/yurir-dev/threadpool</a>
It supports templated return values, core pinning, ordering of some tasks.
all implementation in two .h files.
So, the original question will be something like this:
<pre><code>#include &quot;tp/threadpool.h&quot;

int arr[5] = { 0 };

concurency::threadPool&lt;void&gt; tp;
tp.start(std::thread::hardware_concurrency());

std::vector&lt;std::future&lt;void&gt;&gt; futures;
for (int i = 0; i &lt; 8; ++i) { // for 8 iterations,
 for (int j = 0; j &lt; 4; ++j) {
 futures.push_back(tp.push([&amp;arr, j]() {
 arr[j] += 2;
 }));
 }
}

// wait until all pushed tasks are finished.
for (auto&amp; f : futures)
 f.get();
// or just tp.end(); // will kill all the threads

arr[4] = *std::min_element(arr, arr + 4);
</code></pre>

Relevant questions:

About C++11:

<ul>
<li><a href="https://stackoverflow.com/questions/12993451/c11-stdthread-pooled">C++11: std::thread pooled?</a></li>
<li><a href="https://stackoverflow.com/questions/14351352/will-asynclaunchasync-in-c11-make-thread-pools-obsolete-for-avoiding-expen">Will async(launch::async) in C++11 make thread pools obsolete for avoiding expensive thread creation?</a></li>
</ul>

About Boost:

<ul>
<li><a href="https://stackoverflow.com/questions/2659065/c-boost-thread-reusing-threads">C++ boost thread reusing threads</a></li>
<li><a href="https://stackoverflow.com/questions/3458397/boostthread-and-creating-a-pool-of-them">boost::thread and creating a pool of them!</a></li>
</ul>

<hr>

How do I get a pool of threads to send tasks to, without creating and deleting them over and over again? This means persistent threads to resynchronize without joining.

<hr>

I have code that looks like this:

<pre><code>namespace {
 std::vector&lt;std::thread&gt; workers;

 int total = 4;
 int arr[4] = {0};

 void each_thread_does(int i) {
 arr[i] += 2;
 }
}

int main(int argc, char *argv[]) {
 for (int i = 0; i &lt; 8; ++i) { // for 8 iterations,
 for (int j = 0; j &lt; 4; ++j) {
 workers.push_back(std::thread(each_thread_does, j));
 }
 for (std::thread &amp;t: workers) {
 if (t.joinable()) {
 t.join();
 }
 }
 arr[4] = std::min_element(arr, arr+4);
 }
 return 0;
}
</code></pre>

Instead of creating and joining threads each iteration, I'd prefer to send tasks to my worker threads each iteration and only create them once.

Thread pooling in C++11

数据结构

编译器

Windows

相关问题关于C++11：关于Boost：如何获得线程池 to 将任务发送到，而不是一次又一次地创建和删除它们？这意味着无需加入即可重新同步的持久线程。我的代码看起来像这样：namespace { std::vector<std::thread> workers; int total = 4; int arr[4]...

问C++11中的线程池
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++11中的线程池EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++11中的线程池
EN