.Net的異步機制(APM核心:IAsyncResult) - step 3

在上一篇文章(什麼是.Net的異步機制(Invoke,BeginInvoke,EndInvoke) - step 2 ), 我們已經簡單介紹了異步的調用方式, 下面我們來看看異步的核心.

異步的核心: IAsyncResult

Asynchronous Programming Model

整個異步調用過程中都是圍繞IAsyncResult來進行的,大家可以看看上篇文章的例子,BeginXXX 傳回這個對象,EndXXX接收這個對象來結束目前異步對象,下面我們來看看IAsyncResult 接口成員/和實作此接口的AsyncResult類成員(其中有些在上篇中已經涉及到)

IAsyncResult接口

1

public   interface  IAsyncResult

2

{

3

        WaitHandle AsyncWaitHandle 

{ get; } //阻塞一個線程，直到一個或多個同步對象接收到信号

4

        Boolean IsCompleted 

{ get; } //判讀目前異步是否完成

5

        Object AsyncState 

{ get; } //擷取額外的參數值,請看上一篇文章的Code 4.3

6

        Boolean CompletedSynchronously 

{ get; } //幾乎沒有使用

7

    }

AsyncResult類

 1

     public   class  AsyncResult : IAsyncResult, IMessageSink

 2

{

 3

        //IAsyncResult 的實作      

 4

        public virtual WaitHandle AsyncWaitHandle 

{ get; }

 5

        public virtual bool IsCompleted 

{ get; }

 6

        public virtual object AsyncState 

{ get; }

 7

        public virtual bool CompletedSynchronously 

{ get; }

 8

 9

        // 其他一些重要的屬性

10

        public bool EndInvokeCalled 

{ get; set; } //檢驗是否調用了EndInvoke()

11

        public virtual object AsyncDelegate 

{ get; } //擷取原始的委托對象,可檢視上一篇文章中的Code 4.1/4.2/5

12

    }

注意:基本上都是隻讀屬性

下面我們來看看異步的執行順序,并回顧下 IAsyncResult 下各個屬性的應用,如果還是不熟悉請看前2篇文章.

Code 1:

 1

    class  Program

 2

{

 3

        static void Main(string[] args)

 4

{

 5

            Console.WriteLine("[(#{1}){0}]:Asynchronous Start", DateTime.Now.ToString(), Thread.CurrentThread.ManagedThreadId);

 6

 7

            AsyncTest test = new AsyncTest();

 8

            MyThirdAsyncCode.AsyncTest.SalaryEventHandler del = test.YearlySalary;

 9

            //使用回調函數

10

            AsyncCallback callback = new AsyncCallback(OnSalaryCallback);

11

            IAsyncResult ar = del.BeginInvoke(100000, 15, 100000, callback, 2000);

12

13

            DoAntherJob();

14

            Console.ReadLine(); // 讓黑屏等待,不會直接關閉..

15

        }

16

17

        //開始其他工作.

18

        static void DoAntherJob()

19

{

20

            Thread.Sleep(1000);//需要1秒才能完成這個工作,注1

21

            Console.WriteLine("[(#{1}){0}]:Do Another Job", DateTime.Now.ToString(), Thread.CurrentThread.ManagedThreadId);

22

        }

23

24

        static void OnSalaryCallback(IAsyncResult asyncResult)

25

{

26

            //通過AsyncState 擷取額外的參數.

27

            decimal para = (int)asyncResult.AsyncState;

28

29

            //通過AsyncDelegate 擷取原始的委托對象

30

            AsyncResult obj = (AsyncResult)asyncResult;

31

            MyThirdAsyncCode.AsyncTest.SalaryEventHandler del =

(MyThirdAsyncCode.AsyncTest.SalaryEventHandler)obj.AsyncDelegate;

32

33

            if (asyncResult.IsCompleted)// 判讀是否已經調用完成

34

                Console.WriteLine("[(#{1}){0}]:Asynchronous Finished.", DateTime.Now.ToString(), Thread.CurrentThread.ManagedThreadId);

35

36

            decimal val = del.EndInvoke(asyncResult);

37

38

            Console.WriteLine("[(#{2}){0}]:Output Result:{1}", DateTime.Now.ToString(), val + para, Thread.CurrentThread.ManagedThreadId);

39

        }

40

    }

