c#并行任务多种优化方案分享(异步委托)

遇到一个多线程任务优化的问题,现在解决了,分享如下。

假设有四个任务:

任务1:登陆验证(CheckUser)

任务2:验证成功后从Web服务获取数据(GetDataFromWeb)

任务3:验证成功后从数据库获取数据(GetDatFromDb)

任务4:使用2、3的数据执行一个方法 (StartProcess)

一个比较笨的方法(本人最开始的方法,记为方法1)是直接开启一个线程,按照顺序依次执行四个任务:

代码如下:

new Thread(delegate
                {
                    CheckUser();
                    GetDatFromDb();//从数据库获取数据
                    GetDataFromWeb();//web服务获取数据
                    StartProcess();//执行4
                }).Start();

但是仔细分析需求我们会发现,任务2和任务3并没有先后区别,事实上两者并无关联,只不过任务4的执行需要任务2和3都已完成作为条件,所以我们可以再开两个线程用于执行任务2和任务3,当两者都执行完毕之后,执行任务4。

在这里使用了两个全局变量用于表示任务2和任务3的状态。用三个线程分别执行任务2、3、4,其中任务4一直在循环监听全局变量的状态,确保在2、3都执行完毕后才执行。

这记为方法2:

代码如下:

private static volatile bool _m2;//任务2的标志位
 private static volatile bool _m3;//任务3的标志位
 private static void Main(string[] args)
        {
            new Thread(delegate
                {
                    CheckUser();
                    new Thread(delegate
                        {
                             GetDatFromDb();//从数据库获取数据
                             _m2 = true;//标志位置为true
                        }).Start();
                    new Thread(delegate
                        {
                            GetDataFromWeb();//web服务获取数据
                            _m3 = true;//标志位置为true
                        }).Start();
                    new Thread(delegate
                        {
                            while (!(_m3 && _m2))//判断任务2和3是否已执行完毕
                            {
                                Thread.Sleep(100);
                            }
                            StartProcess();//执行任务4
                            _m2 = true;
                        }).Start();
                }).Start();
          }

以上代码基本上已经可以达到预期目标了,但是由于借助了两个全局变量,尽管在这里不会涉及到同步冲突的问题,但总觉得很不放心,而且当我们需要做扩展的时候,比方说在执行任务4之前,我们还需要加载文件内的数据(GetDataFromFile),那我们必须再添加一个全局标志位,显得有点麻烦。

事实上,Thread类本身已经拥有对这种情况的完美解决方案——join。

代码如下:

Thread.Join 方法
在继续执行标准的 COM 和 SendMessage 消息泵处理期间,阻塞调用线程,直到某个线程终止为止。

简单来说,join就是个阻塞方法,在线程1内创建线程2,调用线程2的Join方法,那么线程1将会被阻塞,直到线程2执行完毕。运用到上面的例子就是,在任务4内创建任务2和任务3的线程,调用任务2和任务3的线程的Join方法使任务4阻塞,直到任务2和任务3执行完毕,才继续执行任务4。这记为方法3,代码如下

代码如下:

private static void Main(string[] args)
        {
            new Thread(delegate
                {
                    CheckUser();
                    new Thread(delegate
                        {
                            Thread task2 = new Thread(delegate
                                {
                                    GetDatFromDb(); //从数据库获取数据
                                });
                            Thread task3 = new Thread(delegate
                                {
                                    GetDataFromWeb(); //web服务获取数据
                                });
                            task2.Start();
                            task3.Start();
                            task2.Join();//任务2阻塞
                            task3.Join();//任务3阻塞
                            StartProcess(); //执行任务4
                        }).Start();
                }).Start();
        }

这样便不需要任何标志位了。这是最理想的解决方案。

另外还有一种解决方案,使用EventWaitHandle

代码如下:

EventWaitHandle 类允许线程通过发出信号和等待信号来互相通信。事件等待句柄(简称事件)就是可以通过发出相应的信号来释放一个或多个等待线程的等待句柄。信号发出后,可以用手动或自动方式重置事件等待句柄

简单来说,就是方法2的进阶版,使用EventWaitHandle控制状态,而不再使用While循环监听,但这里仍旧需要两个全局的EventWaitHandle对象。该方法记为方法4,代码如下

代码如下:

