3.1 简介
线程池主要用在需要大量短暂的开销大的资源的情形。我们预先分配一些资源在线程池当中，当我们需要使用的时候，直接从池中取出，代替了重新创建，不用时候就送回到池当中。
.NET当中的线程池是受CLR来管理的。
.NET线程池有一个QueueUserWorkItem()的静态方法，这个方法接收一个委托，每当该方法被调用后，委托进入内部的队列中，如果线程池当中没有任何线程，此时创建一个新的工作线程，并将队列的第一个委托放入到工作线程当中。
注意点：
①线程池内的操作，尽量放入短时间运行的工作
②ASP.NET应用程序使用线程池不要把工作线程全部使用掉，否则web服务器将不能处理新的请求。
ASP.NET只推荐使用输入/输出密集型异步操作，因为其使用了一个不同的方式，叫做I/O线程。
③线程池当中的线程全部是后台线程，因此要注意前台线程执行完成后，后台线程也将结束工作。
3.2线程池中调用委托
首先要了解一个什么是【异步编程模型（Asynchronous Programming Model简称APM）】
.NET 1.0 异步编程模型(APM),
.NET 2.0 基于事件的异步编程模型（EAP），
.NET 4.0 基于任务的异步编程模型（TAP）。
本章主要了解什么是APM和EAP。
下面这篇文章介绍了异步编程模型，感觉挺好的，这里mark一下。
http://blog.csdn.net/xinke453/article/details/37810823
结合我这本书上的Demo，感觉理解起来无鸭梨，哈哈~
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 int threadId = 0; 6 7 RunOnThreadPool poolDelegate = Test; 8 //用创建线程的方法先创建了一个线程 9 var t = new Thread(() => Test(out threadId)); 10 t.Start(); 11 t.Join(); 12 13 Console.WriteLine("Thread id: {0}", threadId); 14 15 /* 16 使用BeginInvoke来运行委托,Callback是一个回调函数， 17 "a delegate asynchronous call" 代表你希望转发给回调方法的一个对象的引用， 18 在回调方法中，可以查询IAsyncResult接口的AsyncState属性来访问该对象 19 */ 20 IAsyncResult r = poolDelegate.BeginInvoke(out threadId, Callback, "a delegate asynchronous call"); 21 //这个例子当中使用AsyncWaitHandle属性来等待直到操作完成★ 22 r.AsyncWaitHandle.WaitOne(); 23 //操作完成后，会得到一个结果，可以通过委托调用EndInvoke方法，将IAsyncResult对象传递给委托参数。 24 string result = poolDelegate.EndInvoke(out threadId, r); 25 26 Console.WriteLine("Thread pool worker thread id: {0}", threadId); 27 Console.WriteLine(result); 28 29 Thread.Sleep(TimeSpan.FromSeconds(2)); 30 } 31 32 private delegate string RunOnThreadPool(out int threadId); 33 34 private static void Callback(IAsyncResult ar) 35 { 36 Console.WriteLine("Starting a callback..."); 37 Console.WriteLine("State passed to a callbak: {0}", ar.AsyncState); 38 Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread); 39 Console.WriteLine("Thread pool worker thread id: {0}", Thread.CurrentThread.ManagedThreadId); 40 } 41 42 43 private static string Test(out int threadId) 44 { 45 Console.WriteLine("Starting..."); 46 Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread); 47 Thread.Sleep(TimeSpan.FromSeconds(2)); 48 threadId = Thread.CurrentThread.ManagedThreadId; 49 return string.Format("Thread pool worker thread id was: {0}", threadId);
注意：在这个例子当中，主线程调用Thread.Sleep(TimeSpan.FromSeconds(2));如果没这句话，回调函数就不会被执行了，
以为线程池是后台线程，此时主线程结束，那么后台线程也跟着结束了，所以可能不会执行。
对于访问异步操作的结果，APM提供了四种方式供开发人员选择：
①在调用BeginXxx方法的线程上调用EndXxx方法来得到异步操作的结果，但是这种方式会阻塞调用线程，知道操作完成之后调用线程才继续运行。
②查询IAsyncResult的AsyncWaitHandle属性，从而得到WaitHandle，然后再调用它的WaitOne方法来使一个线程阻塞并等待操作完成再调用EndXxx方法来获得操作的结果。
（本例子当中使用了这个方法）
③循环查询IAsyncResult的IsComplete属性，操作完成后再调用EndXxx方法来获得操作返回的结果。
④使用 AsyncCallback委托来指定操作完成时要调用的方法，在操作完成后调用的方法中调用EndXxx操作来获得异步操作的结果。
★★★推荐使用第④种方法，因为此时不会阻塞执行BeginXxx方法的线程，然而其他三种都会阻塞调用线程，相当于效果和使用同步方法是一样，个人感觉根本失去了异步编程的特点，所以其他三种方式可以简单了解下，在实际异步编程中都是使用委托的方式。
3.3向线程池中加入异步操作
QueueUserWorkItem方法的定义！
1 [SecuritySafeCritical] 2 public static bool QueueUserWorkItem(WaitCallback callBack);
1 [SecuritySafeCritical] 2 public static bool QueueUserWorkItem(WaitCallback callBack, object state);
实例: 1 class Program 2 { 3 static void Main(string[] args) 4 { 5 const int x = 1; 6 const int y = 2; 7 const string lambdaState = "lambda state 2"; 8 //方法一,直接调用QueueUserWorkItem传入单个参数，作为回调函数 9 ThreadPool.QueueUserWorkItem(AsyncOperation); 10 Thread.Sleep(TimeSpan.FromSeconds(1)); 11 12 //方法二，传入回调函数以及状态参数 13 ThreadPool.QueueUserWorkItem(AsyncOperation, "async state"); 14 Thread.Sleep(TimeSpan.FromSeconds(1)); 15 16 //方法三，使用labmbda表达式 17 ThreadPool.QueueUserWorkItem( state => { 18 Console.WriteLine("Operation state: {0}", state); 19 Console.WriteLine("Worker thread id: {0}", Thread.CurrentThread.ManagedThreadId); 20 Thread.Sleep(TimeSpan.FromSeconds(2)); 21 }, "lambda state"); 22 23 //方法四，使用闭包机制 24 ThreadPool.QueueUserWorkItem( _ => 25 { 26 Console.WriteLine("Operation state: {0}, {1}", x+y, lambdaState); 27 Console.WriteLine("Worker thread id: {0}", Thread.CurrentThread.ManagedThreadId); 28 Thread.Sleep(TimeSpan.FromSeconds(2)); 29 }, "lambda state"); 30 31 Thread.Sleep(TimeSpan.FromSeconds(2)); 32 } 33 34 private static void AsyncOperation(object state) 35 { 36 Console.WriteLine("Operation state: {0}", state ?? "(null)"); 37 Console.WriteLine("Worker thread id: {0}", Thread.CurrentThread.ManagedThreadId); 38 Thread.Sleep(TimeSpan.FromSeconds(2)); 39 }
扩展：C#闭包（Closure）机制是什么？
3.4线程池与并行度
下面这个实例展示线程池如何工作于大量异步操作，以及他和创建的大量单独线程方式的区别。
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 const int numberOfOperations = 500; 6 var sw = new Stopwatch(); 7 sw.Start(); 8 UseThreads(numberOfOperations); 9 sw.Stop(); 10 Console.WriteLine("Execution time using threads: {0}", sw.ElapsedMilliseconds); 11 12 sw.Reset(); 13 sw.Start(); 14 UseThreadPool(numberOfOperations); 15 sw.Stop(); 16 Console.WriteLine("Execution time using threads: {0}", sw.ElapsedMilliseconds); 17 } 18 19 static void UseThreads(int numberOfOperations) 20 { 21 using (var countdown = new CountdownEvent(numberOfOperations)) 22 { 23 Console.WriteLine("Scheduling work by creating threads"); 24 for (int i = 0; i < numberOfOperations; i++) 25 { 26 var thread = new Thread(() => { 27 Console.Write("{0},", Thread.CurrentThread.ManagedThreadId); 28 Thread.Sleep(TimeSpan.FromSeconds(0.1)); 29 countdown.Signal(); 30 }); 31 thread.Start(); 32 } 33 countdown.Wait(); 34 Console.WriteLine(); 35 } 36 } 37 38 static void UseThreadPool(int numberOfOperations) 39 { 40 using (var countdown = new CountdownEvent(numberOfOperations)) 41 { 42 Console.WriteLine("Starting work on a threadpool"); 43 for (int i = 0; i < numberOfOperations; i++) 44 { 45 ThreadPool.QueueUserWorkItem( _ => { 46 Console.Write("{0},", Thread.CurrentThread.ManagedThreadId); 47 Thread.Sleep(TimeSpan.FromSeconds(0.1)); 48 countdown.Signal(); 49 }); 50 } 51 countdown.Wait(); 52 Console.WriteLine(); 53 } 54 } 55 }
分别用创建大量线程的方式和线程池的方式执行500个Thread.Sleep(TimeSpan.FromSeconds(0.1))操作，
我们发现线程池花费了更多的时间，但是占用的资源数目很少（通过ThreadId来看）。
3.5实现一个取消选项
使用CancellationTokenSource和CancellationToken两个类来实现工作线程工作的取消操作。
实例： 1 class Program 2 { 3 static void Main(string[] args) 4 { 5 using (var cts = new CancellationTokenSource()) 6 { 7 CancellationToken token = cts.Token; 8 ThreadPool.QueueUserWorkItem(_ => AsyncOperation1(token)); 9 Thread.Sleep(TimeSpan.FromSeconds(2)); 10 cts.Cancel(); 11 } 12 13 using (var cts = new CancellationTokenSource()) 14 { 15 CancellationToken token = cts.Token; 16 ThreadPool.QueueUserWorkItem(_ => AsyncOperation2(token)); 17 Thread.Sleep(TimeSpan.FromSeconds(2)); 18 cts.Cancel(); 19 } 20 21 using (var cts = new CancellationTokenSource()) 22 { 23 CancellationToken token = cts.Token; 24 ThreadPool.QueueUserWorkItem(_ => AsyncOperation3(token)); 25 Thread.Sleep(TimeSpan.FromSeconds(2)); 26 cts.Cancel(); 27 } 28 29 Thread.Sleep(TimeSpan.FromSeconds(2)); 30 } 31 32 /// <summary> 33 /// 第一种采用轮询IsCancellationRequested属性的方式，如果为true，那么操作被取消 34 /// </summary> 35 /// <param name="token"></param> 36 static void AsyncOperation1(CancellationToken token) 37 { 38 Console.WriteLine("Starting the first task"); 39 for (int i = 0; i < 5; i++) 40 { 41 if (token.IsCancellationRequested) 42 { 43 Console.WriteLine("The first task has been canceled."); 44 return; 45 } 46 Thread.Sleep(TimeSpan.FromSeconds(1)); 47 } 48 Console.WriteLine("The first task has completed succesfully"); 49 } 50 /// <summary> 51 /// 抛出一个OperationCancelledException异常 52 /// 这个允许操作之外控制取消过程，即需要取消操作的时候，通过操作之外的代码来处理 53 /// </summary> 54 /// <param name="token"></param> 55 static void AsyncOperation2(CancellationToken token) 56 { 57 try 58 { 59 Console.WriteLine("Starting the second task"); 60 61 for (int i = 0; i < 5; i++) 62 { 63 token.ThrowIfCancellationRequested(); 64 Thread.Sleep(TimeSpan.FromSeconds(1)); 65 } 66 Console.WriteLine("The second task has completed succesfully"); 67 } 68 catch (OperationCanceledException) 69 { 70 Console.WriteLine("The second task has been canceled."); 71 } 72 } 73 /// <summary> 74 /// 第三种注册一个回调函数，当操作被取消时候，调用回调函数 75 /// </summary> 76 /// <param name="token"></param> 77 private static void AsyncOperation3(CancellationToken token) 78 { 79 bool cancellationFlag = false; 80 token.Register(() => cancellationFlag = true); 81 Console.WriteLine("Starting the third task"); 82 for (int i = 0; i < 5; i++) 83 { 84 if (cancellationFlag) 85 { 86 Console.WriteLine("The third task has been canceled."); 87 return; 88 } 89 Thread.Sleep(TimeSpan.FromSeconds(1)); 90 } 91 Console.WriteLine("The third task has completed succesfully"); 92
CancellationTokenSource和CancellationToken两个类是.net4.0一会引入的，目前是实现异步操作取消事实标准。
3.6在线程池中使用等待事件处理器和超时
使用线程池当中的Threadpool.RegisterWaitSingleObject类来进行事件案处理。
RegisterWaitSingleObject的原型如下：
1 public static RegisteredWaitHandle RegisterWaitForSingleObject( 2 WaitHandle waitObject, 3 WaitOrTimerCallback callBack, 4 Object state, 5 int millisecondsTimeOutInterval, 6 bool executeOnlyOnce 7 )
参数
waitObject
要注册的 WaitHandle。使用 WaitHandle 而非 Mutex。
callBack
waitObject 参数终止时调用的 WaitOrTimerCallback 委托。
state
传递给委托的对象。
timeout
TimeSpan 表示的超时时间。如果 timeout 为零，则函数测试对象的状态并立即返回。如果 timeout 为 -1，则函数的超时间隔永远不过期。
executeOnlyOnce
如果为 true，表示在调用了委托后，线程将不再在 waitObject 参数上等待；如果为 false，表示每次完成等待操作后都重置计时器，直到注销等待。
返回值
封装本机句柄的 RegisteredWaitHandle。
相信看了这些之后大家还是一头雾水，这个方法的做用是向线程池添加一个可以定时执行的方法，第四个参数millisecondsTimeOutInterval 就是用来设置间隔执行的时间，但是这里第五个参数executeOnlyOnce 会对第四个参数起作用，当它为true时，表示任务仅会执行一次，就是说它不会，像Timer一样，每隔一定时间执行一次，这个功能的话用Timer控件也可以实现
该方法还在此基础上提供了基于信号量来触发执行任务。
信号量也叫开关量，故名思议，它只有两种状态，不是true就是false,
WaitHandle就是这类开关量的基础类，继承它的类有Mutex,ManualResetEvent,AutoResetEvent,一般我们使用后两个
写法:
static ManualResetEvent wait2=new ManualResetEvent(false);
static AutoResetEvent wait=new AutoResetEvent(false);
我们可以在将其实例化时指定开关量的初始值。（true为有信号，false为没信号）
ManualResetEvent和AutoResetEvent的区别在于：
前者调用Set方法后将自动将开关量值将一直保持为true,后者调用Set方法将变为true随后立即变为false,可以将它理解为一个脉冲。
例子 1 class Program 2 { 3 static void Main(string[] args) 4 { 5 //执行两次RunOperations操作，第一次会超时，第二次不会超时 6 RunOperations(TimeSpan.FromSeconds(5)); 7 RunOperations(TimeSpan.FromSeconds(7)); 8 } 9 10 static void RunOperations(TimeSpan workerOperationTimeout) 11 { 12 //定义一个ManualResetEvent信号量，初始为false 13 using (var evt = new ManualResetEvent(false)) 14 //实例化一个CancellationTokenSource实例，用于取消操作 15 using (var cts = new CancellationTokenSource()) 16 { 17 Console.WriteLine("Registering timeout operations..."); 18 //注册超时的被调用的回调函数。 19 var worker = ThreadPool.RegisterWaitForSingleObject( 20 evt, 21 (state, isTimedOut) => WorkerOperationWait(cts, isTimedOut), 22 null, 23 workerOperationTimeout, 24 true ); 25 26 Console.WriteLine("Starting long running operation..."); 27 //线程池执行WorkerOperation操作 28 ThreadPool.QueueUserWorkItem(_ => WorkerOperation(cts.Token, evt)); 29 30 Thread.Sleep(workerOperationTimeout.Add(TimeSpan.FromSeconds(2))); 31 worker.Unregister(evt); 32 } 33 } 34 35 /// <summary> 36 /// 线程池内需要被调用的操作 37 /// </summary> 38 /// <param name="token"></param> 39 /// <param name="evt"></param> 40 static void WorkerOperation(CancellationToken token, ManualResetEvent evt) 41 { 42 for(int i = 0; i < 6; i++) 43 { 44 if (token.IsCancellationRequested) 45 { 46 return; 47 } 48 Thread.Sleep(TimeSpan.FromSeconds(1)); 49 } 50 //设置信号量，此时evt为true。 51 evt.Set(); 52 } 53 54 /// <summary> 55 /// 超时时候执行的回调函数 56 /// </summary> 57 /// <param name="cts"></param> 58 /// <param name="isTimedOut"></param> 59 static void WorkerOperationWait(CancellationTokenSource cts, bool isTimedOut) 60 { 61 if (isTimedOut) 62 { 63 cts.Cancel(); 64 Console.WriteLine("Worker operation timed out and was canceled."); 65 } 66 else 67 { 68 Console.WriteLine("Worker operation succeded."); 69 } 70
3.7在线程池中使用计时器
使用system.Threading.Timer对象来在线程池中创建周期性调用的异步操作。
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 Console.WriteLine("Press 'Enter' to stop the timer..."); 6 DateTime start = DateTime.Now; 7 //实例化这个timer类 8 //一秒后执行TimerOperation这个操作，然后每隔2秒执行一次 9 _timer = new Timer( 10 _ => TimerOperation(start), 11 null, 12 TimeSpan.FromSeconds(1), 13 TimeSpan.FromSeconds(2)); 14 15 Thread.Sleep(TimeSpan.FromSeconds(6)); 16 17 //改变计时器的运行时间，一秒后执行TimerOperation，然后每隔4秒执行一次 18 _timer.Change(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(4)); 19 20 Console.ReadLine(); 21 22 _timer.Dispose(); 23 } 24 25 static Timer _timer; 26 27 static void TimerOperation(DateTime start) 28 { 29 TimeSpan elapsed = DateTime.Now - start; 30 Console.WriteLine("{0} seconds from {1}. Timer thread pool thread id: {2}", elapsed.Seconds, start, 31 Thread.CurrentThread.ManagedThreadId); 32 } 33
3.8使用BackgroudWorker组件
本小节将介绍一个异步编程模式的另一种方式，叫基于事件的异步模式（EAP）
先看一个例子吧：
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 //实例化一个BackgroundWorker类 6 var bw = new BackgroundWorker(); 7 //获取或设置一个值，该值指示 BackgroundWorker 能否报告进度更新。 8 bw.WorkerReportsProgress = true; 9 //设置后台工作线程是否支持取消操作 10 bw.WorkerSupportsCancellation = true; 11 12 //给DoWork、ProgressChanged、RunWorkerCompleted事件绑定处理函数 13 bw.DoWork += Worker_DoWork; 14 bw.ProgressChanged += Worker_ProgressChanged; 15 bw.RunWorkerCompleted += Worker_Completed; 16 17 //启动异步操作 18 bw.RunWorkerAsync(); 19 20 Console.WriteLine("Press C to cancel work"); 21 do 22 { 23 if (Console.ReadKey(true).KeyChar == 'C') 24 { 25 //取消操作 26 bw.CancelAsync(); 27 } 28 29 } 30 while(bw.IsBusy); 31 } 32 33 static void Worker_DoWork(object sender, DoWorkEventArgs e) 34 { 35 Console.WriteLine("DoWork thread pool thread id: {0}", Thread.CurrentThread.ManagedThreadId); 36 var bw = (BackgroundWorker) sender; 37 for (int i = 1; i <= 100; i++) 38 { 39 40 if (bw.CancellationPending) 41 { 42 e.Cancel = true; 43 return; 44 } 45 46 if (i%10 == 0) 47 { 48 bw.ReportProgress(i); 49 } 50 51 Thread.Sleep(TimeSpan.FromSeconds(0.1)); 52 } 53 e.Result = 42; 54 } 55 56 static void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e) 57 { 58 Console.WriteLine("{0}% completed. Progress thread pool thread id: {1}", e.ProgressPercentage, 59 Thread.CurrentThread.ManagedThreadId); 60 } 61 62 static void Worker_Completed(object sender, RunWorkerCompletedEventArgs e) 63 { 64 Console.WriteLine("Completed threadpool thread id:{0}",Thread.CurrentThread.ManagedThreadId); 65 if (e.Error != null) 66 { 67 Console.WriteLine("Exception {0} has occured.", e.Error.Message); 68 } 69 else if (e.Cancelled) 70 { 71 Console.WriteLine("Operation has been canceled."); 72 } 73 else 74 { 75 Console.WriteLine("The answer is: {0}", e.Result); 76 } 77 }
事件
|
| 名称 | 说明 |
|
| ||
|
| 调用 RunWorkerAsync 时发生。 RunWorkerAsync 方法提交一个启动以异步方式运行的操作的请求。发出该请求后，将引发 DoWork 事件，该事件随后开始执行后台操作。 如果后台操作已在运行，则再次调用 RunWorkerAsync 将引发 InvalidOperationException。 | |
|
| 调用 ReportProgress 时发生。 public void ReportProgress ( percentProgress 已完成的后台操作所占的百分比，范围从 0% 到 100%。 如果您需要后台操作报告其进度，则可以调用 ReportProgress 方法来引发 ProgressChanged 事件。 WorkerReportsProgress 属性值必须是 true，否则 ReportProgress 将引发 InvalidOperationException。 您需要实现一个有意义的方法，以便按照占已完成的总任务的百分比来度量后台操作的进度。 对 ReportProgress 方法的调用为异步且立即返回。The ProgressChanged 事件处理程序在创建 BackgroundWorker 的线程上执行。 | |
|
| 当后台操作已完成、被取消或引发异常时发生。 | |
|
|
| 在该方法中可以知道操作是成功完成还是发生错误，亦或被取消。 |
貼り付け元 <https://msdn.microsoft.com/zh-cn/library/system.componentmodel.backgroundworker.aspx>
成功完成的时候
任务取消的时候
172
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