41

42

     public   class  AsyncTest

43

{

44

        public delegate decimal SalaryEventHandler(decimal salary, int monthCount, decimal bonus); // 對應YearlySalary方法

45

        public decimal YearlySalary(decimal salary, int monthCount, decimal bonus)

46

{

47

            //模拟耗時/複雜的邏輯計算.

48

            Thread.Sleep(3000);//等待3秒,注2

49

            return salary * monthCount + bonus;

50

        }

51

    }

圖1

我們看到DoAntherJob 比異步YearlySalary快2秒,看代碼中(注1)和(注2),兩個線程的執行結果

接下來,我們說說AsyncWaitHandle 屬性. 他傳回WaitHandle對象(System.Threading.WaitHandle), 他有3個重要的方法. WaitOne / WaitAny / WaitAll ,我們先來說下WaitOne,在Code1代碼基礎上隻是增加了下面紅色部分.

1,WaitOne

Code 1.1

IAsyncResult ar = del.BeginInvoke(100000, 15, 100000, callback, 2000);

//阻礙目前線程,直到異步調用結束.

ar.AsyncWaitHandle.WaitOne();

//開始其他工作.

DoAntherJob();

圖1.1

執行輸出,對比圖1我們可以看到執行的次序不一樣了(看時間),調用WaitOne,會阻礙目前線程,直到異步完成,才釋放目前的線程, WaitOne 提供了時間的重載版本WaitOne(int millisecondsTimeout)/ WaitOne(TimeSpan timeout);來判斷阻礙的時間.無參的版本是無限等待的(直到異步調用結束)

2, WaitAll

我們在Code1的代碼基礎上加上Hello的異步調用(使Main提供多個異步調用),注意紅色部分.

Code 1.2

 1

     class  Program

 2

{

 3

        static void Main(string[] args)

 4

{

 5

            Console.WriteLine("[(#{1}){0}]:Asynchronous Start", DateTime.Now.ToString(), Thread.CurrentThread.ManagedThreadId);

 6

 7

            AsyncTest test = new AsyncTest();

 8

            MyThirdAsyncCode.AsyncTest.SalaryEventHandler del = test.YearlySalary;

 9

            MyThirdAsyncCode.AsyncTest.AsyncEventHandler asy = test.Hello;

10

11

            IAsyncResult salayAsyc = del.BeginInvoke(100000, 15, 100000, OnSalaryCallback, null);

12

            IAsyncResult helloAsyc = asy.BeginInvoke("Hello Andy", OnHelloCallback, null);

13

            //把所有異步的句柄儲存到WaitHandle 對象中

14

            WaitHandle[] handles = 

{ salayAsyc.AsyncWaitHandle, helloAsyc.AsyncWaitHandle };

15

            //阻礙目前線程,直到所有異步調用結束.

16

            WaitHandle.WaitAll(handles);

17

18

            //開始其他工作.

19

            DoAntherJob();

20

            Console.ReadLine(); // 讓黑屏等待,不會直接關閉..

21

        }

22

        static void DoAntherJob()

23

{

24

            Thread.Sleep(1000);//需要1秒才能完成這個工作,注1

25

            Console.WriteLine("[(#{1}){0}]:Do Another Job", DateTime.Now.ToString(), Thread.CurrentThread.ManagedThreadId);

26

        }

27

        static void OnSalaryCallback(IAsyncResult asyncResult)

28

{

29

            //通過AsyncDelegate 擷取原始的委托對象

30

            AsyncResult obj = (AsyncResult)asyncResult;

31

            MyThirdAsyncCode.AsyncTest.SalaryEventHandler del =

(MyThirdAsyncCode.AsyncTest.SalaryEventHandler)obj.AsyncDelegate;

32

33

            if (asyncResult.IsCompleted)// 判讀是否已經調用完成

34

                Console.WriteLine("[(#{1}){0}]:Asynchronous Finished.", DateTime.Now.ToString(), Thread.CurrentThread.ManagedThreadId);

35

36

            decimal val = del.EndInvoke(asyncResult);

37

            Console.WriteLine("[(#{2}){0}]:Output Result:{1}", DateTime.Now.ToString(), val, Thread.CurrentThread.ManagedThreadId);

38

        }

39

40

        static void OnHelloCallback(IAsyncResult asyncResult)

41

{

42

            //通過AsyncDelegate 擷取原始的委托對象

43

            AsyncResult obj = (AsyncResult)asyncResult;

44

            MyThirdAsyncCode.AsyncTest.AsyncEventHandler del =

(MyThirdAsyncCode.AsyncTest.AsyncEventHandler)obj.AsyncDelegate;

45

46

            if (asyncResult.IsCompleted)// 判讀是否已經調用完成

47

                Console.WriteLine("[(#{1}){0}]:Asynchronous Finished.", DateTime.Now.ToString(), Thread.CurrentThread.ManagedThreadId);

48

49

            string val = del.EndInvoke(asyncResult);

50

            Console.WriteLine("[(#{2}){0}]:Output Result:{1}", DateTime.Now.ToString(), val, Thread.CurrentThread.ManagedThreadId);

51

        }

52

    }

