Multithreading 线程池（如boost）能否初始化为类构造函数并在调用类成员时使用？

假设我有一个线程池（示例可能是）； 我有这个密码：

class Demigod{ 
public:
   Demigod();
   void AskObedienceFast();
   void AskObedienceSlow();
   void WorkHardGodDamn();
   ~Demigod();
private:
   ThreadPool m_PitySlaves;
   int m_Quota;
};
Demigod::Demigod() : m_PitySlaves(manyPlease) { 
}
void Demigod::WorkHardGodDamn(){ 
    //something irelevant just to annoy slaves
}
void Demigod::AskObedienceFast() { 
    for(int q=0; q<m_Quota; ++q){
       m_PitySlaves.schedule(boost::bind(&Demigod::WorkHardGodDamn, this)); 
    }
    m_PitySlaves.wait();
}
void Demigod::AskObedienceSlow() { 
    ThreadPool poorSouls;
    for(int q=0; q<m_Quota; ++q){
       poorSouls.schedule(boost::bind(&Demigod::WorkHardGodDamn, this)); 
    }
    poorSouls.wait();
}
void main(){ 
   Demigod someDude;
   for(size_t i=0; i<dontstop; ++i){ 
      someDude.AskObedienceFast();
   }
}

半神类{
公众：
半神（）；
void AskObedienceFast（）；
无效Askobedinceslow（）；
无效的工作狂该死的（）；
~demigood（）；
私人：
ThreadPool m_PitySlaves；
国际货币单位配额；
};
半神：半神（）：m_可怜的奴隶（许多奴隶）{
}
void-Demigod:：workhardGoddom（）{
//只是为了激怒奴隶
}
void半神：：AskObedienceFast（）{
对于（int q=0；q来说，没有什么比“等待进程”更好的了。如果线程正在等待（在某个条件下），调度程序只是跳过它，因此这样的线程不会做任何事情，也不会被切换到其他线程。正如您非常正确地指出的，线程中最昂贵的任务是设置线程（尽管所有主要的操作系统都在采取措施尽可能地将其最小化，以跟上最近内核的倍增），紧随其后的是线程上下文的切换。因此，您可以了解为什么AskObedienceSlow

非常糟糕。您的临时设备应该只“便宜”结构，它需要尽可能少的时间来构建和销毁。

ThreadPool

肯定不是这样的结构。即使是

AskObedienceFast

也不能保护您免受上下文切换开销的影响，但这就是为什么较大的线程池并不总是更好的原因，最佳性能大小是一个仔细平衡依赖关系的问题降低您的实际工作量。出于这个原因，一些性能最好的高负载、高吞吐量应用程序是单线程、消息传递设计。用于此类应用程序的编程语言（如Erlang）与普通的foo、bar和baz相比，代码示例的创造性非常有趣。下一次迭代将实际阅读代码并试图理解问题：）谢谢，我可以做一点事情，让其他人没有时间思考我的问题：）感谢您告诉我没有等待进程。因此，避免初始化可能会导致性能的巨大损失，但您也仔细指出，拥有一个大的线程池有一个缺点，因为它们会在实际处理器上频繁切换并降低性能。但我会试着开始使用一个线程池ze=有多少个处理器。我会调查消息解析设计，因为我不知道。感谢处理器内核的数量是一个好的开始。对于消息传递（不是解析：-）和消息循环，您可以从Wikipedia开始。