C#异步的世界【上】

小灰灰 2021-09-19 11:14 367阅读 0赞

# 阅读目录 #

*  [APM][]
 *  [EAP][]
 *  [TAP][]
 *  [延伸思考][Link 1]

新进阶的程序员可能对async、await用得比较多，却对之前的异步了解甚少。本人就是此类，因此打算回顾学习下异步的进化史。

本文主要是回顾async异步模式之前的异步，下篇文章再来重点分析async异步模式。

# APM #

APM 异步编程模型，Asynchronous Programming Model

早在C\#1的时候就有了APM。虽然不是很熟悉，但是多少还是见过的。就是那些类是BeginXXX和EndXXX的方法，且BeginXXX返回值是IAsyncResult接口。

在正式写APM示例之前我们先给出一段**同步代码**：

![复制代码][copycode.gif]

//1、同步方法
    private void button1_Click(object sender, EventArgs e)
    {          
        Debug.WriteLine("【Debug】线程ID:" + Thread.CurrentThread.ManagedThreadId);
    
        var request = WebRequest.Create("https://github.com/");//为了更好的演示效果，我们使用网速比较慢的外网
        request.GetResponse();//发送请求    
    
        Debug.WriteLine("【Debug】线程ID:" + Thread.CurrentThread.ManagedThreadId);
        label1.Text = "执行完毕！";
    }

![复制代码][copycode.gif]

【说明】为了更好的演示异步效果，这里我们使用winform程序来做示例。（因为winform始终都需要UI线程渲染界面，如果被UI线程占用则会出现“假死”状态）

【效果图】

![208266-20160917162458789-1752931850.gif][]

看图得知：

*  我们在执行方法的时候页面出现了“假死”，拖不动了。
 *  我们看到打印结果，方法调用前和调用后线程ID都是9（也就是同一个线程）

下面我们再来演示对应的**异步方法**：（BeginGetResponse、EndGetResponse所谓的APM异步模型）

![复制代码][copycode.gif]

private void button2_Click(object sender, EventArgs e)
    {
        //1、APM 异步编程模型，Asynchronous Programming Model
        //C#1[基于IAsyncResult接口实现BeginXXX和EndXXX的方法]             
        Debug.WriteLine("【Debug】主线程ID:" + Thread.CurrentThread.ManagedThreadId);
    
        var request = WebRequest.Create("https://github.com/");
        request.BeginGetResponse(new AsyncCallback(t =>//执行完成后的回调
        {
            var response = request.EndGetResponse(t);
            var stream = response.GetResponseStream();//获取返回数据流 
    
            using (StreamReader reader = new StreamReader(stream))
            {
                StringBuilder sb = new StringBuilder();
                while (!reader.EndOfStream)
                {
                    var content = reader.ReadLine();
                    sb.Append(content);
                }
                Debug.WriteLine("【Debug】" + sb.ToString().Trim().Substring(0, 100) + "...");//只取返回内容的前100个字符 
                Debug.WriteLine("【Debug】异步线程ID:" + Thread.CurrentThread.ManagedThreadId);
                label1.Invoke((Action)(() => { label1.Text = "执行完毕！"; }));//这里跨线程访问UI需要做处理
            }
        }), null);
    
        Debug.WriteLine("【Debug】主线程ID:" + Thread.CurrentThread.ManagedThreadId); 
    }

![复制代码][copycode.gif]

【效果图】

![农码一生][208266-20160917164638773-751592724.gif]

看图得知：

*  启用异步方法并没有是UI界面卡死
 *  异步方法启动了另外一个ID为12的线程

上面代码执行顺序：

![208266-20160917165301148-2064816070.png][]

前面我们说过，APM的BebinXXX必须返回IAsyncResult接口。那么接下来我们分析IAsyncResult接口：

首先我们看：

![208266-20160917170150773-466071839.png][]

确实返回的是IAsyncResult接口。那IAsyncResult到底长的什么样子？：

![208266-20160917173309711-272204706.png][]

并没有想象中的那么复杂嘛。我们是否可以尝试这实现这个接口，然后显示自己的异步方法呢？

首先定一个类MyWebRequest，然后继承IAsyncResult：（下面是基本的伪代码实现）

![复制代码][copycode.gif]

