多线程的秘密,综合揭秘

4.7 回调函数

图片 1

 

运转结果如下

 

 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     }

图片 2

图片 3

回到目录

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

 

图片 4

3.3 前台线程与后台线程

图片 5

可以看出,主线在调用BeginInvoke方法能够继续实行其他命令,而无需再伺机了,那无疑比采取轮询格局决断异步方法是或不是实现更有优势。
在异步方法实施到位后将会调用AsyncCallback所绑定的回调函数,注意一点,回调函数照旧是在异步线程中实施,那样就不会耳闻则诵主线程的运作,那也使用回调函数最值得青昧的地点。
在回调函数中有一个既定的参数IAsyncResult,把IAsyncResult强制调换为AsyncResult后,就能够经过
AsyncResult.AsyncDelegate 获取开始和结果托,再使用EndInvoke方法得到总结结果。
运行结果如下:

 

它富含以下常用公共性质:

图片 6

归来目录

图片 7

 

 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          }
 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     }

 

1.2 多线程

 

在意上述多少个例子都未曾选用Console.ReadKey(),但系统照旧会等待异步线程完结后才会截止。这是因为运用Thread.Start()运行的线程默感到前台线程,而系统必需等待全数前台线程运转停止后,应用程序域才会自动卸载。

 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       }

经过ThreadPool.QueueUserWorkItem运转工小编线程即使是便于,但WaitCallback委托指向的必得是一个蕴含Object参数的无再次来到值方法,这确实是一种限制。若方法必要有重返值,大概隐含七个参数,这将多费周折。有见及此,.NET提供了另一种艺术去创立工小编线程,这就是委托。

1.2 多线程

图片 8😉

ThreadPool线程池中包含有七个静态方法能够平素开发银行工小编线程:
一为 ThreadPool.QueueUserWorkItem(WaitCallback)
二为 ThreadPool.QueueUserWorkItem(WaitCallback,Object) 

 

前边说过,叁个利用程序域中大概满含多少个上下文,而通过CurrentContext能够获取线程当前的上下文。

图片 9

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

Thread
中包蕴了多少个措施来决定线程的始建、挂起、截至、销毁,以往来的例证中会常常利用。

当调用Invoke()方法时,对应此委托的持有办法都会被试行。而BeginInvoke与EndInvoke则援助委托方法的异步调用,由BeginInvoke运营的线程都属于CL大切诺基线程池中的工小编线程,在下边将详细表达。

一、线程的概念

图片 10

图片 11😉

透过ThreadPool.QueueUserWorkItem运行工我线程尽管是便利,但WaitCallback委托指向的总得是一个暗含Object参数的无重回值方法,那的确是一种限制。若方法须要有再次回到值,只怕隐含三个参数,那将多费周折。有见及此,.NET提供了另一种形式去建构工小编线程,这就是寄托。

 

 

二、线程的基础知识

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

为了等待别的后台线程达成后再截止主线程,就能够动用Thread.Sleep()方法。

图片 12

 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     }

应用 ThreadPool.QueueUserWorkItem(WaitCallback,Object)
方法能够把object对象作为参数字传送送到回调函数中。
下边例子中便是把多个string对象作为参数发送到回调函数其中。

 
由于本文是以介绍四线程工夫为主旨,对经过、应用程序域的介绍就到此截止。关于进度、线程、应用程序域的技巧,在“C#汇总揭秘——细说进度、应用程序域与上下文”会有详实介绍。

图片 13

 

运作结果

运行结果:

 

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

图片 14

 

 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     }

前方说过,二个应用程序域中或者包涵八个上下文,而由此CurrentContext能够博得线程当前的上下文。

图片 15

七、并行编制程序与PLINQ

一、线程的定义

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

System.Threading.Thread是用来调控线程的基本功类,通过Thread能够操纵当前应用程序域中线程的创立、挂起、甘休、销毁。

 

图片 16

3.4 挂起线程

进程、应用程序域、线程的涉及如下图,三个进程内得以归纳八个利用程序域,也许有囊括多个线程,线程也能够穿梭于多少个使用程序域个中。但在同一个随时,线程只会处在一个施用程序域内。

图片 17😉

3.3 前台线程与后台线程

图片 18😉

