前言

　　本文大部分內(nèi)容來自于mikeperetz的Asynchronous Method Invocation及本人的一些個人體會所得，希望對你有所幫助。原英文文獻可以在codeproject中搜索到。

介紹

　　這篇文章將介紹異步調(diào)用的實現(xiàn)機制及如何調(diào)用異步方法。大多數(shù).NET開發(fā)者在經(jīng)過delegate、Thread、AsynchronousInvocation之后，通常都會對以上概念產(chǎn)生混淆及誤用。實際上，以上概念是.NET2.0版本中對并行編程的核心支持，基于概念上的錯誤認識有可能導致在實際的編程中，無法利用異步調(diào)用的特性優(yōu)化我們的程序，例如大數(shù)據(jù)量加載引起的窗體”假死”。事實上這并不是一個困難的問題，該文將以一種逐層深入、抽絲剝繭的方式逐漸深入到異步編程的學習中。

同步與異步

　　大多數(shù)人并不喜歡閱讀大量的文字說明，而喜歡直接閱讀代碼，因此，我們在下文中將主要以代碼的形式闡述同步與異步的調(diào)用。

同步方法調(diào)用

　　假設我們有一個函數(shù)，它的功能是將當前線程掛起3秒鐘。

static void Sleep()
{
Thread.Sleep(3000);
}

　　通常，當你的程序在調(diào)用Sleep后，它將等待3秒鐘的時間，在這3秒鐘時間內(nèi)，你不能做任何其他操作。3秒之后，控制權被交回給調(diào)用線程（通常也就是你的主線程，即WinForm程序的UI線程）。這種類型的調(diào)用稱為同步，本次調(diào)用順序如下：

　　●  調(diào)用Sleep()；

　　●  Sleep()執(zhí)行中；

　　●  Sleep()執(zhí)行完畢，控制權歸還調(diào)用線程。

　　我們再次調(diào)用Sleep()函數(shù)，不同的是，我們要基于委托來完成這次調(diào)用。一般為了將函數(shù)綁定在委托中，我們要定義與函數(shù)返回類型、參數(shù)值完全一致的委托，這稍有點麻煩。但.NET內(nèi)部已經(jīng)為我們定義好了一些委托，例如MethodInvoker，這是一種無返回值、無參數(shù)的委托簽名，這相當于你自定義了一種委托：

public delegate void SimpleHandler();

　　執(zhí)行以下代碼：

MethodInvoker invoker = new MethodInvoker(Sleep);
invoker.Invoke();

　　我們使用了委托,但依然是同步的方式。主線程仍然要等待3秒的掛起，然后得到響應。

注意：Delegate.Invoke是同步方式的。

異步方法調(diào)用

　　如何在調(diào)用Sleep()方法的同時，使主線程可以不必等待Sleep()的完成，一直能夠得到相應呢？這很重要，它意味著在函數(shù)執(zhí)行的同時，主線程依然是非阻塞狀態(tài)。在后臺服務類型的程序中，非阻塞的狀態(tài)意味著該應用服務可以在等待一項任務的同時去接受另一項任務；在傳統(tǒng)的WinForm程序中，意味著主線程(即UI線程)依然可以對用戶的操作得到響應，避免了”假死”。我們繼續(xù)調(diào)用Sleep()函數(shù)，但這次要引入BeginInvoke。

MethodInvoker invoker = new MethodInvoker(Sleep);
invoker.BeginInvoke(null, null);

　　● 注意BeginInvoke這行代碼，它會執(zhí)行委托所調(diào)用的函數(shù)體。同時，調(diào)用BeginInvoke方法的線程(以下簡稱為調(diào)用線程)會立即得到響應，而不必等待Sleep()函數(shù)    的完成。

　　● 以上代碼是異步的，調(diào)用線程完全可以在調(diào)用函數(shù)的同時處理其他工作，但是不足的是我們?nèi)匀徊恢缹τ赟leep()函數(shù)的調(diào)用何時會結束，這是下文將要解決的問    題。

　　● eginInvoke可以以異步的方式完全取代Invoke，我們也不必擔心函數(shù)包含參數(shù)的情況，下文介紹傳值問題。

注意：Delegate.BeginInvoke是異步方式的。如果你要執(zhí)行一項任務，但并不關心它何時完成，我們就可以使用BeginInvoke，它不會帶來調(diào)用線程的阻塞。

對于異步調(diào)用，.NET內(nèi)部究竟做了什么？

　　一旦你使用.NET完成了一次異步調(diào)用，它都需要一個線程來處理異步工作內(nèi)容(以下簡稱異步線程)，異步線程不可能是當前的調(diào)用線程，因為那樣仍然會造成調(diào)用線程的阻塞，與同步無異。事實上，.NET會將所有的異步請求隊列加入線程池，以線程池內(nèi)的線程處理所有的異步請求。對于線程池似乎不必了解的過于深入，但我們?nèi)孕枰P注以下幾點內(nèi)容：

