Isso é copiado da minha resposta para outro post muito semelhante, espero que possa ajudar:
1) Comece com o número máximo de threads que um sistema pode suportar:
int Num_Threads = thread::hardware_concurrency();
2) Para uma implementação eficiente do conjunto de encadeamentos, uma vez que os encadeamentos são criados de acordo com o Num_Threads, é melhor não criar novos ou destruir os antigos (ingressando). Haverá uma penalidade de desempenho, pode até tornar seu aplicativo mais lento que a versão serial.
Cada encadeamento C ++ 11 deve estar executando em sua função com um loop infinito, aguardando constantemente novas tarefas serem executadas.
Aqui está como anexar essa função ao pool de threads:
int Num_Threads = thread::hardware_concurrency();
vector<thread> Pool;
for(int ii = 0; ii < Num_Threads; ii++)
{ Pool.push_back(thread(Infinite_loop_function));}
3) A função Infinite_loop
Este é um loop "while (true)" aguardando a fila de tarefas
void The_Pool:: Infinite_loop_function()
{
while(true)
{
{
unique_lock<mutex> lock(Queue_Mutex);
condition.wait(lock, []{return !Queue.empty() || terminate_pool});
Job = Queue.front();
Queue.pop();
}
Job(); // function<void()> type
}
};
4) Crie uma função para adicionar trabalho à sua fila
void The_Pool:: Add_Job(function<void()> New_Job)
{
{
unique_lock<mutex> lock(Queue_Mutex);
Queue.push(New_Job);
}
condition.notify_one();
}
5) Vincule uma função arbitrária à sua fila
Pool_Obj.Add_Job(std::bind(&Some_Class::Some_Method, &Some_object));
Depois de integrar esses ingredientes, você terá seu próprio pool de segmentação dinâmico. Esses encadeamentos sempre são executados, aguardando a execução do trabalho.
Peço desculpas se houver algum erro de sintaxe, digitei esse código e tenho uma memória ruim. Lamento não poder fornecer o código completo do conjunto de encadeamentos, o que violaria a integridade do meu trabalho.
Edit: para finalizar o pool, chame o método shutdown ():
XXXX::shutdown(){
{
unique_lock<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 &every_thread : thread_vector)
{ every_thread.join();}
thread_vector.clear();
stopped = true; // use this flag in destructor, if not set, call shutdown()
}