C#多线程实现方法——异步委托/调用

C#异步调用(Asynchronou Delegate)

C#异步调用获取结果方法:主要有三种,也可以说是四种(官方说四种,电子书说三种),官方在MSDN上已经有详细的说明: 链接

需要了解到获取异步执行的返回值,意味着你需要调用Delegate的BeginInvoke方法,而不是Invoke方法。

第一种就是书上没有说的,但是官方还是给出来的,就是通过调用EndInvoke方法来获取内容,查看如下代码:

    class MyState
    {
        public int ThreadId = 0;
        public int Data = 0;

        public MyState()
        { 
            
        }
    }
    class AsyncInvoke
    {
        private MyState State = null;
        
        public AsyncInvoke()
        {
            State = new MyState();
        }

        private int TakesAWhile(int data, int ms)
        {
            Console.WriteLine("TakesAWhile started");
            Thread.Sleep(ms);
            Console.WriteLine("TakesAWhile completed");
            return ++data;
        }

        public delegate int TakesAWhileDelegate(int data, int ms);

        public void RunEndInvoke()
        {
            TakesAWhileDelegate dl = new TakesAWhileDelegate(TakesAWhile);
            IAsyncResult ar = dl.BeginInvoke(5, 3000, null, null);
            int result = 0;
            result = dl.EndInvoke(ar);
            Console.WriteLine(string.Format("Result: {0}", result));
        }
    } 
输出结果为:

TakesAWhile started
TakesAWhile completed
Result: 6

通过上面可以知道使用EndInvoke阻塞了主线程(RunEndInvoke函数),同时需要使用BeginInvoke的返回值ar作为EndInvoke的入参。


第二种方法Polling(轮询)BeginInvoke的返回值(IAsyncResult中的属性IsCompleted),将RunEndInvoke替换成下面的函数RunPolling:

        public void RunPolling()
        {
            TakesAWhileDelegate dl = new TakesAWhileDelegate(TakesAWhile);
            IAsyncResult ar = dl.BeginInvoke(5, 3000, null, null);

            while (ar.IsCompleted == false)
            {
                Thread.Sleep(500);
            }
            int result = 0;
            result = dl.EndInvoke(ar);
            Console.WriteLine(string.Format("Result: {0}", result));
        }
结果同上,其实看到这里你也发现第二种跟第一种没有很大区别,所以书上没有阐明第一种方法,其实如果只是为了获取结果,用第一种方法就足够了。其实这两个例子没有很好的体现BeginInvoke的异步的优势,好像跟使用Invoke方法没有很大区别,都是事先了阻塞主线程,如下所示:

        public void RunInvoke()
        {
            TakesAWhileDelegate dl = new TakesAWhileDelegate(TakesAWhile);
            int result = dl.Invoke(5, 3000);
            Console.WriteLine(string.Format("Result: {0}", result));
        }
其实这就涉及的Invoke以及BeginInvoke的区别了,因为调用Invoke,会阻塞主线程,等待异步执行的完成(其实也没有什么异步的说法了)。不过调用BeginInvoke则回立即返回,但是异步执行的结果或者返回值如何获得, 就是这部分阐述的目的:获取异步执行的返回值或结果,所以你可以将上述的RunBeginInvoke替换成如下的:

        public void RunEndInvoke()
        {
            TakesAWhileDelegate dl = new TakesAWhileDelegate(TakesAWhile);
            IAsyncResult ar = dl.BeginInvoke(5, 3000, null, null);
            // Do others in main thread.
            Console.WriteLine("Do others in main thread...");
            //
            int result = 0;
            result = dl.EndInvoke(ar);
            Console.WriteLine(string.Format("Result: {0}", result));
        }
这样输出结果如下所示:

Do others in main thread...
TakesAWhile started
TakesAWhile completed
Result: 6

这样你可以放别的工作在BeginInvoke的之后,在主线程执行,等到执行了,可以使用阻塞主线程来等待异步执行的结果来进行下一步的需要,这样情况能够部分提高工作效率,通常用于执行相互独立的模块,然后再等待两边结果(主线程以及异步线程的结果)来进行下一步的操作。