　　● ; Sleep()的異步調(diào)用會在一個單獨的線程內(nèi)執(zhí)行，這個線程來自于.NET線程池。

　　●  .NET線程池默認包含25個線程，你可以改變這個值的上限，每次異步調(diào)用都會使用其中某個線程執(zhí)行，但我們并不能控制具體使用哪一個線程。

　　●  線程池具備最大線程數(shù)目上限，一旦所有的線程都處于忙碌狀態(tài)，那么新的異步調(diào)用將會被置于等待隊列，直到線程池產(chǎn)生了新的可用線程，因此對于大量異步請      求，我們有必要關注請求數(shù)量，否則可能造成性能上的影響。

簡單了解線程池

　　為了暴露線程池的上限，我們修改Sleep()函數(shù)，將線程掛起的時間延長至30s。在代碼的運行輸出結果中，我們需要關注以下內(nèi)容：

　　●  線程池內(nèi)的可用線程數(shù)量。

　　●  異步線程是否來自于線程池。

　　●  線程托管ID值。

　　上文已經(jīng)提到，.NET線程池默認包含25個線程，因此我們連續(xù)調(diào)用30次異步方法，這樣可以在第25次調(diào)用后，看看線程池內(nèi)部究竟發(fā)生了什么。

private void Sleep()
{
int intAvailableThreads, intAvailableIoAsynThreds;

// 取得線程池內(nèi)的可用線程數(shù)目，我們只關心第一個參數(shù)即可
ThreadPool.GetAvailableThreads(out intAvailableThreads,
out intAvailableIoAsynThreds);

// 線程信息
string strMessage =
String.Format("是否是線程池線程：{0},線程托管ID：{1},可用線程數(shù)：{2}",
Thread.CurrentThread.IsThreadPoolThread.ToString(),
Thread.CurrentThread.GetHashCode(),
intAvailableThreads);

Console.WriteLine(strMessage);

Thread.Sleep(30000);
}

private void CallAsyncSleep30Times()
{
// 創(chuàng)建包含Sleep函數(shù)的委托對象
MethodInvoker invoker = new MethodInvoker(Sleep);

for (int i = 0; i < 30; i++)
{
// 以異步的形式，調(diào)用Sleep函數(shù)30次
invoker.BeginInvoke(null, null);
}
}

　　輸出結果：

　　對于輸出結果，我們可以總結為以下內(nèi)容：

　　●  所有的異步線程都來自于.NET線程池。

　　●  每次執(zhí)行一次異步調(diào)用，便產(chǎn)生一個新的線程；同時可用線程數(shù)目減少。

　　●  在執(zhí)行異步調(diào)用25次后，線程池中不再有空閑線程。此時，應用程序會等待空閑線程的產(chǎn)生。

　　●  一旦線程池內(nèi)產(chǎn)生了空閑線程，它會立即被分配給異步任務等待隊列，之后線程池中仍然不具備空閑線程，應用程序主線程進入掛起狀態(tài)繼續(xù)等待空閑線程，這樣      的調(diào)用一直持續(xù)到異步調(diào)用被執(zhí)行完30次。

　　針對以上結果，我們對于異步調(diào)用可以總結為以下內(nèi)容：

　　●  每次異步調(diào)用都在新的線程中執(zhí)行，這個線程來自于.NET線程池。

　　●  線程池有自己的執(zhí)行上限，如果你想要執(zhí)行多次耗費時間較長的異步調(diào)用，那么線程池有可能進入一種”線程饑餓”狀態(tài)，去等待可用線程的產(chǎn)生。

BeginInvoke和EndInvoke

　　我們已經(jīng)知道，如何在不阻塞調(diào)用線程的情況下執(zhí)行一個異步調(diào)用，但我們無法得知異步調(diào)用的執(zhí)行結果，及它何時執(zhí)行完畢。為了解決以上問題，我們可以使用EndInvoke。EndInvoke在異步方法執(zhí)行完成前，都會造成線程的阻塞。因此，在調(diào)用BeginInvoke之后調(diào)用EndInvoke，效果幾乎完全等同于以阻塞模式執(zhí)行你的函數(shù)(EndInvoke會使調(diào)用線程掛起，一直到異步函數(shù)執(zhí)行完畢)。但是，.NET是如何將BeginInvoke和EndInvoke進行綁定呢？答案就是IAsyncResult。每次我們使用BeginInvoke，返回值都是IAsyncResult類型，它是.NET追蹤異步調(diào)用的關鍵值。每次異步調(diào)用之后的結果如何？如果要了解具體執(zhí)行結果，IAsyncResult便可視為一個標簽。通過這個標簽，你可以了解異步調(diào)用何時執(zhí)行完畢，更重要的是，它可以保存異步調(diào)用的參數(shù)傳值，解決異步函數(shù)上下文問題。