应用轮询情势来检验异步方法的状态十一分麻烦,何况效用不高,有见及此,.NET为
IAsyncResult BeginInvoke(AsyncCallback ,
object)筹划了三个回调函数。使用 AsyncCallback
就能够绑定贰个措施作为回调函数,回调函数必需是带参数 IAsyncResult
且无再次回到值的不二诀窍: void AsycnCallbackMethod(IAsyncResult result)
。在BeginInvoke方法成功后,系统就能够调用AsyncCallback所绑定的回调函数,最后回调函数中调用
XXX EndInvoke(IAsyncResult result)
就足以了结异步方法,它的回来值类型与寄托的重返值一致。

图片 19😉

 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     }

图片 20😉

 

图片 21😉

当定义委托后,.NET就能自行成立贰个代表该信托的类,上面能够用反射形式浮现委托类的方式成员(对反射有意思味的相恋的人能够先参照他事他说加以考察一下“.NET基础篇——反射的神妙”)

八、电磁打点计时器与锁

3.2 使用ParameterizedThreadStart委托

 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     }

留意上述七个例证都未有行使Console.ReadKey(),但系统依然会等待异步线程完成后才会实现。那是因为运用Thread.Start()运营的线程默以为前台线程,而系统必须等待全数前台线程运转甘休后,应用程序域才会活动卸载。

 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         }

4.4  委托类       

3.1 使用ThreadStart委托

适合的数量选拔十二线程能抓实系统的习性,比方:在系统乞请大体积的数码时采纳八线程,把数量输出专门的学业付出异步线程,使主线程保持其安静去管理别的难点。但需求专一一点,因为CPU必要开销相当多的日子在线程的切换上,所以众多地行使八线程反而会招致品质的下降。

透过轮询模式,使用IsCompleted属性判断异步操作是不是到位,这样在异步操作未产生前就足以让主线程施行其它的办事。

四、CLENCORE线程池的劳力线程

 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     }

图片 22

 

 

 

 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     }
 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       }

 

 

4.7 回调函数

图片 23😉

2.1.2 线程的预先等第

2.3 线程的管制方法

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

图片 24😉

2.3 线程的保管艺术

图片 25😉

CLLX570线程池分为工小编线程(workerThreads)与I/O线程 (completionPortThreads)
几种,工小编线程是非同平时用作管理CLPAJERO内部对象的运行,I/O(Input/Output)
线程断章取义是用以与外界系统沟通信息,IO线程的细节就要下一节详细表达。

图片 26😉

在System.Threading中的包括了下表中的多少个常用委托,当中ThreadStart、ParameterizedThreadStart是最常用到的寄托。
由ThreadStart生成的线程是最直白的不二法门,但由ThreadStart所生成并不受线程池管理。
而ParameterizedThreadStart是为异步触发带参数的办法而设的,在下一节将为大家逐个细说。

注意因而CL瑞虎线程池所确立的线程总是默以为后台线程,优先级数为ThreadPriority.Normal。

图片 27

图片 28😉

 

当定义委托后,.NET就能活动成立两个象征该信托的类,下边能够用反射情势展现委托类的办法成员(对反射风乐趣的相恋的人能够先仿照效法一下“.NET基础篇——反射的神妙”)

 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     }

 

3.5 Suspend 与 Resume (慎用)

二、线程的基础知识

由此ThreadPool.Get马克斯(out int workerThreads,out int
completionPortThreads )和 ThreadPool.Set马克斯( int workerThreads, int
completionPortThreads)七个主意能够独家读取和装置CLHaval线程池江苏中华南理工科业大学学程公司小编线程与I/O线程的最大线程数。在Framework2.0中最大线程默许为25*CPU数,在Framewok3.0、4.0中最大线程数默感到250*CPU数,在方今I3,I5,I7 CPU出现后,线程池的最大值一般默感觉一千、三千。
若想测量试验线程池中有个别许的线程正在投入使用,能够透过ThreadPool.GetAvailableThreads( out
int workerThreads,out int completionPortThreads ) 方法。

 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      }

 

2.1.2 线程的先行等第

图片 29

回到目录

三、以ThreadStart方式完结多线程

图片 30

4.1 关于CLR线程池

 

图片 31

 

当要监视多个运转目的的时候,使用IAsyncResult.WaitHandle.WaitOne可就派不上用场了。
幸好.NET为WaitHandle筹算了其它多少个静态方法:WaitAny(waitHandle[],
int)与WaitAll (waitHandle[] , int)。
内部WaitAll在等候全部waitHandle完结后再回去一个bool值。
而WaitAny是等待之中叁个waitHandle达成后就回去三个int,那个int是象征已产生waitHandle在waitHandle[]中的数组索引。
上面正是采取WaitAll的例证,运转结果与运用 IAsyncResult.IsCompleted
一样。

