多任务减慢

问题描述

中的代码：

 静态无效DOIT（字符串名称）
 {
 Console.WriteLine（ 你好{0} | {1}，名称，Thread.CurrentThread.ManagedThreadID）; 
 Thread.sleep代码（5000）; 
 Console.WriteLine（再见{0} | {1}，名称，Thread.CurrentThread.ManagedThreadID）; 
} 
 
静态无效的主要（）
 {
 Task.Factory.StartNew（（）=> DOIT（1））; 
 Task.Factory.StartNew（（）=> DOIT（二））; 
 Task.Factory.StartNew（（）=> DOIT（三国））; 
 Task.Factory.StartNew（（）=> DOIT（四））; 
 Task.Factory.StartNew（（）=> DOIT（五））; 
 Task.Factory.StartNew（（）=> DOIT（六个一））; 
 Task.Factory.StartNew（（）=> DOIT（七））; 
 Task.Factory.StartNew（（）=> DOIT（八））; 
 Task.Factory.StartNew（（）=> DOIT（九））; 
 Task.Factory.StartNew（（）=> DOIT（十大））; 
 
 Console.ReadKey（）; 
} 
  

为什么它可以精确立即开始前3个任务，但随后需要5-10sec任务4开局，任务4开始后，再前任务5开工等需要5-10sec。难道这就是做事的GC？可能有人请澄清发生了什么？

解决方案

By default, the first time you run this, the ThreadPool is allocated using the minimum number of worker threads. After the first 4 tasks are scheduled, the threadpool will "ramp up" to handle more over time, which is why you see the delay.

On my system (which has 8 cores), the first 8 are instantanteous, then the next two start up one second later.

In your case, if you run your test two times, the second time, the threads will all start up immediately. This is because, after the first run, the ThreadPool should have enough workers to schedule this right away.

Try the following to see this behavior in action. If you leave the SetMinThreads call in place, these will all schedule immediately. If you comment it out, you'll see that, the first time, it takes a while, but the second time through (provided you wait for the threads to complete), the threads will run immediately.

static void DoIt(string name)
{
    Console.WriteLine("Hello {0} | {1} - {2}", name, Thread.CurrentThread.ManagedThreadId, DateTime.Now);
    Thread.Sleep(5000);
    Console.WriteLine("Bye {0} | {1} - {2}", name, Thread.CurrentThread.ManagedThreadId, DateTime.Now);
}

static void Main()
{
    int workerThreads, complete;
    ThreadPool.GetMinThreads(out workerThreads, out complete);

    Console.WriteLine(workerThreads);

    // Comment out this line to see the difference...
    // WIth this commented out, the second iteration will be immediate
    ThreadPool.SetMinThreads(100, complete);

    Action run = () =>
        {
            for (int i = 0; i < 20; ++i)
            {
                int tmp = i;
                Task.Factory.StartNew(() => DoIt(tmp.ToString()));
            }
        };

    run();
    Console.WriteLine("Press a key to run again...");
    Console.ReadKey();

    run();

    Console.WriteLine("Press a key to exit...");
    Console.ReadKey();
}

Note that this behavior actually has little to do with the TPL as a whole - it's more the default TaskScheduler used which just passes off the tasks to the ThreadPool. If you were to set these threads up with the LongRunning hint in your StartNew() call, for example, they'd all start immediately (since the default scheduler will setup a new, dedicated thread and execute it immediately).

这篇关于多任务减慢的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！