怎么设置task的最大线程数

 //--------------------------------------------------------------------------
 //
 //  Copyright (c) Microsoft Corporation.  All rights reserved.
 //
 //  File: LimitedConcurrencyTaskScheduler.cs
 //
 //-------------------------------------------------------------------------- 
 
 using System.Collections.Generic;
 using System.Linq; 
 
 namespace System.Threading.Tasks.Schedulers
 {
     /// <summary>
     /// Provides a task scheduler that ensures a maximum concurrency level while
     /// running on top of the ThreadPool.
     /// </summary>
     public class LimitedConcurrencyLevelTaskScheduler : TaskScheduler
     {
         /// <summary>Whether the current thread is processing work items.</summary>
         [ThreadStatic]
         private static bool _currentThreadIsProcessingItems;
         /// <summary>The list of tasks to be executed.</summary>
         private readonly LinkedList<Task> _tasks = new LinkedList<Task>(); // protected by lock(_tasks)
         /// <summary>The maximum concurrency level allowed by this scheduler.</summary>
         private readonly int _maxDegreeOfParallelism;
         /// <summary>Whether the scheduler is currently processing work items.</summary>
         private int _delegatesQueuedOrRunning = ; // protected by lock(_tasks) 
 
         /// <summary>
         /// Initializes an instance of the LimitedConcurrencyLevelTaskScheduler class with the
         /// specified degree of parallelism.
         /// </summary>
         /// <param name="maxDegreeOfParallelism">The maximum degree of parallelism provided by this scheduler.</param>
         public LimitedConcurrencyLevelTaskScheduler(int maxDegreeOfParallelism)
         {
             if (maxDegreeOfParallelism < ) throw new ArgumentOutOfRangeException("maxDegreeOfParallelism");
             _maxDegreeOfParallelism = maxDegreeOfParallelism;
         } 
 
         /// <summary>Queues a task to the scheduler.</summary>
         /// <param name="task">The task to be queued.</param>
         protected sealed override void QueueTask(Task task)
         {
             // Add the task to the list of tasks to be processed.  If there aren't enough
             // delegates currently queued or running to process tasks, schedule another.
             lock (_tasks)
             {
                 _tasks.AddLast(task);
                 if (_delegatesQueuedOrRunning < _maxDegreeOfParallelism)
                 {
                     ++_delegatesQueuedOrRunning;
                     NotifyThreadPoolOfPendingWork();
                 }
             }
         } 
 
         /// <summary>
         /// Informs the ThreadPool that there's work to be executed for this scheduler.
         /// </summary>
         private void NotifyThreadPoolOfPendingWork()
         {
             ThreadPool.UnsafeQueueUserWorkItem(_ =>
             {
                 // Note that the current thread is now processing work items.
                 // This is necessary to enable inlining of tasks into this thread.
                 _currentThreadIsProcessingItems = true;
                 try
                 {
                     // Process all available items in the queue.
                     while (true)
                     {
                         Task item;
                         lock (_tasks)
                         {
                             // When there are no more items to be processed,
                             // note that we're done processing, and get out.
                             if (_tasks.Count == )
                             {
                                 --_delegatesQueuedOrRunning;
                                 break;
                             } 
 
                             // Get the next item from the queue
                             item = _tasks.First.Value;
                             _tasks.RemoveFirst();
                         } 
 
                         // Execute the task we pulled out of the queue
                         base.TryExecuteTask(item);
                     }
                 }
                 // We're done processing items on the current thread
                 finally { _currentThreadIsProcessingItems = false; }
             }, null);
         } 
 
         /// <summary>Attempts to execute the specified task on the current thread.</summary>
         /// <param name="task">The task to be executed.</param>
         /// <param name="taskWasPreviouslyQueued"></param>
         /// <returns>Whether the task could be executed on the current thread.</returns>
         protected sealed override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
         {
             // If this thread isn't already processing a task, we don't support inlining
             if (!_currentThreadIsProcessingItems) return false; 
 
             // If the task was previously queued, remove it from the queue
             if (taskWasPreviouslyQueued) TryDequeue(task); 
 
             // Try to run the task.
             return base.TryExecuteTask(task);
         } 
 
         /// <summary>Attempts to remove a previously scheduled task from the scheduler.</summary>
         /// <param name="task">The task to be removed.</param>
         /// <returns>Whether the task could be found and removed.</returns>
         protected sealed override bool TryDequeue(Task task)
         {
             lock (_tasks) return _tasks.Remove(task);
         } 
 
         /// <summary>Gets the maximum concurrency level supported by this scheduler.</summary>
         public sealed override int MaximumConcurrencyLevel { get { return _maxDegreeOfParallelism; } } 
 
         /// <summary>Gets an enumerable of the tasks currently scheduled on this scheduler.</summary>
         /// <returns>An enumerable of the tasks currently scheduled.</returns>
         protected sealed override IEnumerable<Task> GetScheduledTasks()
         {
             bool lockTaken = false;
             try
             {
                 Monitor.TryEnter(_tasks, ref lockTaken);
                 if (lockTaken) return _tasks.ToArray();
                 else throw new NotSupportedException();
             }
             finally
             {
                 if (lockTaken) Monitor.Exit(_tasks);
             }
         }
     }
 }

测试：

输出结果：

参考：

http://msdn.microsoft.com/en-us/library/ee789351(v=vs.110).aspx

https://social.msdn.microsoft.com/Forums/zh-CN/b02ba3b4-539b-46b7-af6b-a5ca3a61a309/task?forum=visualcshartzhchs

https://code.msdn.microsoft.com/Samples-for-Parallel-b4b76364/view/SourceCode#content