private static EventWaitHandle eventWait1 = new EventWaitHandle(false, EventResetMode.AutoReset);//初始化状态false;
        private static EventWaitHandle eventWait2 = new EventWaitHandle(false, EventResetMode.AutoReset);//初始化状态false;
        private static void Main(string[] args)
        {
            new Thread(delegate
                {
                    CheckUser();
                     new Thread(delegate
                    {
                        GetDatFromDb(); //从数据库获取数据
                        eventWait1.Set(); //标志位置为true
                    }).Start();
                   new Thread(delegate
                    {
                        GetDataFromWeb(); //web服务获取数据
                        eventWait2.Set(); //标志位置为true
                    }).Start();
                    new Thread(delegate
                        {
                            eventWait1.WaitOne();//任务2阻塞,等待
                            eventWait2.WaitOne();//任务3阻塞,等待
                            StartProcess(); //执行任务4
                        }).Start();
                }).Start();
        }

上述三个优化方案,其实核心思想都是一样的,都是通过开启3个线程分别执行2、3、4任务,其中任务4被阻塞(while循环、eventWait.WaitOne,thread.join),当阻塞解除后,继续执行任务4。也就是说,任务4,其实是一直在等待任务2和任务3的完成。那么,是否有办法让任务2和任务3主动通知任务4呢?即,任务2和任务3完成后,主动执行任务4。

方法当然有:异步委托+回调函数

代码如下:

private static object obj = new object();
        private static volatile bool _m2;//任务2的标志位
        private static volatile bool _m3;//任务3的标志位

private static void Main(string[] args)
        {
            CheckUser(); //第一步 验证用户
            Action step2 = delegate
            {
                GetDatFromDb(); //从数据库获取数据
                _m2 = true; //标志位置为true
            };
            Action step3 = delegate
            {
                GetDataFromWeb(); //web服务获取数据
                _m3 = true; //标志位置为true
            };

step2.BeginInvoke(delegate
            {
                if (_m2 && _m3) //通过标志位判断2 3是否都已完成
                {
                    lock (obj)//加锁
                    {
                        _m2 = false;
                        if (_m3)//二重验证 防止两者同时进入
                            StartProcess(); //执行4
                    }
                }
            }, null);
            step3.BeginInvoke(delegate
            {
                if (_m2 && _m3) //通过标志位判断2 3是否都已完成
                {
                    lock (obj)
                    {
                        _m3 = false;
                        if (_m2)
                            StartProcess(); //执行4
                    }
                }
            }, null);
        }

讲解下代码。首先以委托的方式创建了任务2和任务3的委托对象step2和step3。执行这两个委托的异步调用方法BegInvoke。执行BegInvoke,会创建一个新的线程来执行step2和step3的方法,同时,在执行BeginInvoke的时候还指定了一个回调函数

代码如下:

delegate
            {
                if (_m2 && _m3) //通过标志位判断2 3是否都已完成
                {
                    lock (obj)
                    {
                        _m3 = false;
                        if (_m2)
                            StartProcess(); //执行4
                    }
                }
            }

这个函数会在step2和step3的线程执行完毕后被调用。在这里,我再次使用了标志位来判断step2和step3是否已经运行完成,同时,为了防止一种特殊情:“step2和step3所执行的时间几乎相等,他们会同时通过if(_m2&&_m3)判断,进而执行两次StartProcess” 在这里加了lock锁,并且在lock锁内将标志位重置+二重判断(这里可以参考单例模式的双重锁定原理),确保StarProcess只会执行一次。

如此这般,一个主动通知模式的并行任务便实现了,不过,这种实现方法相较于方法2,实在太过麻烦,尤其在与并发处理方面,个人感觉实用性不太高。

另外,还可以使用观察者模式实现异步委托+回调函数的效果。

(0)

