[转]C#综合揭秘——细说三八线程(上)

引言

正文主要从线程的底子用法,CLR线程池当中工小编线程与I/O线程的开发,并行操作PLINQ等七个地点介绍二十四线程的花费。
其中委托的BeginInvoke方法以及回调函数最为常用。 而
I/O线程可能不难蒙受大家的疏忽,其实在支付三十六线程系统,更应该多留意I/O线程的操作。更加是在ASP.NET开发当中,可能更加多少人只会专注在客户端应用Ajax或者在劳动器端使用UpdatePanel。其实合情合理施用I/O线程在广播发布项目或文件下载时,能尽量地回落IIS的压力。
并行编程是Framework4.0中着力推广的异步操作方法,更值得更深刻地读书。
希望本篇小说能对各位的上学商量具有帮忙,当中有所错漏的地点敬请点评。

 

 

目录

一、线程的概念

二、线程的基础知识

三、以ThreadStart方式贯彻多线程

四、CLR线程池的劳动力线程

五、CLR线程池的I/O线程

六、异步
SqlCommand

七、并行编程与PLINQ

八、计时器与锁

 

 

 

 

一、线程的概念

 1. 1 历程、应用程序域与线程的涉嫌

经过(Process)是Windows系统中的一个基本概念,它含有着一个运行程序所急需的资源。进度之间是绝对独立的,一个经过不能访问另一个历程的数目(除非动用分布式总结格局),一个进程运行的战败也不会潜移默化其余进程的运行,Windows系统就是选用进度把工作划分为四个单身的区域的。进度可以驾驭为一个程序的主导边界。

选拔程序域(AppDomain)是一个程序运行的逻辑区域,它可以视为一个轻量级的经过,.NET的次第集正是在应用程序域中运行的,一个经过可以涵盖有五个使用程序域,一个拔取程序域也可以包涵八个程序集。在一个施用程序域中包括了一个或多个左右文context,使用前后文CLR就可以把一些特殊对象的意况放置在不一样容器当中。

线程(Thread)是进程中的基本举办单元,在经过入口实施的首先个线程被视为那几个进度的主线程。在.NET应用程序中,都是以Main()方法作为入口的,当调用此措施时系统就会自动创立一个主线程。线程重若是由CPU寄存器、调用栈和线程本地存储器(Thread
Local
Storage,TLS)组成的。CPU寄存器首要记录当前所推行线程的景况,调用栈首要用于保证线程所调用到的内存与数码,TLS主要用以存放线程的场所消息。

进程、应用程序域、线程的关联如下图,一个进度内可以包含多少个使用程序域,也有囊括七个线程,线程也得以持续于七个利用程序域当中。但在同一个整日,线程只会处在一个行使程序域内。

 

图片 1

 
由于本文是以介绍多线程技术为大旨,对进程、应用程序域的牵线就到此截止。关于进度、线程、应用程序域的技术,在“C#归结揭秘——细说进度、应用程序域与上下文”会有详细介绍。

 

1.2 多线程

在单CPU系统的一个单位时间(time
slice)内,CPU只能够运行单个线程,运行顺序取决于线程的预先级别。如若在单位时间内线程未能形成实施,系统就会把线程的图景音信保存到线程的本土存储器(TLS)
中,以便下次执行时上升执行。而十二线程只是系统带来的一个假像,它在几个单位时间内展开八个线程的切换。因为切换频密而且单位时间非凡短暂,所以三四线程可被看做同时运行。

适合选取八线程能狠抓系统的性质,比如:在系统请求大容量的多寡时利用八线程,把数量输出工作付出异步线程,使主线程保持其安静去处理任何难点。但须要注意一点,因为CPU必要开支不少的时光在线程的切换上,所以重重地利用八线程反而会造成品质的低沉。

 

再次来到目录

二、线程的基础知识

2.1 System.Threading.Thread类

System.Threading.Thread是用来控制线程的基本功类,通过Thread可以操纵当前使用程序域中线程的创始、挂起、停止、销毁。

它概括以下常用公共性质:

属性名称 说明
CurrentContext 获取线程正在其中执行的当前上下文。
CurrentThread 获取当前正在运行的线程。
ExecutionContext 获取一个 ExecutionContext 对象,该对象包含有关当前线程的各种上下文的信息。
IsAlive 获取一个值,该值指示当前线程的执行状态。
IsBackground 获取或设置一个值,该值指示某个线程是否为后台线程。
IsThreadPoolThread 获取一个值,该值指示线程是否属于托管线程池。
ManagedThreadId 获取当前托管线程的唯一标识符。
Name 获取或设置线程的名称。
Priority 获取或设置一个值,该值指示线程的调度优先级。
ThreadState 获取一个值,该值包含当前线程的状态。

 