public class MyWebRequest : IAsyncResult
    {
        public object AsyncState
        {
            get { throw new NotImplementedException(); }
        }
    
        public WaitHandle AsyncWaitHandle
        {
            get { throw new NotImplementedException(); }
        }
    
        public bool CompletedSynchronously
        {
            get { throw new NotImplementedException(); }
        }
    
        public bool IsCompleted
        {
            get { throw new NotImplementedException(); }
        }
    }

![复制代码][copycode.gif]

这样肯定是不能用的，起码也得有个存回调函数的属性吧，下面我们稍微改造下：

![208266-20160917174643633-352284745.png][]

然后我们可以自定义APM异步模型了：（成对的Begin、End）

![复制代码][copycode.gif]

public IAsyncResult MyBeginXX(AsyncCallback callback)
    {
        var asyncResult = new MyWebRequest(callback, null);
        var request = WebRequest.Create("https://github.com/");
        new Thread(() =>  //重新启用一个线程
        {
            using (StreamReader sr = new StreamReader(request.GetResponse().GetResponseStream()))
            {
                var str = sr.ReadToEnd();
                asyncResult.SetComplete(str);//设置异步结果
            }
    
        }).Start();
        return asyncResult;//返回一个IAsyncResult
    }
    
    public string MyEndXX(IAsyncResult asyncResult)
    {
        MyWebRequest result = asyncResult as MyWebRequest;
        return result.Result;
    }

![复制代码][copycode.gif]

调用如下:

![复制代码][copycode.gif]

private void button4_Click(object sender, EventArgs e)
     {
         Debug.WriteLine("【Debug】主线程ID:" + Thread.CurrentThread.ManagedThreadId);
         MyBeginXX(new AsyncCallback(t =>
         {
             var result = MyEndXX(t);
             Debug.WriteLine("【Debug】" + result.Trim().Substring(0, 100) + "...");
             Debug.WriteLine("【Debug】异步线程ID:" + Thread.CurrentThread.ManagedThreadId);
         }));
         Debug.WriteLine("【Debug】主线程ID:" + Thread.CurrentThread.ManagedThreadId);
     }

![复制代码][copycode.gif]

效果图：

![农码一生][208266-20160917175345539-1443440878.gif]

我们看到自己实现的效果基本上和系统提供的差不多。

*  启用异步方法并没有是UI界面卡死
 *  异步方法启动了另外一个ID为11的线程

【总结】

**个人觉得APM异步模式就是启用另外一个线程执行耗时任务，然后通过回调函数执行后续操作。**

APM还可以通过其他方式获取值，如：

while (!asyncResult.IsCompleted)//循环，直到异步执行完成 (轮询方式)
    {
        Thread.Sleep(100);
    }
    var stream2 = request.EndGetResponse(asyncResult).GetResponseStream();

或

asyncResult.AsyncWaitHandle.WaitOne();//阻止线程，直到异步完成 （阻塞等待）
    var stream2 = request.EndGetResponse(asyncResult).GetResponseStream();

补充：如果是普通方法，我们也可以通过委托异步：（BeginInvoke、EndInvoke）

![复制代码][copycode.gif]

public void MyAction()
     {
         var func = new Func<string, string>(t =>
         {
             Thread.Sleep(2000);
             return "name:" + t + DateTime.Now.ToString();
         });
     
         var asyncResult = func.BeginInvoke("张三", t =>
         {
             string str = func.EndInvoke(t);
             Debug.WriteLine(str);
         }, null); 
     }

![复制代码][copycode.gif]

# EAP #

EAP 基于事件的异步模式，Event-based Asynchronous Pattern

此模式在C\#2的时候随之而来。

先来看个EAP的例子：

![复制代码][copycode.gif]

private void button3_Click(object sender, EventArgs e)
     {            
         Debug.WriteLine("【Debug】主线程ID:" + Thread.CurrentThread.ManagedThreadId);
    
         BackgroundWorker worker = new BackgroundWorker();
         worker.DoWork += new DoWorkEventHandler((s1, s2) =>
         {
             Thread.Sleep(2000);
             Debug.WriteLine("【Debug】异步线程ID:" + Thread.CurrentThread.ManagedThreadId);
         });//注册事件来实现异步
         worker.RunWorkerAsync(this);
         Debug.WriteLine("【Debug】主线程ID:" + Thread.CurrentThread.ManagedThreadId);
     }

![复制代码][copycode.gif]

【效果图】（同样不会阻塞UI界面）

![208266-20160917203356195-748599973.png][]

【特征】

