我现在用的是TPL添加新的任务系统线程池中使用的功能Task.Factory.StartNew() 唯一的问题是，我加入了很多的线程，我认为这是创造了太多我的处理器来处理。有没有一种方法来设置此线程池的最大线程数？

Answer 1:

默认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);

要将呼叫ThreadPool.GetMaxThreads()做是为了避免收缩completionPortThreads 。

请注意，这可能是一个坏主意 - 因为没有一个指定的调度程序的所有任务，以及任意数量的其他类使用默认的线程池，设置大小过低可能导致的副作用：饥饿等。

Answer 2:

通常TPL决定一个很好的“默认”线程池的大小。如果你真的需要较少的线程，请参见如何：创建一个任务计划，限制并发度

Answer 3:

你应该先调查你的性能问题。有迹象表明可能导致降低利用各种问题：

调度长时间运行的任务，而不LongRunningTask选项
试图打开相同的网址两个以上的并发连接
阻止访问同一资源
试图访问使用的invoke（）从多个线程UI线程

在任何情况下，你都不能减少的并发任务的数量只是解决的可扩展性问题。你的程序可以在双将来运行，四核或八核机。限制的计划任务数只会导致CPU资源的浪费。

Answer 4:

通常情况下，TPL调度应该做的选择多少任务同时运行的一个很好的工作，但如果你真的想拥有控制权我的博客文章显示了如何都与任务，并以行动做到这一点，并提供了一个示例项目，你可以下载并运行看都在行动。

当你可能需要明确限制多少任务同时运行的一个例子是，当你调用自己的服务，不想超载您的服务器。

对于你所描述的，这听起来像你可能会受益于确保您使用的是异步/与你的任务等待着，以防止不必要的线消耗量更多。这将取决于虽然在如果你是做CPU密集型的工作，或在你的任务IO限制的工作。如果它的IO绑定，那么您可以大大使用异步受益/等待。

无论如何，你问你如何限制同时运行的任务数，所以这里的一些代码来显示如何使用这两种行动和任务去做。

用行动

如果使用操作，您可以使用内置的.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&#39;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&#39;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);