2.1.1 线程的标识符

ManagedThreadId是肯定线程的绝无仅有标识符,程序在多数情状下都是通过Thread.ManagedThreadId来辨别线程的。而Name是一个可变值,在默许时候,Name为一个空值
Null,开发人士可以由此程序设置线程的称谓,但这只是一个相助效率。

 

2.1.2 线程的预先级别

.NET为线程设置了Priority属性来定义线程执行的优先级别,里面包罗5个拔取,其中诺玛l是默许值。除非系统有特殊必要,否则不应有随便设置线程的先期级别。

成员名称 说明
Lowest 可以将 Thread 安排在具有任何其他优先级的线程之后。      
BelowNormal 可以将 Thread 安排在具有 Normal 优先级的线程之后,在具有 Lowest 优先级的线程之前。      
Normal 默认选择。可以将 Thread 安排在具有 AboveNormal 优先级的线程之后,在具有 BelowNormal 优先级的线程之前。 
AboveNormal 可以将 Thread 安排在具有 Highest 优先级的线程之后,在具有 Normal 优先级的线程之前。      
Highest 可以将 Thread 安排在具有任何其他优先级的线程之前。      

 

2.1.3 线程的场所

经过ThreadState能够检测线程是处在Unstarted、Sleeping、Running
等等状态,它比 IsAlive 属质量提供更多的特定新闻。

眼前说过,一个采纳程序域中恐怕包罗四个上下文,而通过CurrentContext能够赢得线程当前的上下文。

CurrentThread是最常用的一个性质,它是用于获取当前运行的线程。

 

2.1.4 System.Threading.Thread的方法

Thread
中概括了八个艺术来决定线程的始建、挂起、为止、销毁,未来来的例证中会平时应用。

方法名称 说明
Abort()     终止本线程。
GetDomain() 返回当前线程正在其中运行的当前域。
GetDomainId() 返回当前线程正在其中运行的当前域Id。
Interrupt() 中断处于 WaitSleepJoin 线程状态的线程。
Join() 已重载。 阻塞调用线程,直到某个线程终止时为止。
Resume() 继续运行已挂起的线程。
Start()   执行本线程。
Suspend() 挂起当前线程,如果当前线程已属于挂起状态则此不起作用
Sleep()   把正在运行的线程挂起一段时间。

 

2.1.5 开发实例

以下那几个事例,就是通过Thread突显当前线程讯息

图片 2😉

 1         static void Main(string[] args)
 2         {
 3             Thread thread = Thread.CurrentThread;
 4             thread.Name = "Main Thread";
 5             string threadMessage = string.Format("Thread ID:{0}\n    Current AppDomainId:{1}\n    "+
 6                 "Current ContextId:{2}\n    Thread Name:{3}\n    "+
 7                 "Thread State:{4}\n    Thread Priority:{5}\n",
 8                 thread.ManagedThreadId, Thread.GetDomainID(), Thread.CurrentContext.ContextID,
 9                 thread.Name, thread.ThreadState, thread.Priority);
10             Console.WriteLine(threadMessage);
11             Console.ReadKey();
12         }

图片 3😉

 

运转结果

图片 4

 

2.2  System.Threading 命名空间

在System.Threading命名空间内提供多个点子来营造二十四线程应用程序,其中ThreadPool与Thread是多线程开发中最常用到的,在.NET中特意设定了一个CLR线程池专门用来管理线程的运行,那么些CLR线程池正是通过ThreadPool类来管理。而Thread是治本线程的最直白格局,上面几节将详细介绍有关内容。

类     说明
AutoResetEvent 通知正在等待的线程已发生事件。无法继承此类。
ExecutionContext 管理当前线程的执行上下文。无法继承此类。
Interlocked 为多个线程共享的变量提供原子操作。
Monitor 提供同步对对象的访问的机制。
Mutex 一个同步基元,也可用于进程间同步。
Thread 创建并控制线程,设置其优先级并获取其状态。
ThreadAbortException 在对 Abort 方法进行调用时引发的异常。无法继承此类。
ThreadPool 提供一个线程池,该线程池可用于发送工作项、处理异步 I/O、代表其他线程等待以及处理计时器。
Timeout 包含用于指定无限长的时间的常数。无法继承此类。
Timer 提供以指定的时间间隔执行方法的机制。无法继承此类。
WaitHandle 封装等待对共享资源的独占访问的操作系统特定的对象。

在System.Threading中的包涵了下表中的五个常用委托,其中ThreadStart、ParameterizedThreadStart是最常用到的寄托。
由ThreadStart生成的线程是最直接的措施,但由ThreadStart所生成并不受线程池管理。
而ParameterizedThreadStart是为异步触发带参数的艺术而设的,在下一节将为大家逐一细说。

