我正在使用 TPL 使用函数向系统线程池添加新任务Task.Factory.StartNew()。唯一的问题是我添加了很多线程，我认为它为我的处理器创建了太多的线程来处理。有没有办法在这个线程池中设置最大线程数？
问问题
16337 次
4 回答
16
默认值TaskScheduler（从 获得TaskScheduler.Default）是类型（内部类）ThreadPoolTaskScheduler。此实现使用ThreadPool该类来对任务进行排队（如果Task不是使用TaskCreationOptions.LongRunning- 在这种情况下为每个任务创建一个新线程）。
所以，如果你想限制Task通过创建的对象可用的new Task(() => Console.WriteLine("In task"))线程数，你可以像这样限制全局线程池中的可用线程：
// Limit threadpool size
int workerThreads, completionPortThreads;
ThreadPool.GetMaxThreads(out workerThreads, out completionPortThreads);
workerThreads = 32;
ThreadPool.SetMaxThreads(workerThreads, completionPortThreads);
调用 toThreadPool.GetMaxThreads()是为了避免缩小completionPortThreads.
请注意，这可能是个坏主意——因为所有没有指定调度程序的任务以及任何数量的其他类都使用默认的 ThreadPool，将大小设置得太低可能会导致副作用：饥饿等。
于 2012-08-09T07:43:06.800 回答
7
通常 TPL 确定一个好的“默认”线程池大小。如果您确实需要更少的线程，请参阅如何：创建限制并发程度的任务计划程序
于 2012-06-17T23:49:53.853 回答
4
您应该首先调查您的性能问题。有多种问题可能会导致利用率降低：
- 在没有 LongRunningTask 选项的情况下安排长时间运行的任务
- 试图打开两个以上到同一个网址的并发连接
- 阻止访问同一资源
- 尝试使用 Invoke() 从多个线程访问 UI 线程
在任何情况下，您都存在无法通过减少并发任务数量来解决的可伸缩性问题。您的程序将来可能会在两核、四核或八核机器上运行。限制计划任务的数量只会导致 CPU 资源的浪费。
于 2012-06-19T07:58:10.137 回答
0
通常 TPL 调度程序应该很好地选择同时运行多少任务，但如果你真的想控制它我的博客文章展示了如何使用 Tasks 和 Actions 来做到这一点，并提供了一个示例项目，你可以下载并运行以查看两者的运行情况。
当您调用自己的服务并且不想使服务器超载时，您可能希望明确限制并发运行的任务数。
对于您所描述的内容，听起来您可能会从确保对任务使用 async/await 以防止不必要的线程消耗中受益更多。这将取决于您是在执行任务中的 CPU 密集型工作还是 IO 密集型工作。如果它受 IO 限制，那么您可能会从使用 async/await 中受益匪浅。
无论如何，您询问了如何限制并发运行的任务数量，所以这里有一些代码来展示如何使用 Actions 和 Tasks 来做到这一点。
有行动
如果使用 Actions，您可以使用内置的 .Net Parallel.Invoke 函数。在这里，我们将其限制为最多并行运行 3 个线程。
var listOfActions = new List<Action>();
for (int i = 0; i < 10; i++)
{
// Note that we create the Action here, but do not start it.
listOfActions.Add(() => DoSomething());
}
var options = new ParallelOptions {MaxDegreeOfParallelism = 3};
Parallel.Invoke(options, listOfActions.ToArray());
有任务
由于您在这里使用任务，因此没有内置功能。但是，您可以使用我在博客上提供的那个。
/// <summary>
/// Starts the given tasks and waits for them to complete. This will run, at most, the specified number of tasks in parallel.
/// <para>NOTE: If one of the given tasks has already been started, an exception will be thrown.</para>
/// </summary>
/// <param name="tasksToRun">The tasks to run.</param>
/// <param name="maxTasksToRunInParallel">The maximum number of tasks to run in parallel.</param>
/// <param name="cancellationToken">The cancellation token.</param>
public static void StartAndWaitAllThrottled(IEnumerable<Task> tasksToRun, int maxTasksToRunInParallel, CancellationToken cancellationToken = new CancellationToken())
{
StartAndWaitAllThrottled(tasksToRun, maxTasksToRunInParallel, -1, cancellationToken);
}
/// <summary>
/// Starts the given tasks and waits for them to complete. This will run, at most, the specified number of tasks in parallel.
/// <para>NOTE: If one of the given tasks has already been started, an exception will be thrown.</para>
/// </summary>
/// <param name="tasksToRun">The tasks to run.</param>
/// <param name="maxTasksToRunInParallel">The maximum number of tasks to run in parallel.</param>
/// <param name="timeoutInMilliseconds">The maximum milliseconds we should allow the max tasks to run in parallel before allowing another task to start. Specify -1 to wait indefinitely.</param>
/// <param name="cancellationToken">The cancellation token.</param>
public static void StartAndWaitAllThrottled(IEnumerable<Task> tasksToRun, int maxTasksToRunInParallel, int timeoutInMilliseconds, CancellationToken cancellationToken = new CancellationToken())
{
// Convert to a list of tasks so that we don't enumerate over it multiple times needlessly.
var tasks = tasksToRun.ToList();
using (var throttler = new SemaphoreSlim(maxTasksToRunInParallel))
{
var postTaskTasks = new List<Task>();
// Have each task notify the throttler when it completes so that it decrements the number of tasks currently running.
tasks.ForEach(t => postTaskTasks.Add(t.ContinueWith(tsk => throttler.Release())));
// Start running each task.
foreach (var task in tasks)
{
// Increment the number of tasks currently running and wait if too many are running.
throttler.Wait(timeoutInMilliseconds, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
task.Start();
}
// Wait for all of the provided tasks to complete.
// We wait on the list of "post" tasks instead of the original tasks, otherwise there is a potential race condition where the throttler's using block is exited before some Tasks have had their "post" action completed, which references the throttler, resulting in an exception due to accessing a disposed object.
Task.WaitAll(postTaskTasks.ToArray(), cancellationToken);
}
}
然后创建任务列表并调用函数让它们运行，一次最多同时运行 3 个，你可以这样做：
var listOfTasks = new List<Task>();
for (int i = 0; i < 10; i++)
{
var count = i;
// Note that we create the Task here, but do not start it.
listOfTasks.Add(new Task(() => Something()));
}
Tasks.StartAndWaitAllThrottled(listOfTasks, 3);
于 2017-06-06T04:26:01.277 回答