图片 32

进度(Process)是Windows系统中的一个基本概念,它包罗着三个周转程序所急需的财富。进度之间是相对独立的,二个进度不能够访谈另二个进度的多少(除非动用分布式计算格局),一个经过运营的挫折也不会影响其它过程的周转,Windows系统正是接纳进程把职业划分为多个独立的区域的。进度能够明白为贰个顺序的着力边界。

图片 33

2.1.4 System.Threading.Thread的方法

图片 34

 
出于本文是以介绍十六线程技巧为核心,对经过、应用程序域的牵线就到此结束。关于进度、线程、应用程序域的技巧,在“C#综上所述揭秘——细说过程、应用程序域与上下文”会有详实介绍。

通过ThreadState能够检验线程是处在Unstarted、Sleeping、Running
等等状态,它比 IsAlive 属质量提供更加多的特定音讯。

以下那一个例子,正是经过Thread呈现当前线程音信

图片 35

在第3节曾经介绍过线程Thread有一个属性IsBackground,通过把此属性设置为true,就足以把线程设置为后台线程!那时应用程序域将要主线程完毕时就被卸载,而不会等待异步线程的运转。

原创小说,转发时请表明笔者及出处

利用程序域(AppDomain)是多少个程序运维的逻辑区域,它能够视为贰个轻量级的长河,.NET的前后相继集正是在运用程序域中运营的,二个进度可以包涵有多少个利用程序域,贰个选拔程序域也能够饱含两个程序集。在一个施用程序域中包蕴了二个或多个左右文context,使用前后文CL奥迪Q3就能够把一些特殊指标的情事放置在不一致容器在那之中。

 

运营结果:

图片 36😉

2.1.5 开采实例

3.5 Suspend 与 Resume (慎用)

图片 37

 

图片 38

图片 39

Thread
中包含了五个措施来决定线程的始建、挂起、甘休、销毁,今后来的例证中会平日使用。

图片 40😉

除此以外,也得以应用WailHandle达成一样的行事,WaitHandle里面包含有三个措施WaitOne(int
timeout),它能够判明委托是或不是做到职业,在干活未到位前主线程能够继续别的干活。运营下边代码可得到与应用
IAsyncResult.IsCompleted 一样的结果,何况更简约方便 。

三、以ThreadStart情势达成三十二线程

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

引言

3.4 挂起线程

图片 41😉

回到目录

请留神运转结果,在调用Thread.Start()方法后,系统以异步格局运行Message.ShowMessage(),而主线程的操作是继续实行的,在Message.ShowMessage()完毕前,主线程已成功全数的操作。

图片 42

C#汇总揭秘

图片 43

 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     }

图片 44

2.1.1 线程的标记符

 

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

图片 45

 

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     }

ManagedThreadId是认同线程的无可比拟标记符,程序在大部气象下都是通过Thread.ManagedThreadId来识别线程的。而Name是二个可变值,在暗中认可时候,Name为三个空值
Null,开采人士能够透进程序设置线程的称呼,但那只是三个声援功效。

图片 46

运营结果

2.1 System.Threading.Thread类

图片 47😉

4.2 工笔者线程与I/O线程

假如想为回调函数字传送送一些外表音信,就能够运用BeginInvoke(AsyncCallback,object)的最终三个参数object,它同意外界向回调函数输入任何类型的参数。只要求在回调函数中采纳AsyncResult.AsyncState 就足以拿走object对象。

图片 48

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

 

图片 49😉

若想终止正在运作的线程,能够动用Abort()方法。在采用Abort()的时候,将吸引三个奇特非常ThreadAbortException 。
若想在线程终止前复苏线程的实施,能够在捕获至极后
,在catch(ThreadAbortException ex){…}
中调用Thread.ResetAbort()打消终止。
而利用Thread.Join()能够确认保证应用程序域等待异步线程截止后才甘休运营。

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     }

 

行使 ThreadPool.QueueUserWorkItem(WaitCallback,Object)
方法能够把object对象作为参数字传送送到回调函数中。
上面例子中就是把三个string对象作为参数发送到回调函数个中。

3.1 使用ThreadStart委托

经过、应用程序域、线程的关系如下图,一个经过内能够富含多少个应用程序域,也是有囊括多个线程,线程也足以不断于几个利用程序域当中。但在同贰个时时,线程只会处在多少个采取程序域内。

图片 50

目录

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

四、CL中华V线程池的劳力线程

