标签: threadpool

在下面的代码中,由于接口,类LazyBar必须从它的方法返回一个任务(并且为了参数而不能更改).如果LazyBars的实现是不寻常的,那么它恰好快速且同步地运行 - 从方法返回No-Operation任务的最佳方法是什么？

我已经在Task.Delay(0)下面了,但是我想知道如果这个函数被调用了很多(如果参数起见,比如说每秒数百次),这是否有任何性能副作用:

• 这种语法糖会不会变成大事？
• 它是否开始堵塞应用程序的线程池？
• 编译器切割器是否足以以Delay(0)不同方式处理？
• 请问return Task.Run(() => { });有什么不同？

有没有更好的办法？

using System.Threading.Tasks;

namespace MyAsyncTest
{
    internal interface IFooFace
    {
        Task WillBeLongRunningAsyncInTheMajorityOfImplementations();
    }

    /// <summary>
    /// An implementation, that unlike most cases, will not have a long-running
    /// operation in 'WillBeLongRunningAsyncInTheMajorityOfImplementations'
    /// </summary>
    internal class LazyBar : IFooFace
    {
        #region IFooFace Members

        public Task WillBeLongRunningAsyncInTheMajorityOfImplementations()
        {
            // First, do something really quick
            var x = 1; …

我正在编写一个服务器,当请求传入时,我将每个动作分支到一个线程中.我这样做是因为几乎每个请求都进行数据库查询.我正在使用线程池库来减少线程的构造/销毁.

我的问题是 - 像这样的I/O线程有什么好的截止点？我知道这只是一个粗略的估计,但我们是在说几百个？成千上万的？

编辑:

谢谢大家的回复,似乎我只是要测试它以找出我的线程数上限.问题是:我怎么知道我达到了这个上限？究竟应该测量什么？

假设我有一个利用Executor框架的应用程序

Executors.newSingleThreadExecutor().submit(new Runnable(){
    @Override
    public void run(){
        // do stuff
    }
}

当我在调试器中运行此应用程序时,将使用以下(默认)名称创建一个线程:Thread[pool-1-thread-1].正如您所看到的,这不是非常有用,据我所知,该Executor框架没有提供一种简单的方法来命名创建的线程或线程池.

那么,如何为线程/线程池提供名称呢？例如,Thread[FooPool-FooThread].

等待ExecutorService完成所有任务的最简单方法是什么？我的任务主要是计算,所以我只想运行大量的工作 - 每个核心一个.现在我的设置如下:

ExecutorService es = Executors.newFixedThreadPool(2);
for (DataTable singleTable : uniquePhrases) {   
    es.execute(new ComputeDTask(singleTable));
}
try{
    es.wait();
} 
catch (InterruptedException e){
    e.printStackTrace();
}

ComputeDTask实现runnable.这似乎正确执行任务,但代码崩溃wait()了IllegalMonitorStateException.这很奇怪,因为我玩了一些玩具示例,它似乎工作.

uniquePhrases包含数万个元素.我应该使用其他方法吗？我正在寻找尽可能简单的东西

使用新线程和使用线程池中的线程有什么区别？有什么性能优势,为什么我应该考虑使用池中的线程而不是我明确创建的线程？我在这里专门讨论.NET,但一般的例子很好.

我有一个固定的线程池,我提交任务(限于5个线程).如何找出这5个线程中的哪一个执行我的任务(类似"线程#3 of 5正在执行此任务")？

ExecutorService taskExecutor = Executors.newFixedThreadPool(5);

//in infinite loop:
taskExecutor.execute(new MyTask());
....

private class MyTask implements Runnable {
    public void run() {
        logger.debug("Thread # XXX is doing this task");//how to get thread id?
    }
}

我一直在尝试用C#学习多线程编程,我很困惑什么时候最好使用线程池而不是创建我自己的线程.一本书建议仅为小任务使用线程池(无论这意味着什么),但我似乎无法找到任何真正的指导方针.在做出此编程决策时,您使用了哪些注意事项？

相关问题:

关于C++ 11:

• C++ 11:std :: thread汇集了吗？
• C++ 11中的async(launch :: async)是否会使线程池过时以避免昂贵的线程创建？

关于Boost:

• C++提升线程重用线程
• boost :: thread并创建它们的池!

我如何获得一个线程池,以任务发送到,而无需创建和删除它们一遍又一遍？这意味着要在不加入的情况下重新同步的持久线程.

我的代码看起来像这样:

namespace {
  std::vector<std::thread> 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 < 8; ++i) { // for 8 iterations,
    for (int j = 0; j < 4; ++j) {
      workers.push_back(std::thread(each_thread_does, j));
    }
    for (std::thread &t: …

我一直认为使用ThreadPool(比如说非关键的)短期背景任务被认为是最佳实践,即使在ASP.NET中也是如此,但后来我发现这篇文章似乎暗示了其他 -这个论点是你应该离开ThreadPool来处理ASP.NET相关的请求.

所以这就是我到目前为止一直在做的小异步任务:

ThreadPool.QueueUserWorkItem(s => PostLog(logEvent))

而且文章建议明确地创建一个线程,类似于:

new Thread(() => PostLog(logEvent)){ IsBackground = true }.Start()

第一种方法具有管理和限制的优点,但是有可能(如果文章是正确的)后台任务正在争夺具有ASP.NET请求处理程序的线程.第二种方法释放了ThreadPool,但代价是无限制,因此可能耗尽太多资源.

所以我的问题是,文章中的建议是否正确？

如果你的网站流量太大而你的ThreadPool已经满了,那么最好是带外,还是一个完整的ThreadPool意味着你无论如何都要达到你的资源限制,在这种情况下你不应该试图开始自己的线程？

澄清:我只是询问小型非关键异步任务(例如,远程日志记录)的范围,而不是需要单独过程的昂贵工作项(在这些情况下,我同意您需要更强大的解决方案).

它与这个问题松散相关:std :: thread是否在C++ 11中汇集？.虽然问题不同,但意图是一样的:

问题1:使用您自己的(或第三方库)线程池以避免昂贵的线程创建仍然有意义吗？

另一个问题的结论是你不能依赖于std::thread汇集(可能或可能不是).但是,std::async(launch::async)似乎有更高的机会被汇集.

它不认为它是由标准强制,但恕我直言,如果线程创建缓慢,我会期望所有好的C++ 11实现都会使用线程池.只有在创建新线程成本低廉的平台上,我才会期望它们总是产生一个新线程.

问题2:这正是我的想法,但我没有事实证明这一点.我很可能会弄错.这是一个有根据的猜测吗？

最后,在这里我提供了一些示例代码,首先展示了我认为线程创建如何表达async(launch::async):

例1:

 thread t([]{ f(); });
 // ...
 t.join();

变

 auto future = async(launch::async, []{ f(); });
 // ...
 future.wait();

示例2:消防和遗忘线程

 thread([]{ f(); }).detach();

变

 // a bit clumsy...
 auto dummy = async(launch::async, []{ f(); });

 // ... but I hope soon it can be simplified to
 async(launch::async, []{ f(); });

问题3:您希望async版本的thread版本？

其余的不再是问题的一部分,只是为了澄清:

为什么必须将返回值赋给虚拟变量？

不幸的是,当前的C++ 11标准强制您捕获返回值std::async,否则执行析构函数,直到操作终止为止.有人认为这是标准中的一个错误(例如,Herb Sutter). …