相关推荐

  • C# 委托的三种调用示例(同步调用 异步调用 异步回调)

    首先,通过代码定义一个委托和下面三个示例将要调用的方法: 复制代码 代码如下: public delegate int AddHandler(int a,int b);    public class 加法类    {        public static int Add(int a, int b)        {            Console.WriteLine("开始计算:" + a + "+" + b);            Thread.Sl

  • C#事件处理和委托event delegate实例简述

    本文实例讲述了C#事件处理和委托event delegate,分享给大家供大家参考.具体方法如下: 以下仅仅是用最简单的方式表示事件,实际应用可能是不同窗体之间相互通知某些操作,达到触发. 首先声明一个degate的 EventHandler 参数可以没有 一个或多个 但是触发和使用一定要匹配. 创建一个该EvenHandler的实例a 在程序建立或你需要的时候产生一个事件触发申明: a += new EventHandler(d); public delegate void EventHand

  • c#委托学习示例分享

    1.委托 总的来说,委托是一个类,它定义了方法的类型,使得可以将方法当作另一个方法的参数来进行传递,这种将方法动态地赋给参数的做法,可以避免在程序中大量使用If-Else(Switch)语句,同时使得程序具有更好的可扩展性.所以,引入委托后,编程人员可以把方法的引用封装在委托对象中,然后把委托对象传递给需要引用方法.调用委托和调用方法的方式是一模一样的,代码如下: a.代码: 复制代码 代码如下: using System;using System.Collections.Generic;usi

  • C#委托初级使用的实例代码

    复制代码 代码如下: delegate double ProcessDelegate(double param1, double param2); static double Muliply(double param1, double param2)        {            return param1 * param2;                } static double Divide(double param1, double param2)        {    

  • C#基础之委托用法实例教程

    本文以实例形式简单介绍了C#中委托的用法,是深入学习C#程序设计所必须掌握的重要技巧.现以教程形式分享给大家供大家参考之用.具体如下: 首先,委托是C#中最为常见的内容.与类.枚举.结构.接口一样,委托也是一种类型.类是对象的抽象,而委托则可以看成是函数的抽象.一个委托代表了具有相同参数列表和返回值的所有函数.比如: delegate int GetCalculatedValueDelegate(int x, int y); 在上面的定义中,我们定义了一个委托,这个委托代表着一类函数,这些函数的

  • C#使用委托的步骤浅析

    本文浅析了C#使用委托的步骤.分享给大家供大家参考.具体分析如下: 委托可以理解为C或C++里面的函数指针,调用委托其实是调用被委托的方法. 简单的使用委托的步骤如下: 1.定义委托 复制代码 代码如下: // 定义委托使用关键字 delegate private delegate void SetProgressBarValueDelegate(int value); 2.声明委托 复制代码 代码如下: private SetProgressBarValueDelegate setProgre

  • C#中常见的系统内置委托用法详解

    一般来说,C#在公共语言运行时(CLR)环境中系统为我们内置了一些常用的委托,包括Action类的委托.Func类的委托.Predicate<T>委托.Comparison<T>委托等等.以上这些委托的命名空间都是System,所属程序集都是 mscorlib.dll,今天本文就来讲一讲这些委托的使用方法. 就像我们自己已定义好的一样,要实现某些功能,我们可以直接利用系统内置委托,实例化它们,而不必显式定义一个新委托并将命名方法分配给该委托.如: public static voi

  • C#中委托和事件的区别实例解析

    本文实例分析了C#中委托和事件的区别,分享给大家供大家参考之用.具体如下: 大致来说,委托是一个类,该类内部维护着一个字段,指向一个方法.事件可以被看作一个委托类型的变量,通过事件注册.取消多个委托或方法.本篇分别通过委托和事件执行多个方法,从中体会两者的区别. 一.通过委托执行方法 class Program { static void Main(string[] args) { Example example = new Example(); example.Go(); Console.Re

  • C#基础之泛型委托实例教程

    本文实例讲述了C#中泛型委托的用法,并以示例形式较为详细的进行了用法分析.分享给大家供大家参考之用.具体如下: 首先,泛型委托是委托的一种特殊形式,虽然感觉看上去比较怪异,其实在使用的时候跟委托差不多,不过泛型委托更具有类型通用性. 就拿C#里最常见的委托EventHandler打比方.在.NET 2.0以前,也就是泛型出现以前,普通的事件处理函数都由EventHandler定义,如下: public delegate void EventHandler(object sender, Event

  • c#委托详解和和示例分享

    什么是委托? 委托是寻址方法的.NET版本,使用委托可以将方法作为参数进行传递.委托是一种特殊类型的对象,其特殊之处在于委托中包含的只是一个活多个方法的地址,而不是数据. 委托虽然看起来像是一种类型,但其实定义一个委托,是定义了一个新的类.下面这行代码,定义了一个委托,使用ILDasm.exe查看其生成的IL代码如图所示: 复制代码 代码如下: //定义委托,它定义了可以代表的方法的类型,但其本身却是一个类 public delegate int methodDelegate(string st

  • C#中委托的基本用法总结

    原则: 1.委托本质就是个指针,一个函数指针,拿到函数的首地址即可: C#的委托加了安全性,体现在对于函数指针所引用的函数指令块的类型检测,比如返回值,参数类型,参数个数 而C中的函数指针被赋值的时候(在C#中,就是委托实例化的时候,因为C#中后台将委托处理成一个类了,封装了哈)被赋予的值是否满足类型的种种条件(返回值,参数类型,参数个数)不做检查,由用户给出保证,C#会编译提示出来 2.委托实例化的过程,也就是委托对象构造的过程,从底层来讲,即将一个现存的函数代码指令块的内存地址(静态函数,实

随机推荐