Thread.Suspend()与 Thread.Resume()是在Framework1.0
就曾经存在的老艺术了,它们分别能够挂起、复苏线程。但在Framework2.0中就已经确定排斥那八个措施。那是因为一旦有个别线程占用了已有个别能源,再选拔Suspend()使线程长时间高居挂起状态,当在别的线程调用这一个能源的时候就能够挑起死锁!所以在尚未须要的情事下相应制止采用这两个办法。

运作结果

图片 51

图片 52

第第一建工公司立一个寄托对象,通过IAsyncResult BeginInvoke(string
name,AsyncCallback callback,object state) 异步调用委托方法,BeginInvoke
方法除最终的三个参数外,别的参数都是与格局参数相对应的。通过 BeginInvoke
方法将赶回三个贯彻了 System.IAsyncResult
接口的对象,之后就足以选择EndInvoke(IAsyncResult )
方法就能够了结异步操作,获取委托的运转结果。

 

运作结果

在System.Threading命名空间内提供八个艺术来营造三十二线程应用程序,当中ThreadPool与Thread是多线程开辟中最常用到的,在.NET中等专门的学问高校门设定了二个CLHaval线程池特地用于管理线程的运维,那些CL奥迪Q5线程池就是通过ThreadPool类来治本。而Thread是治本线程的最直白情势,上边几节将详细介绍有关内容。

为了等待其余后台线程完毕后再停止主线程,就可以运用Thread.Sleep()方法。

运维结果如下

.NET为线程设置了Priority属性来定义线程执行的优先等第,里面含有5个选项,在那之中Normal是暗许值。除非系统有特殊须要,不然不该随意设置线程的初期等级。

图片 53😉

二、线程的基础知识

图片 54😉

 

由此ThreadStart来创立三个新线程是最间接的秘籍,但那样成立出来的线程相比较难管理,假设创建过多的线程反而会让系统的品质下载。有见及此,.NET为线程管理特意设置了一个CL科雷傲线程池,使用CL昂科拉线程池系统能够更合理地保管线程的运用。全部央求的服务都能运作于线程池中,当运维甘休时线程便会回归到线程池。通过设置,能调整线程池的最大线程数量,在呼吁凌驾线程最大值时,线程池能遵照操作的早期品级来实践,让有个别操作处于等候意况,待有线程回归时再实践操作。

 

图片 55😉

在System.Threading命名空间内提供八个办法来创设二十八线程应用程序,在那之中ThreadPool与Thread是多线程开垦中最常用到的,在.NET中特意设定了三个CLEvoque线程池特意用于管理线程的运维,那么些CL卡宴线程池就是经过ThreadPool类来治本。而Thread是处理线程的最直接格局,下边几节将详细介绍有关内容。

一、线程的概念

 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     }

Thread.Suspend()与 Thread.Resume()是在Framework1.0
就已经存在的老方法了,它们各自能够挂起、苏醒线程。但在Framework2.0中就早已分明排斥那多少个办法。那是因为假如某些线程占用了已部分能源,再利用Suspend()使线程短时间处在挂起状态,当在别的线程调用那个能源的时候就能够挑起死锁!所以在尚未供给的情况下应当制止接纳那七个艺术。

图片 56

 

图片 57

CLGL450线程池分为工我线程(workerThreads)与I/O线程 (completionPortThreads)
二种,工作者线程是非同通常用作管理CLLAND内部对象的运维,I/O(Input/Output)
线程看名就能够猜到其意义是用于与外表系统交流消息,IO线程的细节就要下一节详细表明。

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

 

图片 58

除此以外,也足以运用WailHandle达成一样的行事,WaitHandle里面富含有三个措施WaitOne(int
timeout),它能够看清委托是还是不是做到专业,在干活未变成前主线程能够继续别的干活。运转上面代码可得到与应用
IAsyncResult.IsCompleted 同样的结果,何况更简约方便 。

 

 

CurrentThread是最常用的贰个性格,它是用于获取当前运转的线程。

 

运作结果

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

 

4.1 关于CLR线程池

归来目录

 

4.6  善用IAsyncResult

 

运维结果如下,此时采纳程序域将要主线程运维5秒后自行终止

3.2 使用ParameterizedThreadStart委托

 

 

 

 

它满含以下常用公共属性:

