C#多线程之线程池篇2

　　在上一篇C#多线程之线程池篇1中，我们主要学习了如何在线程池中调用委托以及如何在线程池中执行异步操作，在这篇中，我们将学习线程池和并行度、实现取消选项的相关知识。

三、线程池和并行度

　　在这一小节中，我们将学习对于大量的异步操作，使用线程池和分别使用单独的线程在性能上有什么差异性。具体操作步骤如下：

1、使用Visual Studio 2015创建一个新的控制台应用程序。

2、双击打开“Program.cs”文件，编写代码如下所示：

 using System;
 using System.Diagnostics;
 using System.Threading;
 using static System.Console;
 using static System.Threading.Thread;

 namespace Recipe03
 {
     class Program
     {
         static void UseThreads(int numberOfOperations)
         {
             using(var countdown=new CountdownEvent(numberOfOperations))
             {
                 WriteLine("Scheduling work by creating threads");
                 for(int i = ; i < numberOfOperations; i++)
                 {
                     var thread = new Thread(() =>
                       {
                           Write($"{CurrentThread.ManagedThreadId},");
                           Sleep();
                           countdown.Signal();
                       });
                     thread.Start();
                 }
                 countdown.Wait();
                 WriteLine();
             }
         }

         static void UseThreadPool(int numberOfOperations)
         {
             using(var countdown=new CountdownEvent(numberOfOperations))
             {
                 WriteLine("Starting work on a threadpool");
                 for(int i = ; i < numberOfOperations; i++)
                 {
                     ThreadPool.QueueUserWorkItem(_ =>
                     {
                         Write($"{CurrentThread.ManagedThreadId},");
                         Sleep();
                         countdown.Signal();
                     });
                 }
                 countdown.Wait();
                 WriteLine();
             }
         }

         static void Main(string[] args)
         {
             const int numberOfOperations = ;
             var sw = new Stopwatch();
             sw.Start();
             UseThreads(numberOfOperations);
             sw.Stop();
             WriteLine($"Execution time using threads: {sw.ElapsedMilliseconds}");

             sw.Reset();
             sw.Start();
             UseThreadPool(numberOfOperations);
             sw.Stop();
             WriteLine($"Execution time using the thread pool: {sw.ElapsedMilliseconds}");
         }
     }
 }

3、运行该控制台应用程序，运行效果（每次运行效果可能不同）如下图所示：

　　在上述代码中，我们首先创建了500个线程来执行异步操作，我们发现使用每个单独的线程执行异步操作所消耗的时间为175毫秒。然后我们使用线程池来执行500个异步操作，我们发现所消耗的时间为9432毫秒。这说明使用线程池来执行大并发的异步操作会节省操作系统的内存和线程数，但是会严重影响应用程序的性能。

四、实现取消选项

　　在这一小节中，我们将学习如何在线程池中取消一个异步操作。具体步骤如下所示：

1、使用Visual Studio 2015创建一个新的控制台应用程序。

2、双击打开“Program.cs”文件，编写代码如下所示：

 using System;
 using System.Threading;
 using static System.Console;
 using static System.Threading.Thread;

 namespace Recipe04
 {
     class Program
     {
         // CancellationToken：传播有关应取消操作的通知。
         static void AsyncOperation1(CancellationToken token)
         {
             WriteLine("Starting the first task");
             for (int i = ; i < ; i++)
             {
                 // IsCancellationRequested：获取是否已请求取消此标记。
                 // 如果已请求取消此标记，则为 true，否则为 false。
                 if (token.IsCancellationRequested)
                 {
                     WriteLine("The first task has been canceled.");
                     return;
                 }
                 Sleep(TimeSpan.FromSeconds());
             }
             WriteLine("The first task has completed succesfully");
         }

         static void AsyncOperation2(CancellationToken token)
         {
             try
             {
                 WriteLine("Starting the second task");
                 for (int i = ; i < ; i++)
                 {
                     // 如果已请求取消此标记，则引发 System.OperationCanceledException。
                     token.ThrowIfCancellationRequested();
                     Sleep(TimeSpan.FromSeconds());
                 }
                 WriteLine("The second task has completed succesfully");
             }
             catch (OperationCanceledException)
             {
                 WriteLine("The second task has been canceled.");
             }
         }

         static void AsyncOperation3(CancellationToken token)
         {
             bool cancellationFlag = false;
             // 注册一个将在取消此 System.Threading.CancellationToken 时调用的委托。
             // Register的参数是一个Action类型的委托，该委托在取消 System.Threading.CancellationToken 时执行
             token.Register(() => cancellationFlag = true);
             WriteLine("Starting the third task");
             for (int i = ; i < ; i++)
             {
                 if (cancellationFlag)
                 {
                     WriteLine("The third task has been canceled.");
                     return;
                 }
                 Sleep(TimeSpan.FromSeconds());
             }
             WriteLine("The third task has completed succesfully");
         }

         static void Main(string[] args)
         {
             // CancellationTokenSource：通知 System.Threading.CancellationToken，告知其应被取消。
             using (var cts = new CancellationTokenSource())
             {
                 // 获取与此 System.Threading.CancellationTokenSource 关联的 System.Threading.CancellationToken。
                 CancellationToken token = cts.Token;
                 ThreadPool.QueueUserWorkItem(_ => AsyncOperation1(token));
                 Sleep(TimeSpan.FromSeconds());
                 // 传达取消请求。
                 cts.Cancel();
             }

             // CancellationTokenSource：通知 System.Threading.CancellationToken，告知其应被取消。
             using (var cts = new CancellationTokenSource())
             {
                 // 获取与此 System.Threading.CancellationTokenSource 关联的 System.Threading.CancellationToken。
                 CancellationToken token = cts.Token;
                 ThreadPool.QueueUserWorkItem(_ => AsyncOperation2(token));
                 Sleep(TimeSpan.FromSeconds());
                 // 传达取消请求。
                 cts.Cancel();
             }

             // CancellationTokenSource：通知 System.Threading.CancellationToken，告知其应被取消。
             using (var cts = new CancellationTokenSource())
             {
                 // 获取与此 System.Threading.CancellationTokenSource 关联的 System.Threading.CancellationToken。
                 CancellationToken token = cts.Token;
                 ThreadPool.QueueUserWorkItem(_ => AsyncOperation3(token));
                 Sleep(TimeSpan.FromSeconds());
                 // 传达取消请求。
                 cts.Cancel();
             }

             Sleep(TimeSpan.FromSeconds());
         }
     }
 }

3、运行该控制台应用程序，运行效果如下图所示：

　　在上述代码中，我们使用了CancellationTokenSource和CancellationToken类，这两个类在.NET 4.0引入，现在已经成为取消异步操作事实上的标准。

　　在“AsyncOperation1”方法中，我们仅仅是轮询检查“CancellationToken.IsCancellationRequested”属性，如果该属性为true，这意味着我们的操作已被取消，我们必须放弃此次操作。

　　在“AsyncOperation2”方法中，我们调用CancellationToken的“ThrowIfCancellationRequested”方法来检查操作是否已被取消，如果已被取消，该方法会抛出OperationCanceledException异常，我们使用try/catch块捕获这个异常来中止异步操作的执行。

　　在“AsyncOperation3”方法中，我们调用CancellationToken的“Register”方法来注册一个异步操作被取消时被调用的回调方法。这种方式可以允许我们将取消操作的逻辑链接到另一个异步操作中。