*  通过事件的方式注册回调函数
 *  通过 XXXAsync方法来执行异步调用

例子很简单，但是和APM模式相比，是不是没有那么清晰透明。为什么可以这样实现？事件的注册是在干嘛？为什么执行RunWorkerAsync会触发注册的函数？

感觉自己又想多了...

我们试着反编译看看源码：

![208266-20160917210817695-407624360.png][]

只想说，这么玩，有意思吗？

# TAP #

TAP 基于任务的异步模式，Task-based Asynchronous Pattern

到目前为止，我们觉得上面的APM、EAP异步模式好用吗？好像没有发现什么问题。再仔细想想...如果我们有多个异步方法需要按先后顺序执行，并且需要(在主进程)得到所有返回值。

如果你对编程感兴趣或者想往编程方向发展，可以关注微信公众号**【筑梦编程】**，大家一起交流讨论！小编也会每天定时更新既有趣又有用的编程知识！

首先定义三个委托：

![复制代码][copycode.gif]

public Func<string, string> func1()
    {
        return new Func<string, string>(t =>
        {
            Thread.Sleep(2000);
            return "name:" + t;
        });
    }
    public Func<string, string> func2()
    {
        return new Func<string, string>(t =>
        {
            Thread.Sleep(2000);
            return "age:" + t;
        });
    }
    public Func<string, string> func3()
    {
        return new Func<string, string>(t =>
        {
            Thread.Sleep(2000);
            return "sex:" + t;
        });
    }

![复制代码][copycode.gif]

然后按照一定顺序执行：

![复制代码][copycode.gif]

public void MyAction()
    {
        string str1 = string.Empty, str2 = string.Empty, str3 = string.Empty;
        IAsyncResult asyncResult1 = null, asyncResult2 = null, asyncResult3 = null;
        asyncResult1 = func1().BeginInvoke("张三", t =>
        {
            str1 = func1().EndInvoke(t);
            Debug.WriteLine("【Debug】异步线程ID:" + Thread.CurrentThread.ManagedThreadId);
            asyncResult2 = func2().BeginInvoke("26", a =>
            {
                str2 = func2().EndInvoke(a);
                Debug.WriteLine("【Debug】异步线程ID:" + Thread.CurrentThread.ManagedThreadId);
                asyncResult3 = func3().BeginInvoke("男", s =>
                {
                    str3 = func3().EndInvoke(s);
                    Debug.WriteLine("【Debug】异步线程ID:" + Thread.CurrentThread.ManagedThreadId);
                }, null);
            }, null);
        }, null);
    
        asyncResult1.AsyncWaitHandle.WaitOne();
        asyncResult2.AsyncWaitHandle.WaitOne();
        asyncResult3.AsyncWaitHandle.WaitOne();
        Debug.WriteLine(str1 + str2 + str3);
    }

![复制代码][copycode.gif]

除了难看、难读一点好像也没什么 。不过真的是这样吗？

![208266-20170115112208556-477305547.png][]

asyncResult2是null?  
由此可见在完成第一个异步操作之前没有对asyncResult2进行赋值，asyncResult2执行异步等待的时候报异常。那么如此我们就无法控制三个异步函数，按照一定顺序执行完成后再拿到返回值。（理论上还是有其他办法的，只是会然代码更加复杂）

**是的，现在该我们的TAP登场了。**

![208266-20170115113722400-1298698536.png][]

只需要调用Task类的静态方法Run，即可轻轻松松使用异步。

**获取返回值：**

![复制代码][copycode.gif]

var task1 = Task<string>.Run(() =>
    {
        Thread.Sleep(1500);
        Console.WriteLine("【Debug】task1 线程ID:" + Thread.CurrentThread.ManagedThreadId);
        return "张三";
    });
    //其他逻辑            
    task1.Wait();
    var value = task1.Result;//获取返回值
    Console.WriteLine("【Debug】主 线程ID:" + Thread.CurrentThread.ManagedThreadId);

![复制代码][copycode.gif]

**现在我们处理上面多个异步按序执行：**

![复制代码][copycode.gif]