　　我們現(xiàn)在通過幾個例子來了解IAsyncResult。如果之前對它了解不多，那么就需要耐心的將它領悟，因為這種類型的調(diào)用是.NET異步調(diào)用的關鍵內(nèi)容。

private void SleepOneSecond()
{
// 當前線程掛起1秒
Thread.Sleep(1000);
}

private void UsingEndInvoke()
{
// 創(chuàng)建一個指向SleepOneSecond的委托
MethodInvoker invoker = new MethodInvoker(SleepOneSecond);

// 開始執(zhí)行SleepOneSecond，但這次異步調(diào)用我們傳遞一些參數(shù)
// 觀察Delegate.BeginInvoke()的第二個參數(shù)
IAsyncResult tag = invoker.BeginInvoke(null, "passing some state");

// 應用程序在此處會造成阻塞，直到SleepOneSecond執(zhí)行完成
invoker.EndInvoke(tag);

// EndInvoke執(zhí)行完畢，取得之前傳遞的參數(shù)內(nèi)容
string strState = (string)tag.AsyncState;

Console.WriteLine("EndInvoke的傳遞參數(shù)" + tag.AsyncState.ToString());
}

　　輸出結果：

　　回到文章初始提到的”窗體動態(tài)更新”問題，如果你將上述代碼運行在一個WinForm程序中，會發(fā)現(xiàn)窗體依然陷入”假死”。對于這種情況，你可能會陷入疑惑：之前說異步函數(shù)都執(zhí)行在線程池中，因此可以肯定異步函數(shù)的執(zhí)行不會引起UI線程的忙碌，但為什么窗體依然陷入了”假死”？問題就在于EndInvoke。EndInvoke此時扮演的角色就是”線程鎖”，它充當了一個調(diào)用線程與異步線程之間的調(diào)度器，有時調(diào)用線程需要使用異步函數(shù)的執(zhí)行結果，那么調(diào)度線程就需要在異步執(zhí)行完之前一直等待，直到得到結果方可繼續(xù)運行。EndInvoke一方面負責監(jiān)聽異步函數(shù)的執(zhí)行狀況，一方面將調(diào)用線程掛起。

　　因此在Win Form環(huán)境下，UI線程的&rdquo;假死”并不是因為線程忙碌造成，而是被EndInvoke”善意的”暫時封鎖，它只是為了等待異步函數(shù)的完成。

　　我們可以對EndInvoke總結如下：

　　●  在執(zhí)行EndInvoke時，調(diào)用線程會進入掛起狀態(tài)，一直到異步函數(shù)執(zhí)行完成。

　　●  使用EndInvoke可以使應用程序得知異步函數(shù)何時執(zhí)行完畢。

　　●  如果將上述寫法稱為”異步”，你一定覺得這種”異步”徒具其名，雖然知道異步函數(shù)何時執(zhí)行完畢，也得到了異步函數(shù)的傳值，但我們的調(diào)用線程仍然會等待函數(shù)執(zhí)行完畢，在等待過程中線程阻塞，實際上與同步調(diào)用無異。

如何捕捉異常？

　　現(xiàn)在我們把問題稍微復雜化，考慮異步函數(shù)拋出異常的一種情形。我們需要了解在何處捕捉到異常，是BeginInvoke，還是EndInvoke？甚至是有沒有可能無法捕捉異常？答案是EndInvoke。BeginInvoke的工作只是開始線程池對于異步函數(shù)的執(zhí)行工作，EndInvoke則需要處理函數(shù)執(zhí)行完成的所有信息，包括其中產(chǎn)生的異常。

private void SleepOneSecond()
{
Thread.Sleep(3000);

throw new Exception("Here Is An Async Function Exception");
}

private void UsingEndInvoke()
{
// 創(chuàng)建一個指向SleepOneSecond的委托
MethodInvoker invoker = new MethodInvoker(SleepOneSecond);

// 開始執(zhí)行SleepOneSecond，但這次異步調(diào)用我們傳遞一些參數(shù)
// 觀察Delegate.BeginInvoke()的第二個參數(shù)
IAsyncResult tag = invoker.BeginInvoke(null, "passing some state");

try
{
// 應用程序在此處會造成阻塞，直到SleepOneSecond執(zhí)行完成
invoker.EndInvoke(tag);
}
catch (Exception ex)
{
// 此處可以捕捉異常
MessageBox.Show(ex.Message);
}

// EndInvoke執(zhí)行完畢，取得之前傳遞的參數(shù)內(nèi)容
string strState = (string)tag.AsyncState;

Console.WriteLine("EndInvoke的傳遞參數(shù)" + tag.AsyncState.ToString());
}

