并发编程概述 委托（delegate） 事件（event） .net core 2.0 event bus 一个简单的基于内存事件总线实现 .net core 基于NPOI 的excel导出类...

并发编程概述

 

---

 

前言

说实话，在我软件开发的头两年几乎不考虑并发编程，请求与响应把业务逻辑尽快完成一个星期的任务能两天完成绝不拖三天（剩下时间各种浪），根本不会考虑性能问题（能接受范围内）。但随着工作内容的变化，一些问题，它的解决方案已经让我避不开并发编程这一块知识点了。为了一劳永逸，此系列与并发编程有关的系列文章诞生，希望对各有有所帮助。

 

基础术语

同步（synchronization）：关于协调线程或进程之间的活动，并确保被多个线程或进程访问的数据一直有效，同步允许线程和进程一致地操作。

并发（concurrency）：同时做多间事情，是关于程序的各个方面的合作和串联工作，以实现目标。

进程（Process）：一个具有一定独立功能的程序关于某个数据集合的一次运行活动，是系统进行资源分配和调度运行的基本单位，当一个程序开始运行时，它在系统中奖开启一个或多个进程，一个进程又有多个线程组成。

线程（thread）：代表程序中的单个执行逻辑流程，是一个独立处理的执行路径，是轻量级的进程。

多线程（multithreading）：多个线程来执行程序。并发的一种形式，但不是唯一的方式。

并行处理：把正在执行的大量的任务分割成小块，分配给多个同时运行的线程。多线程的一种。

异步编程：并发的一种形式，采用future模式或回调（callback）机制，以避免产生不必要的线程。

 

 

异步编程

异步编程并不一定要用多线程去实现，多线程只是其中一种实现手段。在.Net中，新版funture类型有Task和Task。老式异步编程API中采用回调或事件（event）。异步编程的核心理念是异步操作。

异步操作：启动了的操作将会在一段时间后完成。这个操作执行时，不会阻塞原来的线程。启动了这个操作的线程，可以继续执行其他任务。当操作完成时，会通知它的future或调用回调函数，以便让程序指导操作已经结束。

响应式编程：一种声明式的编程模式，程序在该模式中对事件做出响应，区别于异步编程是因为它是基于异步事件（asynchronous evnt）。并发编程的一种形式。

 

I/O密集与计算密集

I/O密集（I/O-bound）：如果一个操作将大部分时间用于等待一个条件的产生，那么它就被成为I/O密集操作。

计算密集（compute-bound）：如果一个操作将大部分时间用于执行CPU密集操作，那么它被称为计算密集操作。

 

并发编程

优秀软件的关键特征就是具有并发性，程序在同一时间做着更多的事情，而不是过去我们看到的一种单请求单响应。智能化、高用户体验的程序已经离不并发编程。

 

 

委托（delegate）

 

---

 

委托概述

将方法调用者和目标方法动态关联起来，委托是一个类，所以它和类是同级的，可以通过委托来掉用方法，不要误以为委托和方法同级的，方法只是类的成员。委托定义了方法的类型（定义委托和与之对应的方法必须具有相同的参数个数，并且类型相同，返回值类型相同），使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。

 

基础委托(Delegate)

在.Net中声明委托使用关键词delegate，委托具有多种使用方式（以下均为同步委托调用）：

 1     /// 

 2     /// 普通委托基础调用方式（同步委托）
 3     /// 
 4     public class Delegates
 5     {
 6         /// 

 7         /// 定义有参无返回值委托
 8         /// 
 9         /// 
10         public delegate void NoReturnWithParameters(string o);
11         /// 

12         /// 构造函数实例化
13         /// 
14         public void DemoOne()
15         {
16             NoReturnWithParameters methord = new NoReturnWithParameters(this.Test);
17             methord.Invoke("One-ok");
18         }
19         /// 

20         /// 赋值对象
21         /// 
22         public void DemoTwo()
23         {
24             NoReturnWithParameters methord = this.Test;
25             methord.Invoke("Two-ok");
26         }
27         /// 

28         /// DotNet 2.0 
29         /// 
30         public void DemoThree()
31         {
32             NoReturnWithParameters methord = new NoReturnWithParameters(
33                 delegate (string o)
34                      {
35                          Console.WriteLine("有参无返回值:{0}", o);
36                      }
37             );
38             methord.Invoke("Three-ok");
39         }
40         /// 

41         /// DotNet 3.0 
42         /// 
43         public void DemoFour()
44         {
45             NoReturnWithParameters methord = new NoReturnWithParameters(
46                 (string o) =>
47                     {
48                         Console.WriteLine("有参无返回值:{0}", o);
49                     }
50             );
51             methord.Invoke("Four-ok");
52         }
53         /// 

54         /// 委托约束
55         /// 
56         public void DemoFive()
57         {
58             NoReturnWithParameters methord = new NoReturnWithParameters(
59                 (o) =>
60                 {
61                     Console.WriteLine("有参无返回值:{0}", o);
62                 }
63             );
64             methord.Invoke("Five-ok");
65         }
66         /// 

67         /// 方法只有一行去则掉大括号及分号
68         /// 
69         public void DemoSix()
70         {
71             NoReturnWithParameters methord = new NoReturnWithParameters((o) => Console.WriteLine("有参无返回值:{0}", o));
72             methord.Invoke("Six-ok");
73         }
74         public void DemoSeven()
75         {
76             NoReturnWithParameters methord = (o) => Console.WriteLine("有参无返回值:{0}", o);
77             methord.Invoke("Seven-ok");
78         }
79         /// 

80         /// 定义有参无返回值测试方法
81         /// 
82         /// 
83         private void Test(string o)
84         {
85             Console.WriteLine("有参无返回值:{0}", o);
86         }
87         /*
88          * 作者：Jonins
89          * 出处：http://www.cnblogs.com/jonins/
90          */
91     }

 