Console.WriteLine("【Debug】主 线程ID:" + Thread.CurrentThread.ManagedThreadId);
    string str1 = string.Empty, str2 = string.Empty, str3 = string.Empty;
    var task1 = Task.Run(() =>
    {
        Thread.Sleep(500);
        str1 = "姓名：张三,";
        Console.WriteLine("【Debug】task1 线程ID:" + Thread.CurrentThread.ManagedThreadId);
    }).ContinueWith(t =>
    {
        Thread.Sleep(500);
        str2 = "年龄：25,";
        Console.WriteLine("【Debug】task2 线程ID:" + Thread.CurrentThread.ManagedThreadId);
    }).ContinueWith(t =>
    {
        Thread.Sleep(500);
        str3 = "爱好：妹子";
        Console.WriteLine("【Debug】task3 线程ID:" + Thread.CurrentThread.ManagedThreadId);
    });
    
    Thread.Sleep(2500);//其他逻辑代码
    
    task1.Wait();
    
    Debug.WriteLine(str1 + str2 + str3);
    Console.WriteLine("【Debug】主 线程ID:" + Thread.CurrentThread.ManagedThreadId);

![复制代码][copycode.gif]

\[效果图\]

![208266-20170115122435416-409331100.png][]

我们看到，结果都得到了，且是异步按序执行的。且代码的逻辑思路非常清晰。如果你感受还不是很大，那么你现象如果是100个异步方法需要异步按序执行呢？用APM的异步回调，那至少也得异步回调嵌套100次。那代码的复杂度可想而知。

# 延伸思考 #

*  WaitOne完成等待的原理
 *  异步为什么会提升性能
 *  线程的使用数量和CPU的使用率有必然的联系吗

**问题1**：WaitOne完成等待的原理

在此之前，我们先来简单的了解下多线程信号控制AutoResetEvent类。

var _asyncWaitHandle = new AutoResetEvent(false);
    _asyncWaitHandle.WaitOne();

此代码会在 WaitOne 的地方会一直等待下去。除非有另外一个线程执行 AutoResetEvent 的set方法。

var _asyncWaitHandle = new AutoResetEvent(false);
    _asyncWaitHandle.Set();
    _asyncWaitHandle.WaitOne();

如此，到了 WaitOne 就可以直接执行下去。没有有任何等待。

现在我们对APM 异步编程模型中的 WaitOne 等待是不是知道了点什么呢。我们回头来实现之前自定义异步方法的异步等待。

![复制代码][copycode.gif]

public class MyWebRequest : IAsyncResult
    {
        //异步回调函数（委托）
        private AsyncCallback _asyncCallback;
        private AutoResetEvent _asyncWaitHandle;
        public MyWebRequest(AsyncCallback asyncCallback, object state)
        {
            _asyncCallback = asyncCallback;
            _asyncWaitHandle = new AutoResetEvent(false);
        }
        //设置结果
        public void SetComplete(string result)
        {
            Result = result;
            IsCompleted = true;
            _asyncWaitHandle.Set();
            if (_asyncCallback != null)
            {
                _asyncCallback(this);
            }
        }
        //异步请求返回值
        public string Result { get; set; }
        //获取用户定义的对象，它限定或包含关于异步操作的信息。
        public object AsyncState
        {
            get { throw new NotImplementedException(); }
        }
        // 获取用于等待异步操作完成的 System.Threading.WaitHandle。
        public WaitHandle AsyncWaitHandle
        {
            //get { throw new NotImplementedException(); }
    
            get { return _asyncWaitHandle; }
        }
        //获取一个值，该值指示异步操作是否同步完成。
        public bool CompletedSynchronously
        {
            get { throw new NotImplementedException(); }
        }
        //获取一个值，该值指示异步操作是否已完成。
        public bool IsCompleted
        {
            get;
            private set;
        }
    }

![复制代码][copycode.gif]

红色代码就是新增的异步等待。

【执行步骤】

![208266-20170115142349853-1869357627.png][]

**问题2：**异步为什么会提升性能

比如同步代码：

Thread.Sleep(10000);//假设这是个访问数据库的方法
    Thread.Sleep(10000);//假设这是个访问FQ网站的方法

这个代码需要20秒。

如果是异步：

![复制代码][copycode.gif]

var task = Task.Run(() =>
    {
        Thread.Sleep(10000);//假设这是个访问数据库的方法
    });
    Thread.Sleep(10000);//假设这是个访问FQ网站的方法
    task.Wait();

![复制代码][copycode.gif]

如此就只要10秒了。这样就节约了10秒。

如果是：

var task = Task.Run(() =>
    {
        Thread.Sleep(10000);//假设这是个访问数据库的方法
    }); 
    task.Wait();