53

54

     public   class  AsyncTest

55

{

56

        public delegate decimal SalaryEventHandler(decimal salary, int monthCount, decimal bonus); // 對應YearlySalary方法

57

        public delegate string AsyncEventHandler(string name); // 對應Hello 方法

58

        public string Hello(string name)

59

{

60

            //模拟耗時/複雜的邏輯計算.等待5秒

61

            Thread.Sleep(5000);

62

            return "Hello:" + name;

63

        }

64

        public decimal YearlySalary(decimal salary, int monthCount, decimal bonus)

65

{

66

            //模拟耗時/複雜的邏輯計算.

67

            Thread.Sleep(3000);//等待3秒

68

            return salary * monthCount + bonus;

69

        }

70

    }

圖1.2

從圖1.2中可以看出,WaitAll會阻礙目前線程(主線程#10),等待所有異步的對象都執行完畢(耗時最長的異步),才釋放目前的線程,WaitAll/WaitAny的重載版本和WaitOne一樣.

3, WaitAny

和WaitAll 基本上是一樣的.我們可以使用 WaitAny 來指定某個/某幾個委托先等待,修改Code1.2紅色部分,使用WaitAny.

Code1.3

//把salayAsyc異步的句柄儲存到WaitHandle 對象中

WaitHandle[] handles = { salayAsyc.AsyncWaitHandle };

//阻礙目前線程,直到所有異步調用結束.

WaitHandle.WaitAny(handles);

圖1.3

我們阻礙了DoAntherJob(#10)線程,直到Salary異步調用計算完成.同樣我們可以巧用這三個方法來改變我們方法執行的順序.

釋放資源

Code2

1

static   void  OnSalaryCallback(IAsyncResult asyncResult)

2

{

3

            //通過AsyncDelegate 擷取原始的委托對象

4

            AsyncResult obj = (AsyncResult)asyncResult;

5

            MyThirdAsyncCode.AsyncTest.SalaryEventHandler del =

(MyThirdAsyncCode.AsyncTest.SalaryEventHandler)obj.AsyncDelegate;

6

7

            decimal val = del.EndInvoke(asyncResult);

8

            asyncResult.AsyncWaitHandle.Close();//顯示的釋放資源

9

        }

當開始調用BeginXXX後,就會建立一個新的AsyncResult對象.這個對象會構造一個WaitHandle句柄(通過AsyncWaitHandle通路),當我們EndXXX後,并不會馬上關閉這個句柄,而是等待垃圾收集器來關閉,這時候我們最後在調用EndXXX完成後,顯示的關閉這個句柄.

說到這裡,我們基本上把異步方法都解釋一遍,下面我們來看看重構的異步對象,我們也可以細細體會異步對象的内部執行代碼..下面Code3.1/3.2/3.3代碼來自Jeffery Richard大師的Power Threading類庫,具體可檢視http://msdn.microsoft.com/en-us/magazine/cc163467.aspx

重構的異步對象

1步,構造一個内部無參的AsyncResultNoResult對象,繼承IAsyncResult接口(保留原創的注釋)

Code3.1

  1

  internal   class  AsyncResultNoResult : IAsyncResult

  2

{

  3

        // Fields set at construction which never change while 

  4

        // operation is pending

  5

        private readonly AsyncCallback m_AsyncCallback;

  6

        private readonly Object m_AsyncState;

  7

  8

        // Fields set at construction which do change after 

  9

        // operation completes

 10

        private const Int32 c_StatePending = 0; 

 11

        private const Int32 c_StateCompletedSynchronously = 1;

 12

        private const Int32 c_StateCompletedAsynchronously = 2;

 13

        private Int32 m_CompletedState = c_StatePending;

 14

 15

        // Field that may or may not get set depending on usage

 16

        private ManualResetEvent m_AsyncWaitHandle;

 17

 18

        // Fields set when operation completes

 19

        private Exception m_exception;

 20

 21

        public AsyncResultNoResult(AsyncCallback asyncCallback, Object state)

 22

{

 23

            m_AsyncCallback = asyncCallback;

 24

            m_AsyncState = state;

 25

        }

 26

 27

        public void SetAsCompleted(

 28

           Exception exception, Boolean completedSynchronously)

 29

{

 30

            // Passing null for exception means no error occurred. 

 31

            // This is the common case

 32

            m_exception = exception;

 33

 34

            // The m_CompletedState field MUST be set prior calling the callback

 35

            Int32 prevState = Interlocked.Exchange(ref m_CompletedState,

 36

               completedSynchronously ? c_StateCompletedSynchronously :

 37

               c_StateCompletedAsynchronously);

 38

            if (prevState != c_StatePending)

 39

                throw new InvalidOperationException(

 40

                    "You can set a result only once");

 41

 42

            // If the event exists, set it

 43

            if (m_AsyncWaitHandle != null) m_AsyncWaitHandle.Set();

 44

 45

            // If a callback method was set, call it

 46

            if (m_AsyncCallback != null) m_AsyncCallback(this);

 47

        }

 48

 49

        public void EndInvoke()

 50

{

 51

            // This method assumes that only 1 thread calls EndInvoke 

 52

            // for this object

 53

            if (!IsCompleted)

 54

{

 55

                // If the operation isn't done, wait for it

 56

                AsyncWaitHandle.WaitOne();

 57

                AsyncWaitHandle.Close();

 58

                m_AsyncWaitHandle = null;  // Allow early GC

 59

            }

 60

 61

            // Operation is done: if an exception occured, throw it

 62

            if (m_exception != null) throw m_exception;

 63

        }

 64

 65

        Implementation of IAsyncResult#region Implementation of IAsyncResult

 66

        public Object AsyncState 

{ get 

{ return m_AsyncState; } }

 67

 68

        public Boolean CompletedSynchronously

 69

{

 70

            get

 71

{

 72

                return Thread.VolatileRead(ref m_CompletedState) ==

 73

                    c_StateCompletedSynchronously;

 74

            }

 75

        }

 76

 77

        public WaitHandle AsyncWaitHandle

 78

{

 79

            get

 80

{

 81

                if (m_AsyncWaitHandle == null)

 82

{

 83

                    Boolean done = IsCompleted;

 84

                    ManualResetEvent mre = new ManualResetEvent(done);

 85

                    if (Interlocked.CompareExchange(ref m_AsyncWaitHandle,

 86

                       mre, null) != null)

 87

{

 88

                        // Another thread created this object's event; dispose 

 89

                        // the event we just created

 90

                        mre.Close();

 91

                    }

 92

                    else

 93

{

 94

                        if (!done && IsCompleted)

 95

{

 96

                            // If the operation wasn't done when we created 

 97

                            // the event but now it is done, set the event

 98

                            m_AsyncWaitHandle.Set();

 99

                        }

100

                    }

101

                }

102

                return m_AsyncWaitHandle;

103

            }

104

        }

105

106

        public Boolean IsCompleted

107

{

108

            get

109

{

110

                return Thread.VolatileRead(ref m_CompletedState) !=

111

                    c_StatePending;

112

            }

113

        }

114

        #endregion

115

    }

2步,繼承AsyncResultNoResult對象,并且為他提供傳回值和泛型的通路

Code3.2

 1

internal   class  AsyncResult < TResult >  : AsyncResultNoResult

 2

{

 3

        // Field set when operation completes

 4

        private TResult m_result = default(TResult);

 5

 6

        public AsyncResult(AsyncCallback asyncCallback, Object state) :

 7

            base(asyncCallback, state) 

{ }

 8

 9

        public void SetAsCompleted(TResult result,

10

           Boolean completedSynchronously)

11

{

12

            // Save the asynchronous operation's result

13

            m_result = result;

14

15

            // Tell the base class that the operation completed 

16

            // sucessfully (no exception)

17

            base.SetAsCompleted(null, completedSynchronously);

18

        }

19

20

        new public TResult EndInvoke()

21

{

22

            base.EndInvoke(); // Wait until operation has completed 

23

            return m_result;  // Return the result (if above didn't throw)

24

        }

25

    }

3步,模拟長時間的異步工作

Code3.3

 1

internal   sealed   class  LongTask

 2

{

 3

        private Int32 m_ms;  // Milliseconds;

 4

 5

        public LongTask(Int32 seconds)

 6

{

 7

            m_ms = seconds * 1000;

 8

        }

 9

10

        // Synchronous version of time-consuming method

11

        public DateTime DoTask()

12

{

13

            Thread.Sleep(m_ms);  // Simulate time-consuming task

14

            return DateTime.Now; // Indicate when task completed

15

        }

16

17

        // Asynchronous version of time-consuming method (Begin part)

18

        public IAsyncResult BeginDoTask(AsyncCallback callback, Object state)

19

{

20

            // Create IAsyncResult object identifying the 

21

            // asynchronous operation

22

            AsyncResult<DateTime> ar = new AsyncResult<DateTime>(

23

               callback, state);

24

25

            // Use a thread pool thread to perform the operation

26

            ThreadPool.QueueUserWorkItem(DoTaskHelper, ar);

27

28

            return ar;  // Return the IAsyncResult to the caller

29

        }

30

31

        // Asynchronous version of time-consuming method (End part)

32

        public DateTime EndDoTask(IAsyncResult asyncResult)

33

{

34

            // We know that the IAsyncResult is really an 

35

            // AsyncResult<DateTime> object

36

            AsyncResult<DateTime> ar = (AsyncResult<DateTime>)asyncResult;

37

38

            // Wait for operation to complete, then return result or 

39

            // throw exception

40

            return ar.EndInvoke();

41

        }

42

43

        // Asynchronous version of time-consuming method (private part 

44

        // to set completion result/exception)

45

        private void DoTaskHelper(Object asyncResult)

46

{

47

            // We know that it's really an AsyncResult<DateTime> object

48

            AsyncResult<DateTime> ar = (AsyncResult<DateTime>)asyncResult;

49

            try

50

{

51

                // Perform the operation; if sucessful set the result

52

                DateTime dt = DoTask();

53

                ar.SetAsCompleted(dt, false);

54

            }

55

            catch (Exception e)

56

{

57

                // If operation fails, set the exception

58

                ar.SetAsCompleted(e, false);

59

            }

60

        }

61

    }

來自Jeffrey Richter大師更多更詳細的異步操作方法, 請檢視http://www.wintellect.com/PowerThreading.aspx,對于一些朋友可能看不懂Code3.1-3.3代碼(其實沒什麼所謂的),因為涉及到過多的線程知識,這裡出于讓你獲得更多的更深層次的(異步)認識為目的,才提供上面代碼,在以後的文章會再次探讨.

下一篇章中,我們來看看微軟提供有異步調用的類是如何調用的,并從中我會給出些真實應用環境中的一些小技巧,讓你編寫的代碼更健壯更完善.

以上有word 文檔直接粘貼,排版可能不太看,你可以通過下面來下載下傳相應的代碼/文檔

1,文檔

2,代碼(VS2008開發,.Net Framework 2.0(C Sharp)編寫)