【转】C#异步的世界【上】

时间 2019-11-08

标签 c# 异步世界栏目 C# 繁體版

原文原文链接

【转】C#异步的世界【上】html

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

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

APM

APM 异步编程模型，Asynchronous Programming Modelgithub

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

在正式写APM示例以前咱们先给出一段同步代码：编程

//一、同步方法
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 = "执行完毕！";
}

【说明】为了更好的演示异步效果，这里咱们使用winform程序来作示例。（由于winform始终都须要UI线程渲染界面，若是被UI线程占用则会出现“假死”状态）网络

【效果图】多线程

看图得知：dom

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

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

private void button2_Click(object sender, EventArgs e)
{
    //一、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); 
}

【效果图】

看图得知：

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

上面代码执行顺序：

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

首先咱们看：

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

并无想象中的那么复杂嘛。咱们是否能够尝试这实现这个接口，而后显示本身的异步方法呢？

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

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(); }
    }
}

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

而后咱们能够自定义APM异步模型了：（成对的Begin、End）

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;
}

调用以下:

 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);
 }

效果图：

咱们看到本身实现的效果基本上和系统提供的差很少。

启用异步方法并无是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）

 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); 
 }

EAP

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

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

先来看个EAP的例子：

 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);
 }

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

【特征】

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

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

感受本身又想多了...

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

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

TAP

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

到目前为止，咱们以为上面的APM、EAP异步模式好用吗？好像没有发现什么问题。再仔细想一想...若是咱们有多个异步方法须要按前后顺序执行，而且须要(在主进程)获得全部返回值。

首先定义三个委托：

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;
    });
}

而后按照必定顺序执行：

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);
}

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

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

是的，如今该咱们的TAP登场了。

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

获取返回值：

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);

如今咱们处理上面多个异步按序执行：

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);

[效果图]

咱们看到，结果都获得了，且是异步按序执行的。且代码的逻辑思路很是清晰。若是你感觉还不是很大，那么你现象若是是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 等待是否是知道了点什么呢。咱们回头来实现以前自定义异步方法的异步等待。

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;
    }
}

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

【执行步骤】

问题2：异步为何会提高性能

好比同步代码：

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

这个代码须要20秒。

若是是异步：

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

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

若是是：

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

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

或者：

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

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

还有一种状况：

若是是单核CPU进行高密集运算操做，那么异步也是没有意义的。(由于运算是很是耗CPU,而网络请求等待不耗CPU)

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

答案是否。

仍是拿单核作假设。

状况1：

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

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

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

状况2：

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

虽然如此，可是也不能毫无节制的开启线程。由于：

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

demo：http://pan.baidu.com/s/1slOxgnF

本文已同步至索引目录：《C#基础知识巩固》

对于异步编程了解不深，文中极有可能多处错误描述和观点。

感谢广大园友的指正。

本着相互讨论的目的，绝无想要误导你们的意思。