通过ThreadPool.Get马克斯(out int workerThreads,out int
completionPortThreads )和 ThreadPool.Set马克斯( int workerThreads, int
completionPortThreads)多个措施能够独家读取和装置CL福特Explorer线程池中工我线程与I/O线程的最大线程数。在Framework2.0中最大线程默以为25*CPU数,在Framewok3.0、4.0中最大线程数默认为250*CPU数,在不久前
I3,I5,I7 CPU出现后,线程池的最大值一般默感觉一千、3000。
若想测验线程池中有微微的线程正在投入使用,能够透过ThreadPool.GetAvailableThreads(
out int workerThreads,out int
completionPortThreads ) 方法。

图片 59

System.Threading.Thread是用于调控线程的基础类,通过Thread能够调节当前应用程序域中线程的始建、挂起、甘休、销毁。

能够见见,主线在调用BeginInvoke方法能够继续推行其他命令,而不要求再伺机了,那如实比使用轮询格局判定异步方法是还是不是产生更有优势。
在异步方法试行到位后将会调用AsyncCallback所绑定的回调函数,注意一点,回调函数依旧是在异步线程中实施,那样就不会潜移暗化主线程的周转,那也应用回调函数最值得青昧的地方。
在回调函数中有一个既定的参数IAsyncResult,把IAsyncResult强制转变为AsyncResult后,就能够透过
AsyncResult.AsyncDelegate
获取原委托,再采用EndInvoke方法赢得总结结果。
运作结果如下:

图片 60😉

回去目录

 

在以上例子中能够看见,倘使在应用myDelegate.BeginInvoke后立时调用myDelegate.EndInvoke,那在异步线程未变成专门的学问从前主线程将处于阻塞状态,等到异步线程结束获取总计结果后,主线程技术一而再工作,那眼看力不能支体现出二十八线程的优势。此时得以好好利用IAsyncResult
进步主线程的职业性质,IAsyncResult有以下成员:

运转结果

运营结果

当要监视多少个运转目标的时候,使用IAsyncResult.WaitHandle.WaitOne可就派不上用场了。
幸而.NET为WaitHandle计划了另外八个静态方法:WaitAny(waitHandle[],
int)与WaitAll (waitHandle[] , int)。
在那之中WaitAll在等候全体waitHandle实现后再回到二个bool值。
而WaitAny是等待之中多个waitHandle实现后就回去叁个int,这些int是代表已到位waitHandle在waitHandle[]中的数组索引。
下边正是采纳WaitAll的例证,运营结果与运用 IAsyncResult.IsCompleted
同样。

 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         }

ThreadPool线程池中带有有八个静态方法能够直接开发银行工作者线程: 一为
ThreadPool.QueueUserWorkItem(WaitCallback) 二为
ThreadPool.QueueUserWorkItem(WaitCallback,Object) 

图片 61

线程(Thread)是经过中的基本实行单元,在进度入口推行的首个线程被视为这一个进程的主线程。在.NET应用程序中,都是以Main()方法作为入口的,当调用此措施时系统就会自行创造二个主线程。线程主假如由CPU存放器、调用栈和线程本地存款和储蓄器(Thread
Local
Storage,TLS)组成的。CPU寄放器首要记录当前所实施线程的状态,调用栈首要用以保险线程所调用到的内部存款和储蓄器与数量,TLS首要用于寄放线程的情景音讯。

4.3 通过QueueUserWorkItem运维工作者线程

至于I/O线程、SqlCommand二十四线程查询、PLINQ、电磁照管计时器与锁的内容将在C#综述揭秘——细说二十多线程(下)中详细介绍。
对 .NET 开辟风乐趣的爱人款待加入QQ群:230564952
共同探究 !

转载于:http://www.cnblogs.com/leslies2/archive/2012/02/07/2310495.html
 

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

 

图片 62

 

极度使用三十二线程能进步系统的属性,举例:在系统央求大容积的数额时选用三十二线程,把多少输出工作付出异步线程,使主线程保持其安居去处理别的主题材料。但需求当心一点,因为CPU需求开支相当多的时间在线程的切换上,所以重重地使用三十六线程反而会招致品质的下滑。

 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     }

先把WaitCallback委托指向二个包罗Object参数的无重临值方法,再利用
ThreadPool.QueueUserWorkItem(WaitCallback)
就能够异步运行此办法,此时异步方法的参数被视为null 。