委托 说明
ContextCallback 表示要在新上下文中调用的方法。
ParameterizedThreadStart 表示在 Thread 上执行的方法。
ThreadExceptionEventHandler 表示将要处理 Application 的 ThreadException 事件的方法。
ThreadStart 表示在 Thread 上执行的方法。
TimerCallback 表示处理来自 Timer 的调用的方法。
WaitCallback 表示线程池线程要执行的回调方法。
WaitOrTimerCallback 表示当 WaitHandle 超时或终止时要调用的方法。

 

2.3 线程的田间管理章程

经过ThreadStart来创立一个新线程是最间接的方法,但诸如此类创造出来的线程相比难管理,假诺创设过多的线程反而会让系统的习性下载。有见及此,.NET为线程管理越发设置了一个CLR线程池,使用CLR线程池系统可以更合理地保管线程的运用。所有请求的劳务都能运行于线程池中,当运行截至时线程便会回归到线程池。通过安装,能控制线程池的最大线程数量,在央求超出线程最大值时,线程池能按照操作的先期级别来推行,让有些操作处于等候情况,待有线程回归时再履行操作。

基础知识就为大家介绍到那边,上面将详细介绍二十四线程的开销。

 

 

重返目录

三、以ThreadStart方式贯彻多线程

3.1 使用ThreadStart委托

那边先以一个例子浮现一下二十四线程带来的补益,首先在Message类中创制一个措施ShowMessage(),里面显示了脚下运行线程的Id,并利用Thread.Sleep(int
)
方法模拟部分工作。在main()中通过ThreadStart委托绑定Message对象的ShowMessage()方法,然后经过Thread.Start()执行异步方法。

图片 5😉

 1       public class Message  2       {  3           public void ShowMessage()  4           {  5               string message = string.Format("Async threadId is :{0}",  6                                               Thread.CurrentThread.ManagedThreadId);  7               Console.WriteLine(message);  8     9               for (int n = 0; n < 10; n++) 10               { 11                   Thread.Sleep(300);    12                   Console.WriteLine("The number is:" + n.ToString());  13               } 14           } 15       } 16    17       class Program 18       { 19           static void Main(string[] args) 20           { 21               Console.WriteLine("Main threadId is:"+ 22                                 Thread.CurrentThread.ManagedThreadId); 23               Message message=new Message(); 24               Thread thread = new Thread(new ThreadStart(message.ShowMessage)); 25               thread.Start(); 26               Console.WriteLine("Do something ..........!"); 27               Console.WriteLine("Main thread working is complete!"); 28                29           } 30       }

图片 6😉

请留意运行结果,在调用Thread.Start()方法后,系统以异步形式运行Message.ShowMessage(),而主线程的操作是继续执行的,在Message.ShowMessage()落成前,主线程已到位所有的操作。

图片 7

 

3.2 使用ParameterizedThreadStart委托

ParameterizedThreadStart委托与ThreadStart委托极度相似,但ParameterizedThreadStart委托是面向带参数方法的。注意ParameterizedThreadStart
对应措施的参数为object,此参数可以为一个值对象,也得以为一个自定义对象。

图片 8😉

 1     public class Person
 2     {
 3         public string Name
 4         {
 5             get;
 6             set;
 7         }
 8         public int Age
 9         {
10             get;
11             set;
12         }
13     }
14 
15     public class Message
16     {
17         public void ShowMessage(object person)
18         {
19             if (person != null)
20             {
21                 Person _person = (Person)person;
22                 string message = string.Format("\n{0}'s age is {1}!\nAsync threadId is:{2}",
23                     _person.Name,_person.Age,Thread.CurrentThread.ManagedThreadId);
24                 Console.WriteLine(message);
25             }
26             for (int n = 0; n < 10; n++)
27             {
28                 Thread.Sleep(300);   
29                 Console.WriteLine("The number is:" + n.ToString()); 
30             }
31         }
32     }
33 
34     class Program
35     {
36         static void Main(string[] args)
37         {     
38             Console.WriteLine("Main threadId is:"+Thread.CurrentThread.ManagedThreadId);
39             
40             Message message=new Message();
41             //绑定带参数的异步方法
42             Thread thread = new Thread(new ParameterizedThreadStart(message.ShowMessage));
43             Person person = new Person();
44             person.Name = "Jack";
45             person.Age = 21;
46             thread.Start(person);  //启动异步线程 
47             
48             Console.WriteLine("Do something ..........!");
49             Console.WriteLine("Main thread working is complete!");
50              
51         }
52     }

图片 9😉

运转结果:

图片 10

 

3.3 前台线程与后台线程

留神上述四个例证都未曾行使Console.ReadKey(),但系统仍旧会等待异步线程完毕后才会终结。那是因为运用Thread.Start()启动的线程默许为前台线程,而系统必须等待所有前台线程运行为止后,应用程序域才会自动卸载。

