多线程之异步编程模式

.Net为执行异步操作提供了三中模式：

• 异步编程模型 (APM)
• 基于事件的异步模式(EAP)
• 基于任务的异步模式(TAP)

1.异步编程模型(APM)。

使用IAsyncResult设计模式的异步操作通过Begin操作和End操作两个方法实现。

在调用Begin操作后，调用线程继续执行指令，同时异步操作在另外一个线程上执行，调用线程调用End方法来获取结果。

Code：

namespace Examples
{
    public class Progrom
    {
        public static void Main()
        {
            AsyncWorkTest work = new AsyncWorkTest();
            IAsyncResult result = work.BeginWork(CallBack, null);
            Console.WriteLine("Work is begining...");
            string ret = work.EndWork(result);
            Console.WriteLine(ret);
            Console.WriteLine("Work is end...");
            Console.ReadKey();
        }

        static void CallBack(object obj)
        {
            //do someing
        }
    }

    public class AsyncResult : IAsyncResult
    {
        public AsyncResult()
        {
            //Accept parameters
        }
        private object asyncState;
        private volatile bool isCompleted;
        private volatile bool completedSynchronously;
        private ManualResetEvent asynWaitHandle;

        public string Result = "Mandel";

        public object AsyncState
        {
            get { return asyncState; }
        }
        public WaitHandle AsyncWaitHandle
        {
            get
            {
                if (this.asynWaitHandle == null)
                {
                    Interlocked.CompareExchange<ManualResetEvent>(ref this.asynWaitHandle, new ManualResetEvent(false), null);
                }
                return asynWaitHandle;
            }
        }
        public bool CompletedSynchronously
        {
            get { return completedSynchronously; }
        }
        public bool IsCompleted
        {
            get { return isCompleted; }
        }

        public void Work()
        {
            //do someing
            Thread.Sleep(3000); ;
            Result = "The Silent Southern Girl";
            asyncState = this;
            completedSynchronously = false;
            isCompleted = true;
            asynWaitHandle.Set();
        }

    }

    public class AsyncWorkTest
    {
        public IAsyncResult BeginWork(AsyncCallback callback, object state)
        {
            AsyncResult result = new AsyncResult();
            ThreadPool.QueueUserWorkItem((action) =>
            {
                result.Work();
                if (callback != null)
                {
                    callback((AsyncResult)state);
                }
            }, state);
            return result;
        }

        public string EndWork(IAsyncResult re)
        {
            AsyncResult result = (AsyncResult)re;
            result.AsyncWaitHandle.WaitOne();
            return result.Result;
        }
    }

}

如果等待异步操作结果时需要阻塞调用线程，可以使用以下方法：

•   使用AsyncWaitHandle阻止调用线程
•   调用结束异步操作来阻止调用线程(本例子即使用这个)
•   轮询异步操作状态来阻止调用线程。

如果等待异步操作结果时不能阻塞调用线程，可使用以下方法：

• 使用AsyncCallback委托，在委托中结束异步操作。

2.基于事件的异步编程模式(EAP)

 基于事件的异步操作模式具有多线程应用程序的优点，同时隐匿了多线程设计中固有的许多问题。使用EAP类讲能够：

• 在后台执行耗时任务，不会中断应用程序
• 可同时执行多个操作，每个操作完成讲会接到通知
• 等待资源变得可用，但不会停止("挂起")您的应用程序
• 使用事件和委托模型与挂起的异步操作进行通信

 BackgroundWorker组件是典型的封装好的EAP。

 支持基于事件的异步编程模型的类将会提供若干个异步执行方法MethodNameAsync，支持取消异步的方法MethodNameCancelAsync,可以提供进度报告的事件onProgressChanged. 支持异步完成后通知事件onWorkCompleted。