好了,讲第三种的方法来获取异步结果了,就是Wait Handle。 handle是通过BeginInvoke的返回值(ar)中的一个属性AsyncWaitHandle来获得的。一开始AsyncWaitHandle是没有初始化的,但是只要引用该属性,操作系统实现它,同时调用其waitone函数去等待异步执行完的信号。如果使用没有带参的waitone函数,则无限期阻塞主线程来等待异步执行,一旦执行完,则返回, 如下代码所示:

        public void RunWaitHandle()
        {
            TakesAWhileDelegate dl = new TakesAWhileDelegate(TakesAWhile);
            IAsyncResult ar = dl.BeginInvoke(5, 3000, null, null);
            ar.AsyncWaitHandle.WaitOne();
            Console.WriteLine("Wait for 3 seconds.");
            int result = 0;
            result = dl.EndInvoke(ar);
            ar.AsyncWaitHandle.Close();
            Console.WriteLine(string.Format("Result: {0}", result));
        }
输出结果基本同上,就多了一行“Wait for 3 seconds."来识别是否等待了3秒钟,因为后面还有EndInvoke方法。

如果使用带参的,如waitone(1000, false)来判断当前返回值是true则意味着等待1秒,第二参数来判断是否退出同步。

从上面三种方法来看,的确是挺好的,但是每次都需要主线程去等待,大哥不好当,所以就有了第四种方法,就是使用BegingInvoke的第三个参数,该函数是在BeginInvoke调用的函数执行完后自动执行,不然也不叫做callback。
第四个参数通常将异步函数的delegate传递过去,这样在callback函数中就可以方便的获取到异步函数的执行结果或者返回值。

        public void AsyncCompleted(IAsyncResult ar)
        {
            if (ar != null)
            {
				Console.WriteLine("After the async operation.");
                TakesAWhileDelegate dl = ar.AsyncState as TakesAWhileDelegate;
                int result = 0;
                result = dl.EndInvoke(ar);
                Console.WriteLine(string.Format("Result: {0}", result));
            }
        }

        public void RunAsyncCallback()
        {
            TakesAWhileDelegate dl = new TakesAWhileDelegate(TakesAWhile);
            IAsyncResult ar = dl.BeginInvoke(5, 3000, AsyncCompleted, dl);
            Console.WriteLine("Finish RunAsyncCallback.");
        }
输出结果:
Finish RunAsyncCallback.
Press any key to continue...
TakesAWhile started
TakesAWhile completed
After the async operation.
Result: 6

现在Lambda很流行,虽然还是不是很懂,但是也赶下潮流,可以将上述的callback方法改写成lambda形式,同时可以不用指定关于BeginInvoke的第四个参数,同时可以在作用域中访问异步delegate(dl)。代码如下所示:

        public void RunAsyncCallback2()
        {
            TakesAWhileDelegate dl = new TakesAWhileDelegate(TakesAWhile);
            dl.BeginInvoke(5, 3000, ar => {
                Console.Write("After async operation.");
                int result = 0;
                result = dl.EndInvoke(ar);
                Console.WriteLine(string.Format("Result: {0}", result));
            }, null);
            Console.WriteLine("Finish RunAsyncCallback.");
        }

格式的确挺简单的,下次再开个专栏讲lambda吧。

至此,四种获取异步结果或者返回值的方法也说完了,现在补充一下别的知识,就是关于返回值的问题。
我们知道EndInvoke的调用或者Invoke的调用(这里抛开了异步的概念了)都只能返回一个值(真是废话!)。如果我们想在异步执行中修改多个值,可以选择的方法有: 使用一个结构体或者类(简言之就是一个复杂对象),将想要在异步程序中修改对象整合在一起,就如下面的代码所示:

        private MyState TakesAWhile(int data)
        {
            Console.WriteLine("TakesAWhile started");
            Thread.Sleep(3000);
            Console.WriteLine("TakesAWhile completed");
            return new MyState(){Data=++data, ThreadId=Thread.CurrentThread.ManagedThreadId};
        }

        private delegate MyState TaskAWhileDelegate2(int data);

        public void RunEndInvokeWithStructReturn()
        {
            TaskAWhileDelegate2 dl = new TaskAWhileDelegate2(TakesAWhile);
            IAsyncResult ar = dl.BeginInvoke(5, null, null);
            MyState state = null;
            state = dl.EndInvoke(ar);
         
            Console.WriteLine(string.Format("Data: {0}, ThreadId: {1}", state.Data, state.ThreadId));
        }