行使ThreadStart与ParameterizedThreadStart创建新线程特别轻松,但透过此措施成立的线程难于管理,若创建过多的线程反而会影响系统的品质。
有见及此,.NET引进CL迈凯伦720S线程池这几个概念。CLRAV4线程池并不会在CLRubicon早先化的时候立即创建线程,而是在应用程序要创立线程来进行任务时,线程池才初步化二个线程。线程的开首化与其它的线程一样。在成就职务之后,该线程不会活动销毁,而是以挂起的动静重临到线程池。直到应用程序再次向线程池发出诉求时,线程池里挂起的线程就能再也激活推行职务。那样既节约了树立线程所产生的习性损耗,也足以让三个义务反复重用同一线程,进而在应用程序生存期内节约大量支出。

3.6 终止线程

此地先以一个例证浮现一下二十八线程带来的补益,首先在Message类中树立一个方法ShowMessage(),里面展现了眼下运作线程的Id,并选拔Thread.Sleep(int
)
方法模拟部分事业。在main()中经过ThreadStart委托绑定Message对象的ShowMessage()方法,然后通过Thread.Start()实行异步方法。

图片 63😉

图片 64

4.6  善用IAsyncResult

先把WaitCallback委托指向一个包罗Object参数的无再次回到值方法,再利用
ThreadPool.QueueUserWorkItem(WaitCallback)
就足以异步运转此办法,此时异步方法的参数被视为null 。

 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     }

2.2  System.Threading 命名空间

.NET为线程设置了Priority属性来定义线程实践的事先等级,里面含有5个选项,个中Normal是暗许值。除非系统有特殊供给,不然不该随意设置线程的预先等第。

运转结果:

 

 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      }

图片 65😉

请小心运营结果,在调用Thread.Start()方法后,系统以异步形式运维Message.ShowMessage(),而主线程的操作是继续推行的,在Message.ShowMessage()达成前,主线程已到位具有的操作。

图片 66😉

线程(Thread)是进度中的基本实行单元,在经过入口推行的首先个线程被视为那几个进度的主线程。在.NET应用程序中,都以以Main()方法作为入口的,当调用此方法时系统就能够自动创立多少个主线程。线程首假设由CPU存放器、调用栈和线程本地存款和储蓄器(Thread
Local
Storage,TLS)组成的。CPU寄放器首要记录当前所实践线程的景况,调用栈首要用于维护线程所调用到的内部存款和储蓄器与数码,TLS首要用以存放线程的情事音讯。

经过修改注册表创立Windows自定义合同
Entity Framework
并发处理详解
前述进度、应用程序域与上下文

细说四线程(上)

前述八线程(下) 前述事务深远深入分析委托与事件

经过ThreadStart来创建多个新线程是最直接的不二等秘书籍,但如此创制出来的线程比较难管理,假若创制过多的线程反而会让系统的属性下载。有见及此,.NET为线程管理特地设置了二个CLWrangler线程池,使用CL宝马X3线程池系统能够更合理地保管线程的选拔。全数诉求的劳务都能运作于线程池中,当运行甘休时线程便会回归到线程池。通过设置,能调节线程池的最大线程数量,在伸手超越线程最大值时,线程池能依据操作的预先等第来进行,让某些操作处于等候景况,待有线程回归时再进行操作。

分类:
C#总结揭秘

图片 67

但系统不可能预感异步线程须要周转的年月,所以用经过Thread.Sleep(int)阻塞主线程并不是叁个好的缓和办法。有见及此,.NET特地为等候异步线程达成支付了另叁个方法thread.Join()。把地点例子中的最终一行Thread.Sleep(陆仟)修改为
thread.Join() 就能够担保主线程在异步线程thread运行截至后才会终止。

但系统一点都不大概预感异步线程须要周转的时间,所以用经过Thread.Sleep(int)阻塞主线程并非三个好的解决方式。有见及此,.NET专门为等待异步线程落成支付了另三个主意thread.Join()。把地方例子中的最终一行Thread.Sleep(四千)修改为
thread.Join() 就会确认保障主线程在异步线程thread运营结束后才会告一段落。

图片 68😉

注意通过CL揽胜线程池所营造的线程总是默以为后台线程,优先级数为ThreadPriority.Normal。

委托类包括以下多少个关键方法

图片 69

图片 70

采纳CLPRADO线程池的劳力线程一般有二种方法,一是一向通过
ThreadPool.QueueUserWorkItem() 方法,二是经过委托,上边将依次细说。

 

图片 71

 

 

 

在单CPU系统的贰个单位时间(time
slice)内,CPU只好运转单个线程,运营顺序取决于线程的初期等级。如若在单位时间内线程未能成功实施,系统就能够把线程的景色音信保存到线程的本地存款和储蓄器(TLS)
中,以便下一次推行时回涨实施。而多线程只是系统带来的一个假像,它在多少个单位时间内实行多个线程的切换。因为切换频密而且单位时间极度短暂,所以十二线程可被当做同一时候运营。