在首节曾经介绍过线程Thread有一个质量IsBackground,通过把此属性设置为true,就能够把线程设置为后台线程!那时应用程序域将在主线程已毕时就被卸载,而不会等待异步线程的周转。

 

3.4 挂起线程

为了等待其余后台线程达成后再停止主线程,就足以应用Thread.Sleep()方法。

图片 11😉

 1     public class Message  2     {  3         public void ShowMessage()  4         {  5             string message = string.Format("\nAsync threadId is:{0}",  6                                            Thread.CurrentThread.ManagedThreadId);  7             Console.WriteLine(message);  8             for (int n = 0; n < 10; n++)  9             { 10                 Thread.Sleep(300); 11                 Console.WriteLine("The number is:" + n.ToString()); 12             } 13         } 14     } 15  16     class Program 17     { 18         static void Main(string[] args) 19         {      20             Console.WriteLine("Main threadId is:"+ 21                               Thread.CurrentThread.ManagedThreadId); 22              23             Message message=new Message(); 24             Thread thread = new Thread(new ThreadStart(message.ShowMessage)); 25             thread.IsBackground = true; 26             thread.Start(); 27              28             Console.WriteLine("Do something ..........!"); 29             Console.WriteLine("Main thread working is complete!"); 30             Console.WriteLine("Main thread sleep!"); 31             Thread.Sleep(5000); 32         } 33     }

图片 12😉

运作结果如下,此时拔取程序域将在主线程运行5秒后活动终止

图片 13

 

但系统不能预感异步线程须求周转的日子,所以用经过Thread.Sleep(int)阻塞主线程并不是一个好的缓解方法。有见及此,.NET专门为等候异步线程已毕开发了另一个艺术thread.Join()。把上面例子中的最终一行Thread.Sleep(5000)修改为
thread.Join() 就能担保主线程在异步线程thread运行截至后才会截至。

 

3.5 Suspend 与 Resume (慎用)

Thread.Suspend()与 Thread.Resume()是在Framework1.0
就早已存在的老方法了,它们各自可以挂起、復苏线程。但在Framework2.0中就曾经明朗排斥那三个章程。那是因为只要某个线程占用了已部分资源,再使用Suspend()使线程短时间居于挂起状态,当在任何线程调用那么些资源的时候就会引起死锁!所以在未曾须求的图景下应该防止采取那三个法子。

 

3.6 终止线程

若想终止正在运转的线程,可以使用Abort()方法。在应用Abort()的时候,将掀起一个突出格外ThreadAbortException 。 若想在线程终止前恢复生机线程的施行,可以在破获万分后
,在catch(ThreadAbortException ex){…}
中调用Thread.ResetAbort()废除终止。
而使用Thread.Join()可以有限支撑应用程序域等待异步线程结束后才打住运行。

图片 14😉

 1          static void Main(string[] args)
 2          {
 3              Console.WriteLine("Main threadId is:" +
 4                                Thread.CurrentThread.ManagedThreadId);
 5  
 6              Thread thread = new Thread(new ThreadStart(AsyncThread));
 7              thread.IsBackground = true;
 8              thread.Start();
 9              thread.Join();
10  
11          }     
12          
13          //以异步方式调用
14          static void AsyncThread()
15          {
16              try
17              {
18                  string message = string.Format("\nAsync threadId is:{0}",
19                     Thread.CurrentThread.ManagedThreadId);
20                  Console.WriteLine(message);
21  
22                  for (int n = 0; n < 10; n++)
23                  {
24                      //当n等于4时,终止线程
25                      if (n >= 4)
26                      {
27                          Thread.CurrentThread.Abort(n);
28                      }
29                      Thread.Sleep(300);
30                      Console.WriteLine("The number is:" + n.ToString());
31                  }
32              }
33              catch (ThreadAbortException ex)
34              {
35                  //输出终止线程时n的值
36                  if (ex.ExceptionState != null)
37                      Console.WriteLine(string.Format("Thread abort when the number is: {0}!", 
38                                                       ex.ExceptionState.ToString()));
39                 
40                  //取消终止,继续执行线程
41                  Thread.ResetAbort();
42                  Console.WriteLine("Thread ResetAbort!");
43              }
44  
45              //线程结束
46              Console.WriteLine("Thread Close!");
47          }

图片 15😉

运转结果如下

图片 16

 

 

归来目录

四、CLR线程池的劳动力线程

4.1 关于CLR线程池

