VB.net 2010 视频教程 VB.net 2010 视频教程 python基础视频教程
SQL Server 2008 视频教程 c#入门经典教程 Visual Basic从门到精通视频教程
当前位置:
首页 > Python基础教程 >
  • C#教程之C#异步的世界【上】

阅读目录

 

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

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

APM

APM 异步编程模型,Asynchronous Programming Model

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

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

复制代码
//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 = "执行完毕!";
}
复制代码

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

【效果图】

看图得知:

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

下面我们再来演示对应的异步方法:(BeginGetResponse、EndGetResponse所谓的APM异步模型

复制代码
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); 
}
复制代码

【效果图】

 农码一生

看图得知:

  • 启用异步方法并没有是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 异步编程模型中的