C#多线程
?
一、基本概念
1、進程
首先打開任務管理器，查看當前運行的進程：
從任務管理器里面可以看到當前所有正在運行的進程。那么究竟什么是進程呢？
進程（Process）是Windows系統(tǒng)中的一個基本概念，它包含著一個運行程序所需要的資源。一個正在運行的應用程序在操作系統(tǒng)中被視為一個進程，進程可以包括一個或多個線程。線程是操作系統(tǒng)分配處理器時間的基本單元，在進程中可以有多個線程同時執(zhí)行代碼。進程之間是相對獨立的，一個進程無法訪問另一個進程的數(shù)據(jù)（除非利用分布式計算方式），一個進程運行的失敗也不會影響其他進程的運行，Windows系統(tǒng)就是利用進程把工作劃分為多個獨立的區(qū)域的。進程可以理解為一個程序的基本邊界。是應用程序的一個運行例程，是應用程序的一次動態(tài)執(zhí)行過程。
二、線程
在任務管理器里面查詢當前總共運行的線程數(shù)：
線程（Thread）是進程中的基本執(zhí)行單元，是操作系統(tǒng)分配CPU時間的基本單位，一個進程可以包含若干個線程，在進程入口執(zhí)行的第一個線程被視為這個進程的主線程。在.NET應用程序中，都是以Main()方法作為入口的，當調(diào)用此方法時系統(tǒng)就會自動創(chuàng)建一個主線程。線程主要是由CPU寄存器、調(diào)用棧和線程本地存儲器（Thread Local Storage，TLS）組成的。CPU寄存器主要記錄當前所執(zhí)行線程的狀態(tài)，調(diào)用棧主要用于維護線程所調(diào)用到的內(nèi)存與數(shù)據(jù)，TLS主要用于存放線程的狀態(tài)信息。
二、多線程
多線程的優(yōu)點：可以同時完成多個任務；可以使程序的響應速度更快；可以讓占用大量處理時間的任務或當前沒有進行處理的任務定期將處理時間讓給別的任務；可以隨時停止任務；可以設置每個任務的優(yōu)先級以優(yōu)化程序性能。
那么可能有人會問：為什么可以多線程執(zhí)行呢？總結(jié)起來有下面兩方面的原因：
1、CPU運行速度太快，硬件處理速度跟不上，所以操作系統(tǒng)進行分時間片管理。這樣，從宏觀角度來說是多線程并發(fā)的，因為CPU速度太快，察覺不到，看起來是同一時刻執(zhí)行了不同的操作。但是從微觀角度來講，同一時刻只能有一個線程在處理。
2、目前電腦都是多核多CPU的，一個CPU在同一時刻只能運行一個線程，但是多個CPU在同一時刻就可以運行多個線程。
然而，多線程雖然有很多優(yōu)點，但是也必須認識到多線程可能存在影響系統(tǒng)性能的不利方面，才能正確使用線程。不利方面主要有如下幾點：
（1）線程也是程序，所以線程需要占用內(nèi)存，線程越多，占用內(nèi)存也越多。
（2）多線程需要協(xié)調(diào)和管理，所以需要占用CPU時間以便跟蹤線程。
（3）線程之間對共享資源的訪問會相互影響，必須解決爭用共享資源的問題。
（4）線程太多會導致控制太復雜，最終可能造成很多程序缺陷。
當啟動一個可執(zhí)行程序時，將創(chuàng)建一個主線程。在默認的情況下，C#程序具有一個線程，此線程執(zhí)行程序中以Main方法開始和結(jié)束的代碼，Main（）方法直接或間接執(zhí)行的每一個命令都有默認線程（主線程）執(zhí)行，當Main（）方法返回時此線程也將終止。
一個進程可以創(chuàng)建一個或多個線程以執(zhí)行與該進程關聯(lián)的部分程序代碼。在C#中，線程是使用Thread類處理的，該類在System.Threading命名空間中。使用Thread類創(chuàng)建線程時，只需要提供線程入口，線程入口告訴程序讓這個線程做什么。通過實例化一個Thread類的對象就可以創(chuàng)建一個線程。創(chuàng)建新的Thread對象時，將創(chuàng)建新的托管線程。Thread類接收一個ThreadStart委托或ParameterizedThreadStart委托的構造函數(shù)，該委托包裝了調(diào)用Start方法時由新線程調(diào)用的方法，示例代碼如下：
Thread thread=new Thread(new ThreadStart(method));//創(chuàng)建線程
thread.Start();?????????????????????????????????????????????????????????? //啟動線程
上面代碼實例化了一個Thread對象，并指明將要調(diào)用的方法method()，然后啟動線程。ThreadStart委托中作為參數(shù)的方法不需要參數(shù)，并且沒有返回值。ParameterizedThreadStart委托一個對象作為參數(shù)，利用這個參數(shù)可以很方便地向線程傳遞參數(shù)，示例代碼如下：
Thread thread=new Thread(new ParameterizedThreadStart(method));//創(chuàng)建線程
thread.Start(3);???????????????????????????????????????????????????????????????????????????? //啟動線程
創(chuàng)建多線程的步驟：
1、編寫線程所要執(zhí)行的方法
2、實例化Thread類，并傳入一個指向線程所要執(zhí)行方法的委托。（這時線程已經(jīng)產(chǎn)生，但還沒有運行）
3、調(diào)用Thread實例的Start方法，標記該線程可以被CPU執(zhí)行了，但具體執(zhí)行時間由CPU決定
2.1 System.Threading.Thread類
Thread類是是控制線程的基礎類，位于System.Threading命名空間下，具有4個重載的構造函數(shù)：
| 名稱 | 說明 |
| Thread(ParameterizedThreadStart) | 初始化?Thread 類的新實例，指定允許對象在線程啟動時傳遞給線程的委托。要執(zhí)行的方法是有參的。 |
| Thread(ParameterizedThreadStart,?Int32) | 初始化?Thread 類的新實例，指定允許對象在線程啟動時傳遞給線程的委托，并指定線程的最大堆棧大小 |
| Thread(ThreadStart) | 初始化?Thread 類的新實例。要執(zhí)行的方法是無參的。 |
| Thread(ThreadStart,?Int32) | 初始化?Thread 類的新實例，指定線程的最大堆棧大小。 |
ThreadStart是一個無參的、返回值為void的委托。委托定義如下：
public delegate void ThreadStart()
通過ThreadStart委托創(chuàng)建并運行一個線程：
1 class Program2 {3 static void Main(string[] args)4 {5 //創(chuàng)建無參的線程6 Thread thread1 = new Thread(new ThreadStart(Thread1));7 //調(diào)用Start方法執(zhí)行線程8 thread1.Start();9 10 Console.ReadKey(); 11 } 12 13 /// <summary> 14 /// 創(chuàng)建無參的方法 15 /// </summary> 16 static void Thread1() 17 { 18 Console.WriteLine("這是無參的方法"); 19 } 20 }運行結(jié)果
除了可以運行靜態(tài)的方法，還可以運行實例方法
1 class Program2 {3 static void Main(string[] args)4 {5 //創(chuàng)建ThreadTest類的一個實例6 ThreadTest test=new ThreadTest();7 //調(diào)用test實例的MyThread方法8 Thread thread = new Thread(new ThreadStart(test.MyThread));9 //啟動線程 10 thread.Start(); 11 Console.ReadKey(); 12 } 13 } 14 15 class ThreadTest 16 { 17 public void MyThread() 18 { 19 Console.WriteLine("這是一個實例方法"); 20 } 21 }運行結(jié)果：
如果為了簡單，也可以通過匿名委托或Lambda表達式來為Thread的構造方法賦值
1 static void Main(string[] args)2 {3 //通過匿名委托創(chuàng)建4 Thread thread1 = new Thread(delegate() { Console.WriteLine("我是通過匿名委托創(chuàng)建的線程"); });5 thread1.Start();6 //通過Lambda表達式創(chuàng)建7 Thread thread2 = new Thread(() => Console.WriteLine("我是通過Lambda表達式創(chuàng)建的委托"));8 thread2.Start();9 Console.ReadKey(); 10 }?
?運行結(jié)果：
ParameterizedThreadStart是一個有參的、返回值為void的委托，定義如下：
public delegate void ParameterizedThreadStart(Object obj)
1 class Program2 {3 static void Main(string[] args)4 {5 //通過ParameterizedThreadStart創(chuàng)建線程6 Thread thread = new Thread(new ParameterizedThreadStart(Thread1));7 //給方法傳值8 thread.Start("這是一個有參數(shù)的委托");9 Console.ReadKey(); 10 } 11 12 /// <summary> 13 /// 創(chuàng)建有參的方法 14 /// 注意：方法里面的參數(shù)類型必須是Object類型 15 /// </summary> 16 /// <param name="obj"></param> 17 static void Thread1(object obj) 18 { 19 Console.WriteLine(obj); 20 } 21 }注意：ParameterizedThreadStart委托的參數(shù)類型必須是Object的。如果使用的是不帶參數(shù)的委托，不能使用帶參數(shù)的Start方法運行線程，否則系統(tǒng)會拋出異常。但使用帶參數(shù)的委托，可以使用thread.Start()來運行線程，這時所傳遞的參數(shù)值為null。
2.2?線程的常用屬性
| CurrentContext | 獲取線程正在其中執(zhí)行的當前上下文。 |
| CurrentThread | 獲取當前正在運行的線程。 |
| ExecutionContext | 獲取一個 ExecutionContext 對象，該對象包含有關當前線程的各種上下文的信息。 |
| IsAlive | 獲取一個值，該值指示當前線程的執(zhí)行狀態(tài)。 |
| IsBackground | 獲取或設置一個值，該值指示某個線程是否為后臺線程。 |
| IsThreadPoolThread | 獲取一個值，該值指示線程是否屬于托管線程池。 |
| ManagedThreadId | 獲取當前托管線程的唯一標識符。 |
| Name | 獲取或設置線程的名稱。 |
| Priority | 獲取或設置一個值，該值指示線程的調(diào)度優(yōu)先級。 |
| ThreadState | 獲取一個值，該值包含當前線程的狀態(tài)。 |
2.2.1 線程的標識符
ManagedThreadId是確認線程的唯一標識符，程序在大部分情況下都是通過Thread.ManagedThreadId來辨別線程的。而Name是一個可變值，在默認時候，Name為一個空值 Null，開發(fā)人員可以通過程序設置線程的名稱，但這只是一個輔助功能。
?
2.2.2 線程的優(yōu)先級別
當線程之間爭奪CPU時間時，CPU按照線程的優(yōu)先級給予服務。高優(yōu)先級的線程可以完全阻止低優(yōu)先級的線程執(zhí)行。.NET為線程設置了Priority屬性來定義線程執(zhí)行的優(yōu)先級別，里面包含5個選項，其中Normal是默認值。除非系統(tǒng)有特殊要求，否則不應該隨便設置線程的優(yōu)先級別。
| Lowest | 可以將 Thread 安排在具有任何其他優(yōu)先級的線程之后。 |
| BelowNormal | 可以將 Thread 安排在具有?Normal 優(yōu)先級的線程之后，在具有?Lowest 優(yōu)先級的線程之前。 |
| Normal | 默認選擇。可以將 Thread 安排在具有?AboveNormal 優(yōu)先級的線程之后，在具有BelowNormal 優(yōu)先級的線程之前。 |
| AboveNormal | 可以將 Thread 安排在具有?Highest 優(yōu)先級的線程之后，在具有?Normal 優(yōu)先級的線程之前。 |
| Highest | 可以將 Thread 安排在具有任何其他優(yōu)先級的線程之前。 |
?
2.2.3 線程的狀態(tài)
通過ThreadState可以檢測線程是處于Unstarted、Sleeping、Running 等等狀態(tài)，它比 IsAlive 屬性能提供更多的特定信息。
前面說過，一個應用程序域中可能包括多個上下文，而通過CurrentContext可以獲取線程當前的上下文。
CurrentThread是最常用的一個屬性，它是用于獲取當前運行的線程。
?
2.2.4 System.Threading.Thread的方法
Thread 中包括了多個方法來控制線程的創(chuàng)建、掛起、停止、銷毀，以后來的例子中會經(jīng)常使用。
| Abort() | 終止本線程。 |
| GetDomain() | 返回當前線程正在其中運行的當前域。 |
| GetDomainId() | 返回當前線程正在其中運行的當前域Id。 |
| Interrupt() | 中斷處于 WaitSleepJoin 線程狀態(tài)的線程。 |
| Join() | 已重載。 阻塞調(diào)用線程，直到某個線程終止時為止。 |
| Resume() | 繼續(xù)運行已掛起的線程。 |
| Start() | 執(zhí)行本線程。 |
| Suspend() | 掛起當前線程，如果當前線程已屬于掛起狀態(tài)則此不起作用 |
| Sleep() | 把正在運行的線程掛起一段時間。 |
線程示例
1 static void Main(string[] args)2 {3 //獲取正在運行的線程4 Thread thread = Thread.CurrentThread;5 //設置線程的名字6 thread.Name = "主線程";7 //獲取當前線程的唯一標識符8 int id = thread.ManagedThreadId;9 //獲取當前線程的狀態(tài) 10 ThreadState state= thread.ThreadState; 11 //獲取當前線程的優(yōu)先級 12 ThreadPriority priority= thread.Priority; 13 string strMsg = string.Format("Thread ID:{0}\n" + "Thread Name:{1}\n" + 14 "Thread State:{2}\n" + "Thread Priority:{3}\n", id, thread.Name, 15 state, priority); 16 17 Console.WriteLine(strMsg); 18 19 Console.ReadKey(); 20 }運行結(jié)果:
2.3 前臺線程和后臺線程
前臺線程：只有所有的前臺線程都結(jié)束，應用程序才能結(jié)束。默認情況下創(chuàng)建的線程
????????????? 都是前臺線程
后臺線程：只要所有的前臺線程結(jié)束，后臺線程自動結(jié)束。通過Thread.IsBackground設置后臺線程。必須在調(diào)用Start方法之前設置線程的類型，否則一旦線程運行，將無法改變其類型。
通過BeginXXX方法運行的線程都是后臺線程。
1 class Program2 {3 static void Main(string[] args)4 { 5 //演示前臺、后臺線程6 BackGroundTest background = new BackGroundTest(10);7 //創(chuàng)建前臺線程8 Thread fThread = new Thread(new ThreadStart(background.RunLoop));9 //給線程命名 10 fThread.Name = "前臺線程"; 11 12 13 BackGroundTest background1 = new BackGroundTest(20); 14 //創(chuàng)建后臺線程 15 Thread bThread = new Thread(new ThreadStart(background1.RunLoop)); 16 bThread.Name = "后臺線程"; 17 //設置為后臺線程 18 bThread.IsBackground = true; 19 20 //啟動線程 21 fThread.Start(); 22 bThread.Start(); 23 } 24 } 25 26 class BackGroundTest 27 { 28 private int Count; 29 public BackGroundTest(int count) 30 { 31 this.Count = count; 32 } 33 public void RunLoop() 34 { 35 //獲取當前線程的名稱 36 string threadName = Thread.CurrentThread.Name; 37 for (int i = 0; i < Count; i++) 38 { 39 Console.WriteLine("{0}計數(shù)：{1}",threadName,i.ToString()); 40 //線程休眠500毫秒 41 Thread.Sleep(1000); 42 } 43 Console.WriteLine("{0}完成計數(shù)",threadName); 44 45 } 46 }運行結(jié)果：前臺線程執(zhí)行完，后臺線程未執(zhí)行完，程序自動結(jié)束。
把bThread.IsBackground = true注釋掉，運行結(jié)果：主線程執(zhí)行完畢后(Main函數(shù))，程序并未結(jié)束，而是要等所有的前臺線程結(jié)束以后才會結(jié)束。
后臺線程一般用于處理不重要的事情，應用程序結(jié)束時，后臺線程是否執(zhí)行完成對整個應用程序沒有影響。如果要執(zhí)行的事情很重要，需要將線程設置為前臺線程。
2.4 線程同步
所謂同步：是指在某一時刻只有一個線程可以訪問變量。
如果不能確保對變量的訪問是同步的，就會產(chǎn)生錯誤。
c#為同步訪問變量提供了一個非常簡單的方式，即使用c#語言的關鍵字Lock，它可以把一段代碼定義為互斥段，互斥段在一個時刻內(nèi)只允許一個線程進入執(zhí)行，而其他線程必須等待。在c#中，關鍵字Lock定義如下：
Lock(expression)
{
?? statement_block
}
expression代表你希望跟蹤的對象：
?????????? 如果你想保護一個類的實例，一般地，你可以使用this；
?????????? 如果你想保護一個靜態(tài)變量（如互斥代碼段在一個靜態(tài)方法內(nèi)部），一般使用類名就可以了
而statement_block就算互斥段的代碼，這段代碼在一個時刻內(nèi)只可能被一個線程執(zhí)行。
以書店賣書為例
1 class Program2 {3 static void Main(string[] args)4 { 5 BookShop book = new BookShop();6 //創(chuàng)建兩個線程同時訪問Sale方法7 Thread t1 = new Thread(new ThreadStart(book.Sale));8 Thread t2 = new Thread(new ThreadStart(book.Sale));9 //啟動線程 10 t1.Start(); 11 t2.Start(); 12 Console.ReadKey(); 13 } 14 } 15 16 17 18 class BookShop 19 { 20 //剩余圖書數(shù)量 21 public int num = 1; 22 public void Sale() 23 { 24 int tmp = num; 25 if (tmp > 0)//判斷是否有書，如果有就可以賣 26 { 27 Thread.Sleep(1000); 28 num -= 1; 29 Console.WriteLine("售出一本圖書，還剩余{0}本", num); 30 } 31 else 32 { 33 Console.WriteLine("沒有了"); 34 } 35 } 36 }?
運行結(jié)果：
從運行結(jié)果可以看出，兩個線程同步訪問共享資源，沒有考慮同步的問題，結(jié)果不正確。
考慮線程同步，改進后的代碼：
1 class Program2 {3 static void Main(string[] args)4 { 5 BookShop book = new BookShop();6 //創(chuàng)建兩個線程同時訪問Sale方法7 Thread t1 = new Thread(new ThreadStart(book.Sale));8 Thread t2 = new Thread(new ThreadStart(book.Sale));9 //啟動線程 10 t1.Start(); 11 t2.Start(); 12 Console.ReadKey(); 13 } 14 } 15 16 17 18 class BookShop 19 { 20 //剩余圖書數(shù)量 21 public int num = 1; 22 public void Sale() 23 { 24 //使用lock關鍵字解決線程同步問題 25 lock (this) 26 { 27 int tmp = num; 28 if (tmp > 0)//判斷是否有書，如果有就可以賣 29 { 30 Thread.Sleep(1000); 31 num -= 1; 32 Console.WriteLine("售出一本圖書，還剩余{0}本", num); 33 } 34 else 35 { 36 Console.WriteLine("沒有了"); 37 } 38 } 39 } 40 }運行結(jié)果：
2.5 跨線程訪問
點擊“測試”，創(chuàng)建一個線程，從0循環(huán)到10000給文本框賦值，代碼如下：
1 private void btn_Test_Click(object sender, EventArgs e)2 {3 //創(chuàng)建一個線程去執(zhí)行這個方法:創(chuàng)建的線程默認是前臺線程4 Thread thread = new Thread(new ThreadStart(Test));5 //Start方法標記這個線程就緒了，可以隨時被執(zhí)行，具體什么時候執(zhí)行這個線程，由CPU決定6 //將線程設置為后臺線程7 thread.IsBackground = true;8 thread.Start();9 } 10 11 private void Test() 12 { 13 for (int i = 0; i < 10000; i++) 14 { 15 this.textBox1.Text = i.ToString(); 16 } 17 }運行結(jié)果：
產(chǎn)生錯誤的原因：textBox1是由主線程創(chuàng)建的，thread線程是另外創(chuàng)建的一個線程，在.NET上執(zhí)行的是托管代碼，C#強制要求這些代碼必須是線程安全的，即不允許跨線程訪問Windows窗體的控件。
解決方案：
1、在窗體的加載事件中，將C#內(nèi)置控件(Control)類的CheckForIllegalCrossThreadCalls屬性設置為false，屏蔽掉C#編譯器對跨線程調(diào)用的檢查。
?private void Form1_Load(object sender, EventArgs e){//取消跨線程的訪問Control.CheckForIllegalCrossThreadCalls = false;}使用上述的方法雖然可以保證程序正常運行并實現(xiàn)應用的功能，但是在實際的軟件開發(fā)中，做如此設置是不安全的（不符合.NET的安全規(guī)范），在產(chǎn)品軟件的開發(fā)中，此類情況是不允許的。如果要在遵守.NET安全標準的前提下，實現(xiàn)從一個線程成功地訪問另一個線程創(chuàng)建的空間，要使用C#的方法回調(diào)機制。
2、使用回調(diào)函數(shù)
回調(diào)實現(xiàn)的一般過程：
?C#的方法回調(diào)機制，也是建立在委托基礎上的，下面給出它的典型實現(xiàn)過程。
（1）、定義、聲明回調(diào)。
1 //定義回調(diào) 2 private delegate void DoSomeCallBack(Type para); 3 //聲明回調(diào) 4 DoSomeCallBack doSomaCallBack;可以看出，這里定義聲明的“回調(diào)”（doSomaCallBack）其實就是一個委托。
（2）、初始化回調(diào)方法。
doSomeCallBack=new DoSomeCallBack(DoSomeMethod);
所謂“初始化回調(diào)方法”實際上就是實例化剛剛定義了的委托，這里作為參數(shù)的DoSomeMethod稱為“回調(diào)方法”，它封裝了對另一個線程中目標對象（窗體控件或其他類）的操作代碼。
（3）、觸發(fā)對象動作
Opt? obj.Invoke(doSomeCallBack,arg);
其中Opt obj為目標操作對象，在此假設它是某控件，故調(diào)用其Invoke方法。Invoke方法簽名為：
object? Control.Invoke(Delegate? method,params? object[] args);
它的第一個參數(shù)為委托類型，可見“觸發(fā)對象動作”的本質(zhì)，就是把委托doSomeCallBack作為參數(shù)傳遞給控件的Invoke方法，這與委托的使用方式是一模一樣的。
最終作用于對象Opt obj的代碼是置于回調(diào)方法體DoSomeMethod()中的，如下所示：
private void DoSomeMethod(type para)
{
???? //方法體
??? Opt obj.someMethod(para);
}
如果不用回調(diào)，而是直接在程序中使用“Opt obj.someMethod(para);”，則當對象Opt obj不在本線程（跨線程訪問）時就會發(fā)生上面所示的錯誤。
從以上回調(diào)實現(xiàn)的一般過程可知：C#的回調(diào)機制，實質(zhì)上是委托的一種應用。在C#網(wǎng)絡編程中，回調(diào)的應用是非常普遍的，有了方法回調(diào)，就可以在.NET上寫出線程安全的代碼了。
使用方法回調(diào)，實現(xiàn)給文本框賦值：
1 namespace MultiThreadDemo2 {3 public partial class Form1 : Form4 {5 public Form1()6 {7 InitializeComponent();8 }9 10 //定義回調(diào) 11 private delegate void setTextValueCallBack(int value); 12 //聲明回調(diào) 13 private setTextValueCallBack setCallBack; 14 15 private void btn_Test_Click(object sender, EventArgs e) 16 { 17 //實例化回調(diào) 18 setCallBack = new setTextValueCallBack(SetValue); 19 //創(chuàng)建一個線程去執(zhí)行這個方法:創(chuàng)建的線程默認是前臺線程 20 Thread thread = new Thread(new ThreadStart(Test)); 21 //Start方法標記這個線程就緒了，可以隨時被執(zhí)行，具體什么時候執(zhí)行這個線程，由CPU決定 22 //將線程設置為后臺線程 23 thread.IsBackground = true; 24 thread.Start(); 25 } 26 27 private void Test() 28 { 29 for (int i = 0; i < 10000; i++) 30 { 31 //使用回調(diào) 32 textBox1.Invoke(setCallBack, i); 33 } 34 } 35 36 /// <summary> 37 /// 定義回調(diào)使用的方法 38 /// </summary> 39 /// <param name="value"></param> 40 private void SetValue(int value) 41 { 42 this.textBox1.Text = value.ToString(); 43 } 44 } 45 }?
?2.6 終止線程
若想終止正在運行的線程，可以使用Abort（）方法。
三、同步和異步
同步和異步是對方法執(zhí)行順序的描述。
同步：等待上一行完成計算之后，才會進入下一行。
例如：請同事吃飯，同事說很忙，然后就等著同事忙完，然后一起去吃飯。
異步：不會等待方法的完成，會直接進入下一行，是非阻塞的。
例如：請同事吃飯，同事說很忙，那同事先忙，自己去吃飯，同事忙完了他自己去吃飯。
下面通過一個例子講解同步和異步的區(qū)別
1、新建一個winform程序，上面有兩個按鈕，一個同步方法、一個異步方法，在屬性里面把輸出類型改成控制臺應用程序，這樣可以看到輸出結(jié)果，代碼如下：
1 using System;2 using System.Collections.Generic;3 using System.ComponentModel;4 using System.Data;5 using System.Drawing;6 using System.Linq;7 using System.Text;8 using System.Threading;9 using System.Threading.Tasks; 10 using System.Windows.Forms; 11 12 namespace MyAsyncThreadDemo 13 { 14 public partial class Form1 : Form 15 { 16 public Form1() 17 { 18 InitializeComponent(); 19 } 20 21 /// <summary> 22 /// 異步方法 23 /// </summary> 24 /// <param name="sender"></param> 25 /// <param name="e"></param> 26 private void btnAsync_Click(object sender, EventArgs e) 27 { 28 Console.WriteLine($"***************btnAsync_Click Start {Thread.CurrentThread.ManagedThreadId}"); 29 Action<string> action = this.DoSomethingLong; 30 // 調(diào)用委托(同步調(diào)用) 31 action.Invoke("btnAsync_Click_1"); 32 // 異步調(diào)用委托 33 action.BeginInvoke("btnAsync_Click_2",null,null); 34 Console.WriteLine($"***************btnAsync_Click End {Thread.CurrentThread.ManagedThreadId}"); 35 } 36 37 /// <summary> 38 /// 同步方法 39 /// </summary> 40 /// <param name="sender"></param> 41 /// <param name="e"></param> 42 private void btnSync_Click(object sender, EventArgs e) 43 { 44 Console.WriteLine($"****************btnSync_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************"); 45 int j = 3; 46 int k = 5; 47 int m = j + k; 48 for (int i = 0; i < 5; i++) 49 { 50 string name = string.Format($"btnSync_Click_{i}"); 51 this.DoSomethingLong(name); 52 } 53 } 54 55 56 private void DoSomethingLong(string name) 57 { 58 Console.WriteLine($"****************DoSomethingLong {name} Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************"); 59 long lResult = 0; 60 for (int i = 0; i < 1000000000; i++) 61 { 62 lResult += i; 63 } 64 Console.WriteLine($"****************DoSomethingLong {name} End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} {lResult}***************"); 65 } 66 } 67 }?
?2、啟動程序，點擊同步，結(jié)果如下：
從上面的截圖中能夠很清晰的看出：同步方法是等待上一行代碼執(zhí)行完畢之后才會執(zhí)行下一行代碼。
點擊異步，結(jié)果如下：
從上面的截圖中看出：當執(zhí)行到action.BeginInvoke("btnAsync_Click_2",null,null);這句代碼的時候，程序并沒有等待這段代碼執(zhí)行完就執(zhí)行了下面的End，沒有阻塞程序的執(zhí)行。
在剛才的測試中，如果點擊同步，這時winform界面不能拖到，界面卡住了，是因為主線程(即UI線程)在忙于計算。
點擊異步的時候，界面不會卡住，這是因為主線程已經(jīng)結(jié)束，計算任務交給子線程去做。
在仔細檢查上面兩個截圖，可以看出異步的執(zhí)行速度比同步執(zhí)行速度要快。同步方法執(zhí)行完將近16秒，異步方法執(zhí)行完將近6秒。
在看下面的一個例子，修改異步的方法，也和同步方法一樣執(zhí)行循環(huán)，修改后的代碼如下：
1 private void btnAsync_Click(object sender, EventArgs e)2 {3 Console.WriteLine($"***************btnAsync_Click Start {Thread.CurrentThread.ManagedThreadId}");4 //Action<string> action = this.DoSomethingLong;5 調(diào)用委托(同步調(diào)用)6 //action.Invoke("btnAsync_Click_1");7 異步調(diào)用委托8 //action.BeginInvoke("btnAsync_Click_2",null,null);9 Action<string> action = this.DoSomethingLong; 10 for (int i = 0; i < 5; i++) 11 { 12 //Thread.Sleep(5); 13 string name = string.Format($"btnAsync_Click_{i}"); 14 action.BeginInvoke(name, null, null); 15 } 16 Console.WriteLine($"***************btnAsync_Click End {Thread.CurrentThread.ManagedThreadId}"); 17 }?結(jié)果如下：
從截圖中能夠看出：同步方法執(zhí)行是有序的，異步方法執(zhí)行是無序的。異步方法無序包括啟動無序和結(jié)束無序。啟動無序是因為同一時刻向操作系統(tǒng)申請線程，操作系統(tǒng)收到申請以后，返回執(zhí)行的順序是無序的，所以啟動是無序的。結(jié)束無序是因為雖然線程執(zhí)行的是同樣的操作，但是每個線程的耗時是不同的，所以結(jié)束的時候不一定是先啟動的線程就先結(jié)束。從上面同步方法中可以清晰的看出：btnSync_Click_0執(zhí)行時間耗時不到3秒，而btnSync_Click_1執(zhí)行時間耗時超過了3秒。可以想象體育比賽中的跑步，每位運動員聽到發(fā)令槍起跑的順序不同，每位運動員花費的時間不同，最終到達終點的順序也不同。
總結(jié)一下同步方法和異步方法的區(qū)別：
1、同步方法由于主線程忙于計算，所以會卡住界面。
? ? ? 異步方法由于主線程執(zhí)行完了，其他計算任務交給子線程去執(zhí)行，所以不會卡住界面，用戶體驗性好。
2、同步方法由于只有一個線程在計算，所以執(zhí)行速度慢。
? ? ? 異步方法由多個線程并發(fā)運算，所以執(zhí)行速度快，但并不是線性增長的（資源可能不夠）。多線程也不是越多越好，只有多個獨立的任務同時運行，才能加快速度。
3、同步方法是有序的。
? ? ? 異步多線程是無序的：啟動無序，執(zhí)行時間不確定，所以結(jié)束也是無序的。一定不要通過等待幾毫秒的形式來控制線程啟動/執(zhí)行時間/結(jié)束。
四、回調(diào)
先來看看異步多線程無序的例子：
在界面上新增一個按鈕，實現(xiàn)代碼如下：
1 private void btnAsyncAdvanced_Click(object sender, EventArgs e) 2 { 3 Console.WriteLine($"****************btnAsyncAdvanced_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************"); 4 Action<string> action = this.DoSomethingLong; 5 action.BeginInvoke("btnAsyncAdvanced_Click", null, null); 6 // 需求：異步多線程執(zhí)行完之后再打印出下面這句 7 Console.WriteLine($"到這里計算已經(jīng)完成了。{Thread.CurrentThread.ManagedThreadId.ToString("00")}。"); 8 Console.WriteLine($"****************btnAsyncAdvanced_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************"); 9 }?
運行結(jié)果：
從上面的截圖中看出，最終的效果并不是我們想要的效果，而且打印輸出的還是主線程。
既然異步多線程是無序的，那我們有沒有什么辦法可以解決無序的問題呢？辦法當然是有的，那就是使用回調(diào)，.NET框架已經(jīng)幫我們實現(xiàn)了回調(diào)：
BeginInvoke的第二個參數(shù)就是一個回調(diào)，那么AsyncCallback究竟是什么呢？F12查看AsyncCallback的定義：
發(fā)現(xiàn)AsyncCallback就是一個委托，參數(shù)類型是IAsyncResult，明白了AsyncCallback是什么以后，將上面的代碼進行如下的改造：
1 private void btnAsyncAdvanced_Click(object sender, EventArgs e)2 { 3 Console.WriteLine($"****************btnAsyncAdvanced_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");4 Action<string> action = this.DoSomethingLong;5 // 定義一個回調(diào)6 AsyncCallback callback = p => 7 {8 Console.WriteLine($"到這里計算已經(jīng)完成了。{Thread.CurrentThread.ManagedThreadId.ToString("00")}。");9 }; 10 // 回調(diào)作為參數(shù) 11 action.BeginInvoke("btnAsyncAdvanced_Click", callback, null); 12 Console.WriteLine($"****************btnAsyncAdvanced_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************"); 13 }?
運行結(jié)果：
上面的截圖中可以看出，這就是我們想要的效果，而且打印是子線程輸出的，但是程序究竟是怎么實現(xiàn)的呢？我們可以進行如下的猜想：
程序執(zhí)行到BeginInvoke的時候，會申請一個基于線程池的線程，這個線程會完成委托的執(zhí)行(在這里就是執(zhí)行DoSomethingLong()方法)，在委托執(zhí)行完以后，這個線程又會去執(zhí)行callback回調(diào)的委托，執(zhí)行callback委托需要一個IAsyncResult類型的參數(shù)，這個IAsyncResult類型的參數(shù)是如何來的呢？鼠標右鍵放到BeginInvoke上面，查看返回值：
發(fā)現(xiàn)BeginInvoke的返回值就是IAsyncResult類型的。那么這個返回值是不是就是callback委托的參數(shù)呢？將代碼進行如下的修改：
1 private void btnAsyncAdvanced_Click(object sender, EventArgs e)2 {3 // 需求：異步多線程執(zhí)行完之后再打印出下面這句4 Console.WriteLine($"****************btnAsyncAdvanced_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");5 Action<string> action = this.DoSomethingLong;6 // 無序的7 //action.BeginInvoke("btnAsyncAdvanced_Click", null, null);8 9 IAsyncResult asyncResult = null; 10 // 定義一個回調(diào) 11 AsyncCallback callback = p => 12 { 13 // 比較兩個變量是否是同一個 14 Console.WriteLine(object.ReferenceEquals(p,asyncResult)); 15 Console.WriteLine($"到這里計算已經(jīng)完成了。{Thread.CurrentThread.ManagedThreadId.ToString("00")}。"); 16 }; 17 // 回調(diào)作為參數(shù) 18 asyncResult= action.BeginInvoke("btnAsyncAdvanced_Click", callback, null); 19 Console.WriteLine($"****************btnAsyncAdvanced_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************"); 20 }?結(jié)果：
這里可以看出BeginInvoke的返回值就是callback委托的參數(shù)。
現(xiàn)在我們可以使用回調(diào)解決異步多線程無序的問題了。
2、獲取委托異步調(diào)用的返回值
使用EndInvoke可以獲取委托異步調(diào)用的返回值，請看下面的例子：
1 private void btnAsyncReturnVlaue_Click(object sender, EventArgs e)2 {3 // 定義一個無參數(shù)、int類型返回值的委托4 Func<int> func = () =>5 {6 Thread.Sleep(2000);7 return DateTime.Now.Day;8 };9 // 輸出委托同步調(diào)用的返回值 10 Console.WriteLine($"func.Invoke()={func.Invoke()}"); 11 // 委托的異步調(diào)用 12 IAsyncResult asyncResult = func.BeginInvoke(p => 13 { 14 Console.WriteLine(p.AsyncState); 15 },"異步調(diào)用返回值"); 16 // 輸出委托異步調(diào)用的返回值 17 Console.WriteLine($"func.EndInvoke(asyncResult)={func.EndInvoke(asyncResult)}"); 18 }?結(jié)果：
?
總結(jié)
- 上一篇： 【转】理解SQL Server的安全对象
- 下一篇： SharePoint 2007 and