2.1.3 线程的情景

选用CLENVISION线程池中的工小编线程,最灵敏最常用的点子正是行使委托的异步方法,在此先简要介绍一下委托类。

当调用Invoke()方法时,对应此委托的兼具办法都会被奉行。而BeginInvoke与EndInvoke则帮助委托方法的异步调用,由BeginInvoke运营的线程都属于CLEnclave线程池中的工小编线程,在底下将详细表明。

 

 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     }

图片 72

首先建设构造一个寄托对象,通过IAsyncResult BeginInvoke(string
name,AsyncCallback callback,object state) 异步调用委托方法,BeginInvoke
方法除最终的五个参数外,别的参数都是与措施参数相对应的。通过 BeginInvoke
方法将再次回到贰个达成了 System.IAsyncResult
接口的对象,之后就足以行使EndInvoke(IAsyncResult )
方法就能够终结异步操作,获取委托的运作结果。

 

基础知识就为我们介绍到此处,下边将详细介绍多线程的付出。

 

图片 73😉

一经想为回调函数字传送送一些外表音信,就足以应用BeginInvoke(AsyncCallback,object)的结尾三个参数object,它同意外界向回调函数输入任何项目标参数。只供给在回调函数中运用
AsyncResult.AsyncState 就可以赢得object对象。

图片 74😉

图片 75

 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          }

图片 76

 

2.1.3 线程的动静

动用程序域(AppDomain)是叁个程序运行的逻辑区域,它能够视为一个轻量级的进度,.NET的前后相继集就是在使用程序域中运营的,一个进度能够饱含有多个利用程序域,一个使用程序域也能够包括多个程序集。在贰个应用程序域中蕴藏了一个或八个上下文context,使用前后文CL大切诺基就能够把某个特殊目标的场地放置在不一致容器其中。

 

三、以ThreadStart方式实现二十多线程

基础知识就为我们介绍到此地,上边将详细介绍二十八线程的支付。

行使轮询格局来检查评定异步方法的景观十一分麻烦,并且功效不高,有见及此,.NET为
IAsyncResult BeginInvoke(AsyncCallback ,
object)打算了二个回调函数。使用 AsyncCallback
就能够绑定五个形式作为回调函数,回调函数必得是带参数 IAsyncResult
且无重临值的方法: void AsycnCallbackMethod(IAsyncResult result)
。在BeginInvoke方法成功后,系统就能够调用AsyncCallback所绑定的回调函数,最终回调函数中调用
XXX EndInvoke(IAsyncResult result)
就足以甘休异步方法,它的归来值类型与信托的重回值一致。

 

运作结果:

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

 

 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     }
 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     }

图片 77

4.3 通过QueueUserWorkItem运营工我线程

图片 78

图片 79😉

通过轮询方式,使用IsCompleted属性推断异步操作是或不是到位,那样在异步操作未成功前就能够让主线程试行另外的劳作。

图片 80😉

 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     }

图片 81😉

 

图片 82

 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     }

2.1.5 开拓实例

 

这里先以多个例证浮现一下二十四线程带来的实惠,首先在Message类中确立三个办法ShowMessage(),里面突显了眼下运转线程的Id,并运用Thread.Sleep(int
)
方法模拟部分专门的学业。在main()中经过ThreadStart委托绑定Message对象的ShowMessage()方法,然后经过Thread.Start()推行异步方法。

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

四、CL奥迪Q5线程池的劳力线程

3.6 终止线程

进度(Process)是Windows系统中的三个基本概念,它包涵着三个周转程序所急需的能源。进程之间是相对独立的,一个进程不能够访谈另一个进程的数额(除非动用布满式总括格局),叁个经过运维的挫败也不会影响其余进程的周转,Windows系统就是选取进度把工作划分为多个独立的区域的。进程能够知晓为三个顺序的为主边界。

运营结果:

接纳CL凯雷德线程池的劳力线程一般有两种方法,一是一向通过
ThreadPool.QueueUserWorkItem() 方法,二是透过委托,上边将顺序细说。

 

 

委托类包罗以下多少个首要艺术

2.1.4 System.Threading.Thread的方法

图片 83