同步委托&异步委托

同步委托：委托的Invoke方法用来进行同步调用。同步调用也可以叫阻塞调用，它将阻塞当前线程，然后执行调用，调用完毕后再继续向下进行。

异步委托：异步调用不阻塞线程，而是把调用塞到线程池中，程序主线程或UI线程可以继续执行。委托的异步调用通过BeginInvoke和EndInvoke来实现。

以下为异步委托调用方式：

 1     class Program
 2     {
 3         /// 

 4         /// 定义有参无返回值委托
 5         /// 
 6         /// 
 7         public delegate void NoReturnWithParameters(string o);
 8         static void Main(string[] args)
 9         {
10             NoReturnWithParameters methord = new NoReturnWithParameters(Test);
11             Console.WriteLine("主线程执行1");
12             Console.WriteLine("主线程执行2");
13             methord.BeginInvoke("demo-ok", null, null);
14             Console.WriteLine("主线程执行3");
15             Console.WriteLine("主线程执行4");
16             Console.ReadKey();
17         }
18         /// 

19         /// 异步调用委托方法
20         /// 
21         /// 
22         static void Test(string o)
23         {
24             Console.WriteLine("有参无返回值:{0}", o);
25         }
26         /*
27          * 作者：Jonins
28          * 出处：http://www.cnblogs.com/jonins/
29          */
30     }

因为调用BeginInvoke为异步委托，不会阻塞主线程，运行结果如下：

 

异步回调（Callback）

异步回调通过设置回调函数，当调用结束时会自动调用回调函数，可以在回调函数里触发EndInvoke，这样就释放掉了线程，可以避免程序一直占用一个线程。

 1     class Program
 2     {
 3         /// 

 4         /// 定义有参有返回值委托
 5         /// 
 6         /// 
 7         public delegate string ReturnWithParameters(string o);
 8         static void Main(string[] args)
 9         {
10             ReturnWithParameters methord = new ReturnWithParameters(Test);
11             Console.WriteLine("主线程执行1");
12             Console.WriteLine("主线程执行2");
13             /*
14              BeginInvoke方法参数个数不确定, 最后两个参数含义固定，如果不使用的话，需要赋值null
15              委托的方法无参数，这种情况下BeginInvoke中只有两个参数。
16              此外，委托的方法有几个参数，BeginInvoke中从左开始，对应响应的参数。
17              1.倒数第二个参数：是有一个参数值无返回值的委托，它代表的含义为，该线程执行完毕后的回调。
18              2.倒数第一个参数：向即回调中传值，用AsyncState来接受。
19              3.其它参数：对应委托方法的参数。
20              */
21             IAsyncResult asyncResult = methord.BeginInvoke("demo-ok", new AsyncCallback(Callback), "AsycState:给回调函数的参数传递在此处出传值");
22             Console.WriteLine("主线程执行3");
23             Console.WriteLine("主线程执行4");
24             Console.ReadKey();
25         }
26         /// 

27         /// 异步调用委托方法
28         /// 
29         /// 
30         /// 
31         private static string Test(string o)
32         {
33             return "委托方法执行成功：" + o;
34         }
35         /// 

36         /// 回调函数
37         /// 
38         /// 
39         private static void Callback(IAsyncResult asyncResult)
40         {
41             /*
42              *asyncResult为回调前异步调用方法返回值
43              *AsyncResult 是IAsyncResult接口的一个实现类，引用空间：System.Runtime.Remoting.Messaging
44              *AsyncDelegate 属性可以强制转换为定义的委托类型
45              */
46             ReturnWithParameters methord = (ReturnWithParameters)((System.Runtime.Remoting.Messaging.AsyncResult)asyncResult).AsyncDelegate;
47             Console.WriteLine(methord.EndInvoke(asyncResult));
48             Console.WriteLine(asyncResult.AsyncState);
49         }
50         /*
51          * 作者：Jonins
52          * 出处：http://www.cnblogs.com/jonins/
53          */
54     }