异步执行中间没有耗时的代码那么这样的异步将是没有意思的。

或者：

![复制代码][copycode.gif]

var task = Task.Run(() =>
    {
        Thread.Sleep(10000);//假设这是个访问数据库的方法
    }); 
    task.Wait();
    Thread.Sleep(10000);//假设这是个访问FQ网站的方法

![复制代码][copycode.gif]

把耗时任务放在异步等待后，那这样的代码也是不会有性能提升的。

还有一种情况：

如果是单核CPU进行高密集运算操作，那么异步也是没有意义的。(因为运算是非常耗CPU,而网络请求等待不耗CPU)

**问题3：**线程的使用数量和CPU的使用率有必然的联系吗

答案是否。

还是拿单核做假设。

情况1：

![复制代码][copycode.gif]

long num = 0;
    while (true)
    {
        num += new Random().Next(-100,100);
        //Thread.Sleep(100);
    }

![复制代码][copycode.gif]

单核下，我们只启动一个线程，就可以让你CPU爆满。

![208266-20170115145303666-944493718.png][]![208266-20170115145309541-1210613758.png][]

启动八次，八进程CPU基本爆满。

情况2：

![208266-20170115150406713-490112288.png][]

![208266-20170115150420103-1397987906.png][]

一千多个线程，而CPU的使用率竟然是0。由此，我们得到了之前的结论，线程的使用数量和CPU的使用率没有必然的联系。

虽然如此，但是也不能毫无节制的开启线程。因为：

*  开启一个新的线程的过程是比较耗资源的。（可是使用线程池，来降低开启新线程所消耗的资源）
 *  多线程的切换也是需要时间的。
 *  每个线程占用了一定的内存保存线程上下文信息。

[APM]: http://www.cnblogs.com/zhaopei/p/async_one.html#autoid-0-0
[EAP]: http://www.cnblogs.com/zhaopei/p/async_one.html#autoid-1-0
[TAP]: http://www.cnblogs.com/zhaopei/p/async_one.html#autoid-2-0
[Link 1]: http://www.cnblogs.com/zhaopei/p/async_one.html#autoid-3-0
[copycode.gif]: /images/20210812/a828c0352a26462292b068904ee9d303.png
[208266-20160917162458789-1752931850.gif]: /images/20210812/2d19b121a8d441ca9e603fe5903b6249.png
[208266-20160917164638773-751592724.gif]: /images/20210812/def6135a79b44d55a525a3d0545ce52f.png
[208266-20160917165301148-2064816070.png]: /images/20210812/00efe2edd76041f28f6d18e2cfdd4568.png
[208266-20160917170150773-466071839.png]: /images/20210812/1d54e53be1384d2ea93b4b55b09e8949.png
[208266-20160917173309711-272204706.png]: /images/20210812/aa240771c0924e98842ac4e451cd7dfb.png
[208266-20160917174643633-352284745.png]: /images/20210812/339b6dc1258a431095d925eb435b9e4a.png
[208266-20160917175345539-1443440878.gif]: /images/20210812/cbcad6df21354b1a8a3de5c49292b109.png
[208266-20160917203356195-748599973.png]: /images/20210812/ce25a9d60c8b4f57bd3730e8ae4b4ed6.png
[208266-20160917210817695-407624360.png]: /images/20210812/b738c4c61a5d4436978c3e5cc02c6507.png
[208266-20170115112208556-477305547.png]: /images/20210812/c440ba2281b842d48b029acafd6f445a.png
[208266-20170115113722400-1298698536.png]: /images/20210812/eb2f8217af9c4d0ba13e0592ea4259fb.png
[208266-20170115122435416-409331100.png]: /images/20210812/88ac2e69ab5c4d3ea2fa5cde5a8484c2.png
[208266-20170115142349853-1869357627.png]: /images/20210812/c6fba897ed4845379aa80d554b2bff4c.png
[208266-20170115145303666-944493718.png]: https://images2015.cnblogs.com/blog/208266/201701/208266-20170115145303666-944493718.png
[208266-20170115145309541-1210613758.png]: /images/20210812/ff3c0cfce25149de8480b7267e8577e2.png
[208266-20170115150406713-490112288.png]: /images/20210812/97f4060b2f3a47c9b84d15f5584d9576.png
[208266-20170115150420103-1397987906.png]: /images/20210812/512b9debaa1f431683abb1f4ac0ee16c.png