输出结果为:
TakesAWhile started
TakesAWhile completed
Data: 6, ThreadId: 6

使用复杂结构体或者类能够实现多种参数的修改,一来节省输入参数,二来想怎么整合参数就怎么整合。
其实另一种实用的方法(个人认为,也是从C++一路走来,巴拉巴拉。。。),使用c#中的ref来代替指针的,指向已经分配好的复杂对象也是一个很好的方法,如下代码实现同上的功能:

        private void TakesAWhile(int data, int ms, ref MyState state)
        {
            Console.WriteLine("TakesAWhile started");
            Thread.Sleep(ms);
            Console.WriteLine("TakesAWhile completed");
            state.Data = ++data;
            state.ThreadId = Thread.CurrentThread.ManagedThreadId;
        }

        private delegate void TakesAWhileDelegate3(int data, int ms, ref MyState state);
       
        public void RunEndInvokeWithRefStruct()
        {
            TakesAWhileDelegate3 dl = new TakesAWhileDelegate3(TakesAWhile);
            IAsyncResult ar = dl.BeginInvoke(5, 3000, ref State, null, null);
            dl.EndInvoke(ref State, ar); // this State could be any other reference to MyState
            Console.WriteLine(string.Format("Data: {0}, ThreadId: {1}", State.Data, State.ThreadId));
        }

其中EndInvke调用中需要多给一个参数,如果这个参数是成员变量,给或者不给都不会影响到后面一句的打印情况,也就是state已经在异步函数中修改了,即使没有明显修改都没有问题。如果使用out作为输出参数,EndInvoke也需要额外的指定该参数,具体的实现就不给代码,因为实现没有什么好给的,而且本人不太好out这个传递,ref本命的人,希望能再别的地方寻找到使用out的有意义的用法,扯远了。

到此为止,四种方法都讲完了,异步函数的输入参数以及传递参数的方法以及技巧也讲述了,总结一下:
获取异步函数的结果或者返回值的方法有:
1. EndInvoke调用,阻塞主线程
2. Polling IAsyncResult中IsCompleted属性, 阻塞主线程,没有什么实际作用,浪费系统资源
3. Wait Handle响应,使用IAsyncResult中的AsyncWaitHandle属性去调用handle的waitone函数,阻塞主线程,使用重载带参函数实现是否等待同步或者直接跳出
4. 使用callback函数,并使其作为Begininvoke的第三个参数,使用异步delegate作为第四个参数,以使callback能够获取异步delegate的返回值。

使用心得:
如果需要跑两个相互独立的模块,或者主线程需要异步执行的结果或者返回值,可以使用前面三种方法;如果后续操作不太依赖于异步执行后的结果,可以使用callback,既能做到获取处理结果,又不会影响主线程。

PS:

上面讲述的主要是Thread或者task的异步调用BeginInvoke的结果获取方法,但是如果该异步函数中涉及到输出参数,就如刚才说的复杂对象中的成员是controller的话,就又有一章来讲了,对于UI以及后台线程的交互这是一个重要点,如果你不想你的UI经常假死的话,请收看下一回:Controller中BeginInvoke与Invoke的区别以及应用。

AD的优势是异步函数的强类型保证,参数的输入都是规定好的(delegate声明),如果需要传递参数可以在函数中使用ref关键字(只针对引用类型,值类型无效果)。由于异步调用时使用task底层实现的,所以他具有了task的优势,方便使用,但是也有其缺点,不能够想thread那样提供丰富的对线程设置(后台,优先级,不能中断)。
















你可能感兴趣的:(C#多线程实现方法——异步委托/调用)