执行结果如下：

注意：

1.异步调用只能调用一次EndInvoke,否则会报错。

2.如果不回调函数中执行EndInvoke，请在异步调用后手动执行EndInvoke方法释放资源。

 

异步委托线程等待 

1.【Delegate】.EndInvoke（推荐）

1   public delegate void NoReturnWithParameters(string o);
2   NoReturnWithParameters noReturnWithParameters = new NoReturnWithParameters(...);
3        ......
4   noReturnWithParameters.EndInvoke(asyncResult);

2.【IAsyncResult】.AsyncWaitHandle.WaitOne（可以定义等待时间，超过等待时间不继续等待向下执行）

1  IAsyncResult asyncResult = null;
2  asyncResult.AsyncWaitHandle.WaitOne(2000);//等待2000毫秒，超时不等待

3.【IAsyncResult】.IsCompleted（是IAsyncResult对象的一个属性，该值指示异步操作是否已完成。不推荐）

1  IAsyncResult asyncResult = xxx.BeginInvoke(...);
2  while (!asyncResult.IsCompleted)
3  {
4      //正在等待中
5  }

 

内置委托（泛化委托）

 .Net Framework 提供两个支持泛型的内置委托,分别是Action<>和Func<>,在System命名空间中定义，结合lambda表达式,可以提高开发效率。

使用方式如下：

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             //使用Action声明委托
 6             Action action = TestAction;
 7             action.Invoke("action-demo-ok");
 8             //使用Func声明委托
 9             Func func = TestFunc;
10             string result = func.Invoke("func-demo-ok");
11             Console.WriteLine(result);
12             Console.ReadKey();
13         }
14         private static void TestAction(string o)
15         {
16             Console.WriteLine("TestAction方法执行成功:{0}", o);
17         }
18         private static string TestFunc(string o)
19         {
20             return "TestFunc方法执行成功:" + o;
21         }
22         /*
23          * 作者：Jonins
24          * 出处：http://www.cnblogs.com/jonins/
25          */
26     }

Action:无返回值的泛型委托，目前.NET Framework提供了17个Action委托,它们从无参数到最多16个参数。

public delegate void Action
Action	无返回值的泛型委托
Action	传入参数int、string,无返回值的委托
Action	传入参数int,string,bool,无返回值的委托
Action	传入4个bool型参数，无返回值的委托
Action最少0个参数，最多16个参数，无返回值。

 

 

 

 

 

Func:有返回值的泛型委托，.NET Framework提供了17个Func函数，允许回调方法返回值。

public delegate TResult Func
Func	无参，返回值为int的委托
Func	传入参数int,返回值为string类型的委托
Func	传入参数为object, string 返回值为bool类型的委托
Func 表示	传入参数为T1,T2,,T3(类型)返回值为int类型的委托
Func最少0个参数，最多16个参数，根据返回值泛型返回。必须有返回值，不可为void。

 

 

 

 

 

本质上Action和Func都为delegate ，在System命名空间中定义（in和out用来标识变量）

除此之外还有Predicate，它是固定返回值为bool类型的泛型委托。Action和Func足够使用这里不做介绍。

注意：

1.委托定义不要太多，微软仅在MSCorLib.dll中就有进50个委托类型，而且.NET Framework现在支持泛型，所以我们只需几个泛型委托(在System命名空间中定义)就能表示需要获取多达16个参数的方法。

2.如需获取16个以上参数，就必须定义自己的委托类型。所以建议尽量使用内置委托，而不是在代码中定义更多的委托类型，这样可以减少代码中的类型数量，同时简化编码。

3.如需使用ref或out关键字以传引用的方式传递参数，就需要定义自己的委托。

 

内置委托（泛化委托）参数协变&逆变

协变（out）：假定S是B的子类，如果X(S)允许引用转换成X(B),那么称X为协变类。（支持“子类”向“父类”转换）
逆变（in）：假定S是B的子类，如果X(B)允许引用转换成X(X),那么称X为协变类。（支持“父类”向“子类”转换）

正如泛化接口，泛型委托同样支持协变与逆变

1     public delegate void Action(T obj);
2    
3     public delegate TResult Func();

Action在System命名空间中定义支持逆变（in）

1         Action