　　執(zhí)行以上代碼后，你將發(fā)現(xiàn)只有在使用EndInvoke時，才會捕捉到異常，否則異常將丟失。需要注意的是，直接在編譯器中運行程序是無法產(chǎn)生捕獲異常的，只有在Debug、Release環(huán)境下運行，異常才會以對話框的形式直接彈出。

向函數(shù)中傳遞參數(shù)

　　現(xiàn)在我們來改變一下異步函數(shù)，讓它接收一些參數(shù)。

private string FuncWithParameters(int param1, string param2, ArrayList param3)
{
// 我們在這里改變參數(shù)值
param1 = 100;
param2 = "hello";
param3 = new ArrayList();

return "thank you for reading me";
}

　　下面我們使用BeginInvoke與EndInvoke來調(diào)用這個函數(shù)，首先，我們創(chuàng)建一個匹配該函數(shù)的委托簽名。

public delegate string DelegateWithParameters(int param1, string param2, ArrayList param3);

　　我們可以將BeginInvoke和EndInvoke視為將異步函數(shù)分割為兩部分的特殊函數(shù)。BeginInvoke通過自己的兩個參數(shù)值(一個AsyncCallBack委托，一個object對象)來接收傳入?yún)?shù)，EndInvoke用于計算傳出參數(shù)(標記了out或者ref的參數(shù))和函數(shù)返回值。

　　現(xiàn)在我們回到自己的函數(shù)FuncWithParameters，param1、param2、param3是傳入值，同時，它們也作為BeginInvoke的參數(shù)來處理；函數(shù)的返回值是string類型，它將作為EndInvoke的返回類型。比較酷的是，編譯器可以通過委托類型，來自動為BeginInvoke和EndInvoke生成正確的參數(shù)與返回值類型。

　　注意我們在異步函數(shù)中為參數(shù)分配了新的值，這樣可以檢驗這些參數(shù)在調(diào)用異步函數(shù)后，究竟會傳出什么樣的值……

private void CallFuncWithParameters()
{
// 創(chuàng)建幾個參數(shù)
string strParam = "Param1";
int intValue = 100;
ArrayList list = new ArrayList();
list.Add("Item1");

// 創(chuàng)建委托對象
DelegateWithParameters delFoo =
new DelegateWithParameters(FuncWithParameters);

// 調(diào)用異步函數(shù)
IAsyncResult tag =
delFoo.BeginInvoke(intValue, strParam, list, null, null);

// 通常調(diào)用線程會立即得到響應
// 因此你可以在這里進行一些其他處理

// 執(zhí)行EndInvoke來取得返回值
string strResult = delFoo.EndInvoke(tag);

Trace.WriteLine("param1: " + intValue);
Trace.WriteLine("param2: " + strParam);
Trace.WriteLine("ArrayList count: " + list.Count);
}

　　我們的異步函數(shù)對參數(shù)的改變并沒有影響其傳出值，現(xiàn)在我們把ArrayList變?yōu)閞ef參數(shù)，看看會給EndInvoke帶來什么變化。

public delegate string DelegateWithParameters(out int param1, string param2, ref ArrayList param3);

private string FuncWithParameters(out int param1, string param2, ref ArrayList param3)
{
// 我們在這里改變參數(shù)值
param1 = 300;
param2 = "hello";
param3 = new ArrayList();

return "thank you for reading me";
}

private void CallFuncWithParameters()
{
// 創(chuàng)建幾個參數(shù)
string strParam = "Param1";
int intValue = 100;
ArrayList list = new ArrayList();
list.Add("Item1");

// 創(chuàng)建委托對象
DelegateWithParameters delFoo =
new DelegateWithParameters(FuncWithParameters);

// 調(diào)用異步函數(shù)
IAsyncResult tag =
delFoo.BeginInvoke(out intValue, strParam, ref list, null, null);

// 通常調(diào)用線程會立即得到響應
// 因此你可以在這里進行一些其他處理

// 調(diào)用EndInvoke，發(fā)現(xiàn)intValue和list可以作為參數(shù)被傳出，
// 是因為他們可以被異步函數(shù)更新
string strResult = delFoo.EndInvoke(out intValue, ref list, null);

Trace.WriteLine("param1: " + intValue);
Trace.WriteLine("param2: " + strParam);
Trace.WriteLine("ArrayList count: " + list.Count);
}

　　param2沒有變化，因為它是輸入?yún)?shù)；param1作為輸出參數(shù)，被更新為300；ArrayList的值已被重新分配，我們可以發(fā)現(xiàn)它的引用被指向了一個空元素的ArrayList對象(初始引用已丟失)。通過以上實例，我們應該能理解參數(shù)是如何在BeginInvoke與EndInvoke之間傳遞的。現(xiàn)在我們來嘗試完成一個非阻塞模式下的異步調(diào)用，這是個重頭戲！