动用ThreadStart与ParameterizedThreadStart创设新线程特别轻易,但由此此格局成立的线程难于管理,若创立过多的线程反而会潜移暗化系统的属性。
有见及此,.NET引入CLLacrosse线程池这么些定义。CLENCORE线程池并不会在CL福睿斯初步化的时候马上创制线程,而是在应用程序要创设线程来实行职责时,线程池才伊始化八个线程。线程的开头化与其他的线程一样。在造成任务之后,该线程不会自行销毁,而是以挂起的动静再次回到到线程池。直到应用程序再度向线程池发出央求时,线程池里挂起的线程就能再度激活试行职务。那样既省去了树立线程所导致的性格损耗,也可以让多少个职责一再重用同一线程,进而在应用程序生存期内节约一大波开销。

 

本文首要从线程的底蕴用法,CLMurano线程池当湖南中华南理理高校程公司我线程与I/O线程的支付,并行操作PLINQ等七个方面介绍八线程的支出。
在那之中央委员托的BeginInvoke方法以及回调函数最为常用。 而
I/O线程恐怕轻巧碰着大家的马虎,其实在支付二十多线程系统,更应该多留神I/O线程的操作。特别是在ASP.NET开辟当中,大概更两人只会静心在顾客端采取Ajax也许在劳务器端使用UpdatePanel。其实言之成理选用I/O线程在报纸发表项目或文件下载时,能尽恐怕地收缩IIS的下压力。
并行编制程序是Framework4.0中全力推广的异步操作方法,更值得更深切地读书。
希望本篇作品能对各位的求学研商有着帮忙,个中有所错漏的地方敬请点评。

ManagedThreadId是认可线程的有一无二标记符,程序在大部动静下都以通过Thread.ManagedThreadId来辨别线程的。而Name是三个可变值,在暗中认可时候,Name为一个空值
Null,开采人士能够透进程序设置线程的名称,但那只是一个帮助功用。

归来目录

2.1.1 线程的标志符

 

图片 84

若想终止正在运营的线程,能够动用Abort()方法。在动用Abort()的时候,将引发三个出色非常ThreadAbortException 。 若想在线程终止前苏醒线程的施行,可以在捕获至极后
,在catch(ThreadAbortException ex){…}
中调用Thread.ResetAbort()撤销终止。
而使用Thread.Join()能够确认保证应用程序域等待异步线程甘休后才告一段落运营。

图片 85

ParameterizedThreadStart委托与ThreadStart委托非常相像,但ParameterizedThreadStart委托是面向带参数方法的。注意ParameterizedThreadStart
对应措施的参数为object,此参数可感觉二个值对象,也得认为贰个自定义对象。

因而ThreadState能够检验线程是处在Unstarted、Sleeping、Running
等等状态,它比 IsAlive 属性能提供更加多的一定音讯。

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

图片 86

 

图片 87

4.5  利用BeginInvoke与EndInvoke实现异步委托方法

 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     }

运作结果

图片 88😉

运维结果如下,此时采取程序域就要主线程运转5秒后自行终止

2.1 System.Threading.Thread类

运行结果:

六、异步
SqlCommand

 

图片 89😉

在第1节曾经介绍过线程Thread有三个属性IsBackground,通过把此属性设置为true,就足以把线程设置为后台线程!这时应用程序域将要主线程实现时就被卸载,而不会等待异步线程的运行。

 

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

图片 90

 

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

2.2  System.Threading 命名空间

以下这些事例,就是通过Thread展现当前线程消息

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

 

在单CPU系统的一个单位时间(time
slice)内,CPU只好运转单个线程,运转顺序取决于线程的事先等级。要是在单位时间内线程未能做到施行,系统就能把线程的情事音讯保存到线程的本地存款和储蓄器(TLS)
中,以便后一次推行时上升试行。而多线程只是系统带来的多少个假像,它在八个单位时间内举行八个线程的切换。因为切换频密並且单位时间相当短暂,所以三十二线程可被看做同期运营。

 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     }

CurrentThread是最常用的三个属性,它是用以获取当前运作的线程。

在以上例子中得以瞥见,假诺在应用myDelegate.BeginInvoke后随即调用myDelegate.EndInvoke,那在异步线程未成功职业从前主线程将处于阻塞状态,等到异步线程停止获取计算结果后,主线程工夫继续专门的学业,那明显敬谢不敏显示出八线程的优势。此时得以能够利用IAsyncResult
升高主线程的劳作性质,IAsyncResult有以下成员:

4.4  委托类       

运用CL福特Explorer线程池中的工小编线程,最灵敏最常用的措施正是行使委托的异步方法,在此先简要介绍一下委托类。

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