运用ThreadStart与ParameterizedThreadStart建立新线程非凡简单,但经过此办法创建的线程难于管理,若建立过多的线程反而会潜移默化系统的属性。
有见及此,.NET引入CLR线程池那几个定义。CLR线程池并不会在CLR开端化的时候立时创制线程,而是在应用程序要创建线程来推行职责时,线程池才初叶化一个线程。线程的先导化与其余的线程一样。在形成职责之后,该线程不会自行销毁,而是以挂起的场地重回到线程池。直到应用程序再次向线程池发出请求时,线程池里挂起的线程就会再次激活执行任务。那样既省去了树立线程所导致的特性损耗,也能够让多少个义务反复重用同一线程,从而在应用程序生存期内节约大批量用度。

注意因此CLR线程池所确立的线程总是默许为后台线程,优先级数为ThreadPriority.诺玛l。

 

4.2 工小编线程与I/O线程

CLR线程池分为工小编线程(workerThreads)与I/O线程 (completionPortThreads)
二种,工小编线程是关键用作管理CLR内部对象的运转,I/O(Input/Output)
线程顾名思义是用来与外表系统交流新闻,IO线程的细节将在下一节详细表明。

由此ThreadPool.Get马克斯(out int workerThreads,out int
completionPortThreads )和 ThreadPool.SetMax( int workerThreads, int
completionPortThreads)七个办法可以分级读取和设置CLR线程池中工小编线程与I/O线程的最大线程数。在Framework2.0中最大线程默许为25*CPU数,在Framewok3.0、4.0中最大线程数默许为250*CPU数,在前不久
I3,I5,I7 CPU出现后,线程池的最大值一般默许为1000、2000。
若想测试线程池中有稍许的线程正在投入使用,能够经过ThreadPool.GetAvailableThreads(
out int workerThreads,out int
completionPortThreads ) 方法。

应用CLR线程池的工小编线程一般有三种艺术,一是平素通过
ThreadPool.QueueUserWorkItem() 方法,二是通过委托,下边将依次细说。

 

4.3 通过QueueUserWorkItem启动工作者线程

ThreadPool线程池中含有有多个静态方法可以直接开行工作者线程: 一为
ThreadPool.QueueUserWorkItem(WaitCallback) 二为
ThreadPool.QueueUserWorkItem(WaitCallback,Object) 

先把WaitCallback委托指向一个暗含Object参数的无再次回到值方法,再采纳ThreadPool.QueueUserWorkItem(WaitCallback)
就可以异步启动此措施,此时异步方法的参数被视为null 。

图片 17😉

 1     class Program  2     {  3         static void Main(string[] args)  4         {  5             //把CLR线程池的最大值设置为1000  6             ThreadPool.SetMaxThreads(1000, 1000);  7             //显示主线程启动时线程池信息  8             ThreadMessage("Start");  9             //启动工作者线程 10             ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncCallback)); 11             Console.ReadKey(); 12         } 13          14         static void AsyncCallback(object state) 15         { 16             Thread.Sleep(200); 17             ThreadMessage("AsyncCallback"); 18             Console.WriteLine("Async thread do work!"); 19         } 20  21         //显示线程现状 22         static void ThreadMessage(string data) 23         { 24             string message = string.Format("{0}\n  CurrentThreadId is {1}", 25                  data, Thread.CurrentThread.ManagedThreadId); 26             Console.WriteLine(message); 27         } 28     }

图片 18😉

运转结果

图片 19

 

接纳 ThreadPool.QueueUserWorkItem(WaitCallback,Object)
方法可以把object对象作为参数传送到回调函数中。
下边例子中就是把一个string对象作为参数发送到回调函数当中。

图片 20😉

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             //把线程池的最大值设置为1000
 6             ThreadPool.SetMaxThreads(1000, 1000);
 7           
 8             ThreadMessage("Start");
 9             ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncCallback),"Hello Elva");
10             Console.ReadKey();
11         }
12 
13         static void AsyncCallback(object state)
14         {
15             Thread.Sleep(200);
16             ThreadMessage("AsyncCallback");
17 
18             string data = (string)state;
19             Console.WriteLine("Async thread do work!\n"+data);
20         }
21 
22         //显示线程现状
23         static void ThreadMessage(string data)
24         {
25             string message = string.Format("{0}\n  CurrentThreadId is {1}",
26                  data, Thread.CurrentThread.ManagedThreadId);
27             Console.WriteLine(message);
28         }
29     }

图片 21😉

运作结果

图片 22

 

经过ThreadPool.QueueUserWorkItem启动工小编线程尽管是便民,但WaitCallback委托指向的必须是一个暗含Object参数的无再次来到值方法,那活脱脱是一种范围。若方法须求有重回值,或者隐含两个参数,那将多费周折。有见及此,.NET提供了另一种艺术去建立工小编线程,那就是委托。

 

4.4  委托类       

选拔CLR线程池中的工小编线程,最灵敏最常用的章程就是行使委托的异步方法,在此先容易介绍一下委托类。