Code：

 class EAPTest
    {
        public static void Main()
        {
            Work myWork = new Work();
            myWork.onProgressChanged += new ProgressChangedEventHandler(myWork_onProgressChanged);
            myWork.onWorkCompleted += new WorkCompletedEventHandler(myWork_onWorkCompleted);
            myWork.WoekAsync("Mandel");
            myWork.WoekAsync("Alan");
            Thread.Sleep(4000);
            myWork.CancelAsync("Alan");
            Console.ReadKey();
        }

        static void myWork_onProgressChanged(WorkProgressChangedEventArgs e)
        {
            Console.WriteLine("Worked" + e.TaskID + " " + e.ProgressPercentage.ToString() + "% --------------");
        }

        static void myWork_onWorkCompleted(object sender, WorkCompletedEventArgs e)
        {
            Console.WriteLine("Work " + e.TaskID + "Completed---------");
        }
    }

    //delegate
    public delegate void ProgressChangedEventHandler(WorkProgressChangedEventArgs e);
    public delegate void WorkCompletedEventHandler(object sender, WorkCompletedEventArgs e);
    class Work
    {
        private delegate void WorkerEventHandler(AsyncOperation asyncOp, object taskID);
        private delegate void www();
        private SendOrPostCallback onProgressReportDelegate;
        private SendOrPostCallback onCompletedDelegate;

        public event ProgressChangedEventHandler onProgressChanged;
        public event WorkCompletedEventHandler onWorkCompleted;

        private HybridDictionary userStateToLifetime = new HybridDictionary();

        public Work()
        {
            onProgressReportDelegate = new SendOrPostCallback(ReportProgress);
            onCompletedDelegate = new SendOrPostCallback(WorkCompleted);
        }
        private void WorkCompleted(object operationState)
        {
            WorkCompletedEventArgs e = operationState as WorkCompletedEventArgs;
            if (onWorkCompleted != null)
            {
                onWorkCompleted(this, e);
            }
        }
        private void ReportProgress(object state)
        {
            WorkProgressChangedEventArgs e = state as WorkProgressChangedEventArgs;
            if (onProgressChanged != null)
            {
                onProgressChanged(e);
            }
        }

        public virtual void WoekAsync(string taskId)
        {
            // Create an AsyncOperation for taskId.
            AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId);
            lock (userStateToLifetime.SyncRoot)
            {
                if (userStateToLifetime.Contains(taskId))
                {
                    throw new ArgumentException("Task ID parameter must be unique", "taskId");
                }

                userStateToLifetime[taskId] = asyncOp;
            }
            // Start the asynchronous operation.
            WorkerEventHandler workerDelegate = new WorkerEventHandler(Worker);
            workerDelegate.BeginInvoke(asyncOp, taskId, null, null);
        }
        private void Worker(AsyncOperation asyncOp, object taskID)
        {
            Exception e = null;
            ProgressChangedEventArgs progressEventArg;
            for (int i = 0; i < 5; i++)
            {
                Thread.Sleep(1000);
                Console.WriteLine(i);
            }
            if (!TaskCanceled(asyncOp.UserSuppliedState))
            {
                //Do the work
                try
                {
                    Console.WriteLine("Come On! " + taskID);
                    Console.WriteLine("Work " + taskID.ToString() + " is working");
                    progressEventArg = new WorkProgressChangedEventArgs(taskID, 50, new object());
                    asyncOp.Post(this.onProgressReportDelegate, progressEventArg);
                    Console.WriteLine("Work " + taskID.ToString() + " has been completed");
                    progressEventArg = new WorkProgressChangedEventArgs(taskID, 100, new object());
                    asyncOp.Post(this.onProgressReportDelegate, progressEventArg);
                }
                catch (Exception ex)
                {
                    e = ex;
                }
                this.CompletionMethod(taskID, e, TaskCanceled(asyncOp.UserSuppliedState), asyncOp);
            }
            else
            {
                Console.WriteLine("Work " + taskID.ToString() + " has been canceled");
            }
        }

        public void CancelAsync(object taskId)
        {
            AsyncOperation asyncOp = userStateToLifetime[taskId] as AsyncOperation;
            if (asyncOp != null)
            {
                lock (userStateToLifetime.SyncRoot)
                {
                    userStateToLifetime.Remove(taskId);
                }
            }
        }

        private bool TaskCanceled(object taskId)
        {
            return (userStateToLifetime[taskId] == null);
        }

        private void CompletionMethod(object taskID, Exception exception, bool canceled, AsyncOperation asyncOp)
        {
            if (!canceled)
            {
                lock (userStateToLifetime.SyncRoot)
                {
                    userStateToLifetime.Remove(asyncOp.UserSuppliedState);
                }
            }
            WorkCompletedEventArgs e = new WorkCompletedEventArgs(taskID.ToString(), exception, canceled, asyncOp.UserSuppliedState);
            asyncOp.PostOperationCompleted(onCompletedDelegate, e);
        }
    }

    //Args
    public class WorkProgressChangedEventArgs : ProgressChangedEventArgs
    {
        private object taskID = null;

        public WorkProgressChangedEventArgs(object value, int progressPercentage, object userToken)
            : base(progressPercentage, userToken)
        {
            this.taskID = value;
        }
        /// <summary>
        /// 任务标识
        /// </summary>
        public object TaskID
        {
            get
            {
                return taskID;
            }
        }
    }
    public class WorkCompletedEventArgs : AsyncCompletedEventArgs
    {
        object taskID = "";
        public WorkCompletedEventArgs(object value, Exception e, bool canceled, object state)
            : base(e, canceled, state)
        {
            this.taskID = value;
        }
        /// <summary>
        /// 任务标识
        /// </summary>
        public object TaskID
        {
            get
            {
                RaiseExceptionIfNecessary();
                return taskID;
            }
        }
    }