当定义委托后,.NET就会自行成立一个象征该信托的类,上边可以用反射格局显示委托类的办法成员(对反射有趣味的朋友可以先参考一下“.NET基础篇——反射的神秘”)

图片 23😉

 1     class Program  2     {  3         delegate void MyDelegate();  4   5         static void Main(string[] args)  6         {  7             MyDelegate delegate1 = new MyDelegate(AsyncThread);  8             //显示委托类的几个方法成员       9             var methods=delegate1.GetType().GetMethods(); 10             if (methods != null) 11                 foreach (MethodInfo info in methods) 12                     Console.WriteLine(info.Name); 13             Console.ReadKey(); 14          } 15      }

图片 24😉

委托类包涵以下多少个基本点措施

图片 25

图片 26😉

1     public class MyDelegate:MulticastDelegate
2     {
3         public MyDelegate(object target, int methodPtr);
4         //调用委托方法
5         public virtual void Invoke();
6         //异步委托
7         public virtual IAsyncResult BeginInvoke(AsyncCallback callback,object state);
8         public virtual void EndInvoke(IAsyncResult result);
9     }

图片 27😉

当调用Invoke()方法时,对应此委托的所有办法都会被实践。而BeginInvoke与EndInvoke则辅助委托方法的异步调用,由BeginInvoke启动的线程都属于CLR线程池中的工小编线程,在底下将详细表达。

 

4.5  利用BeginInvoke与EndInvoke落成异步委托方法

率先成立一个信托对象,通过IAsyncResult BeginInvoke(string
name,AsyncCallback callback,object state) 异步调用委托方法,BeginInvoke
方法除最终的八个参数外,其他参数都是与艺术参数相对应的。通过 BeginInvoke
方法将回来一个贯彻了 System.IAsyncResult
接口的对象,之后就足以选用EndInvoke(IAsyncResult )
方法就可以终结异步操作,获取委托的运行结果。

图片 28😉

 1     class Program  2     {  3         delegate string MyDelegate(string name);  4   5         static void Main(string[] args)  6         {  7             ThreadMessage("Main Thread");  8               9             //建立委托 10             MyDelegate myDelegate = new MyDelegate(Hello); 11             //异步调用委托,获取计算结果 12             IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null); 13             //完成主线程其他工作 14             .............  15             //等待异步方法完成,调用EndInvoke(IAsyncResult)获取运行结果 16             string data=myDelegate.EndInvoke(result); 17             Console.WriteLine(data); 18              19             Console.ReadKey(); 20         } 21  22         static string Hello(string name) 23         { 24             ThreadMessage("Async Thread"); 25             Thread.Sleep(2000);            //虚拟异步工作 26             return "Hello " + name; 27         } 28  29         //显示当前线程 30         static void ThreadMessage(string data) 31         { 32             string message = string.Format("{0}\n  ThreadId is:{1}", 33                    data,Thread.CurrentThread.ManagedThreadId); 34             Console.WriteLine(message); 35         } 36     }

图片 29😉

运转结果

图片 30

 

4.6  善用IAsyncResult

在以上例子中得以瞥见,假使在应用myDelegate.BeginInvoke后随即调用myDelegate.EndInvoke,那在异步线程未成功工作此前主线程将处于阻塞状态,等到异步线程为止获取计算结果后,主线程才能持续工作,那明确力不从心浮现出多线程的优势。此时可以可以利用IAsyncResult
升高主线程的干活性质,IAsyncResult有以下成员:

图片 31😉

1 public interface IAsyncResult
2 {
3     object AsyncState {get;}            //获取用户定义的对象,它限定或包含关于异步操作的信息。
4     WailHandle AsyncWaitHandle {get;}   //获取用于等待异步操作完成的 WaitHandle。
5     bool CompletedSynchronously {get;}  //获取异步操作是否同步完成的指示。
6     bool IsCompleted {get;}             //获取异步操作是否已完成的指示。
7 }

图片 32😉

通过轮询形式,使用IsCompleted属性判断异步操作是还是不是形成,那样在异步操作未形成前就可以让主线程执行别的的工作。

图片 33😉

 1     class Program  2     {  3         delegate string MyDelegate(string name);  4   5         static void Main(string[] args)  6         {  7             ThreadMessage("Main Thread");  8               9             //建立委托 10             MyDelegate myDelegate = new MyDelegate(Hello); 11             //异步调用委托,获取计算结果 12             IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null); 13             //在异步线程未完成前执行其他工作 14             while (!result.IsCompleted) 15             { 16                 Thread.Sleep(200);      //虚拟操作 17                 Console.WriteLine("Main thead do work!"); 18             } 19             string data=myDelegate.EndInvoke(result); 20             Console.WriteLine(data); 21              22             Console.ReadKey(); 23         } 24  25         static string Hello(string name) 26         { 27             ThreadMessage("Async Thread"); 28             Thread.Sleep(2000); 29             return "Hello " + name; 30         } 31  32         static void ThreadMessage(string data) 33         { 34             string message = string.Format("{0}\n  ThreadId is:{1}", 35                    data,Thread.CurrentThread.ManagedThreadId); 36             Console.WriteLine(message); 37         } 38     }

图片 34😉

运作结果:

图片 35

 

除此以外,也可以运用WailHandle达成同样的做事,WaitHandle里面含有有一个主意WaitOne(int
timeout),它能够判定委托是不是形成工作,在劳作未到位前主线程可以持续其他工作。运行上面代码可取得与使用
IAsyncResult.IsCompleted 同样的结果,而且更简单方便 。

图片 36😉

 1 namespace Test
 2 {
 3     class Program
 4     {
 5         delegate string MyDelegate(string name);
 6 
 7         static void Main(string[] args)
 8         {
 9             ThreadMessage("Main Thread");
10             
11             //建立委托
12             MyDelegate myDelegate = new MyDelegate(Hello);
13  
14             //异步调用委托,获取计算结果
15             IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
16             
17             while (!result.AsyncWaitHandle.WaitOne(200))
18             {
19                 Console.WriteLine("Main thead do work!");
20             }
21             string data=myDelegate.EndInvoke(result);
22             Console.WriteLine(data);
23             
24             Console.ReadKey();
25         }
26 
27         static string Hello(string name)
28         {
29             ThreadMessage("Async Thread");
30             Thread.Sleep(2000);
31             return "Hello " + name;
32         }
33 
34         static void ThreadMessage(string data)
35         {
36             string message = string.Format("{0}\n  ThreadId is:{1}",
37                    data,Thread.CurrentThread.ManagedThreadId);
38             Console.WriteLine(message);
39         }
40     }

图片 37😉

当要监视三个运行目的的时候,使用IAsyncResult.WaitHandle.WaitOne可就派不上用场了。
幸好.NET为WaitHandle准备了此外五个静态方法:WaitAny(waitHandle[],
int)与WaitAll (waitHandle[] , int)。
其中WaitAll在等候所有waitHandle完结后再回去一个bool值。
而WaitAny是伺机之中一个waitHandle落成后就回到一个int,那么些int是意味已成功waitHandle在waitHandle[]中的数组索引。
下边就是运用WaitAll的事例,运行结果与行使 IAsyncResult.IsCompleted
相同。

图片 38😉

 1     class Program  2     {  3         delegate string MyDelegate(string name);  4   5         static void Main(string[] args)  6         {  7             ThreadMessage("Main Thread");  8               9             //建立委托 10             MyDelegate myDelegate = new MyDelegate(Hello); 11   12             //异步调用委托,获取计算结果 13             IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null); 14  15             //此处可加入多个检测对象 16             WaitHandle[] waitHandleList = new WaitHandle[] { result.AsyncWaitHandle,........ }; 17             while (!WaitHandle.WaitAll(waitHandleList,200)) 18             { 19                 Console.WriteLine("Main thead do work!"); 20             } 21             string data=myDelegate.EndInvoke(result); 22             Console.WriteLine(data); 23              24             Console.ReadKey(); 25         } 26  27         static string Hello(string name) 28         { 29             ThreadMessage("Async Thread"); 30             Thread.Sleep(2000); 31             return "Hello " + name; 32         } 33  34         static void ThreadMessage(string data) 35         { 36             string message = string.Format("{0}\n  ThreadId is:{1}", 37                    data,Thread.CurrentThread.ManagedThreadId); 38             Console.WriteLine(message); 39         } 40     }

图片 39😉

 

4.7 回调函数

运用轮询格局来检测异步方法的动静至极辛勤,而且成效不高,有见及此,.NET为
IAsyncResult BeginInvoke(AsyncCallback ,
object)准备了一个回调函数。使用 AsyncCallback
就足以绑定一个格局作为回调函数,回调函数必须是带参数 IAsyncResult
且无再次来到值的艺术: void AsycnCallbackMethod(IAsyncResult result)
。在BeginInvoke方法成功后,系统就会调用AsyncCallback所绑定的回调函数,最终回调函数中调用
XXX EndInvoke(IAsyncResult result)
就可以了结异步方法,它的回来值类型与寄托的重回值一致。

图片 40😉

 1     class Program
 2     {
 3         delegate string MyDelegate(string name);
 4 
 5         static void Main(string[] args)
 6         {
 7             ThreadMessage("Main Thread");
 8 
 9             //建立委托
10             MyDelegate myDelegate = new MyDelegate(Hello);
11             //异步调用委托,获取计算结果
12             myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), null);
13             //在启动异步线程后,主线程可以继续工作而不需要等待
14             for (int n = 0; n < 6; n++)
15                 Console.WriteLine("  Main thread do work!");
16             Console.WriteLine("");
17 
18             Console.ReadKey();
19         }
20 
21         static string Hello(string name)
22         {
23             ThreadMessage("Async Thread");
24             Thread.Sleep(2000);             \\模拟异步操作
25             return "\nHello " + name;
26         }
27 
28         static void Completed(IAsyncResult result)
29         {
30             ThreadMessage("Async Completed");
31 
32             //获取委托对象,调用EndInvoke方法获取运行结果
33             AsyncResult _result = (AsyncResult)result;
34             MyDelegate myDelegate = (MyDelegate)_result.AsyncDelegate;
35             string data = myDelegate.EndInvoke(_result);
36             Console.WriteLine(data);
37         }
38 
39         static void ThreadMessage(string data)
40         {
41             string message = string.Format("{0}\n  ThreadId is:{1}",
42                    data, Thread.CurrentThread.ManagedThreadId);
43             Console.WriteLine(message);
44         }
45     }

图片 41😉

可以见见,主线在调用BeginInvoke方法可以继续执行其他命令,而无需再等待了,那毋庸置疑比选拔轮询格局判断异步方法是不是到位更有优势。
在异步方法执行到位后将会调用AsyncCallback所绑定的回调函数,注意一点,回调函数依然是在异步线程中实施,那样就不会影响主线程的运转,那也利用回调函数最值得青昧的地方。
在回调函数中有一个既定的参数IAsyncResult,把IAsyncResult强制转换为AsyncResult后,就足以因而AsyncResult.AsyncDelegate 获取原委托,再使用EndInvoke方法取得总计结果。
运行结果如下:

图片 42

比方想为回调函数传送一些外表音讯,就足以选择BeginInvoke(AsyncCallback,object)的末尾一个参数object,它同意外部向回调函数输入任何项目标参数。只须求在回调函数中利用
AsyncResult.AsyncState 就足以博得object对象。

图片 43😉

 1     class Program  2     {  3         public class Person  4         {  5             public string Name;  6             public int Age;  7         }  8   9         delegate string MyDelegate(string name); 10  11         static void Main(string[] args) 12         { 13             ThreadMessage("Main Thread"); 14  15             //建立委托 16             MyDelegate myDelegate = new MyDelegate(Hello); 17              18             //建立Person对象 19             Person person = new Person(); 20             person.Name = "Elva"; 21             person.Age = 27; 22              23             //异步调用委托,输入参数对象person, 获取计算结果 24             myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), person);             25            26             //在启动异步线程后,主线程可以继续工作而不需要等待 27             for (int n = 0; n < 6; n++) 28                 Console.WriteLine("  Main thread do work!"); 29             Console.WriteLine(""); 30  31             Console.ReadKey(); 32         } 33  34         static string Hello(string name) 35         { 36             ThreadMessage("Async Thread"); 37             Thread.Sleep(2000); 38             return "\nHello " + name; 39         } 40  41         static void Completed(IAsyncResult result) 42         { 43             ThreadMessage("Async Completed"); 44  45             //获取委托对象,调用EndInvoke方法获取运行结果 46             AsyncResult _result = (AsyncResult)result; 47             MyDelegate myDelegate = (MyDelegate)_result.AsyncDelegate; 48             string data = myDelegate.EndInvoke(_result); 49             //获取Person对象 50             Person person = (Person)result.AsyncState; 51             string message = person.Name + "'s age is " + person.Age.ToString(); 52  53             Console.WriteLine(data+"\n"+message); 54         } 55  56         static void ThreadMessage(string data) 57         { 58             string message = string.Format("{0}\n  ThreadId is:{1}", 59                    data, Thread.CurrentThread.ManagedThreadId); 60             Console.WriteLine(message); 61         } 62     }

图片 44😉

运行结果:

图片 45

 

关于I/O线程、SqlCommand八线程查询、PLINQ、定时器与锁的情节将在C#归结揭秘——细说八线程(下)中详细介绍。
对 .NET 开发有趣味的情侣欢迎出席QQ群:230564952
共同探究 !

回到目录

C#归咎揭秘

由此改动注册表建立Windows自定义协议
Entity Framework
并发处理详解
细说进度、应用程序域与上下文

细说三多线程(上)

细说多线程(下) 前述事务深入剖析委托与事件

 

作者:风尘浪子 http://www.cnblogs.com/leslies2/archive/2012/02/07/2310495.html

原创文章,转发时请表明小编及出处

 

 

 

分类:
C#综上所述揭秘

相关文章