欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

C#异步的世界(上)

程序员文章站 2022-06-27 12:05:46
前言新进阶的程序员可能对async、await用得比较多,却对之前的异步了解甚少。本人就是此类,因此打算回顾学习下异步的进化史。本文主要是回顾async异步模式之前的异步,下篇文章再来重点分析asyn...

前言

新进阶的程序员可能对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线程占用则会出现“假死”状态)

【效果图】

C#异步的世界(上)

看图得知:

我们在执行方法的时候页面出现了“假死”,拖不动了。

我们看到打印结果,方法调用前和调用后线程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); 
}

【效果图】

C#异步的世界(上)

看图得知:

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

上面代码执行顺序:

C#异步的世界(上)

前面我们说过,apm的bebinxxx必须返回iasyncresult接口。那么接下来我们分析iasyncresult接口:

首先我们看:

C#异步的世界(上)

确实返回的是iasyncresult接口。那iasyncresult到底长的什么样子?:

C#异步的世界(上)

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

首先定一个类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(); }
    }
}

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

C#异步的世界(上)

然后我们可以自定义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);
 }

效果图:

C#异步的世界(上)

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

  • 启用异步方法并没有是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界面)

C#异步的世界(上)

【特征】

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

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

感觉自己又想多了...

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

C#异步的世界(上)

只想说,这么玩,有意思吗?

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

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

C#异步的世界(上)

asyncresult2是null?

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

是的,现在该我们的tap登场了。

C#异步的世界(上)

只需要调用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);

[效果图]

C#异步的世界(上)

我们看到,结果都得到了,且是异步按序执行的。且代码的逻辑思路非常清晰。如果你感受还不是很大,那么你现象如果是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;
    }
}

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

【执行步骤】

C#异步的世界(上)

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

比如同步代码:

thread.sleep(10000);//假设这是个访问数据库的方法
thread.sleep(10000);//假设这是个访问*网站的方法

这个代码需要20秒。

如果是异步:

var task = task.run(() =>
{
    thread.sleep(10000);//假设这是个访问数据库的方法
});
thread.sleep(10000);//假设这是个访问*网站的方法
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);//假设这是个访问*网站的方法

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

还有一种情况:

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

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

答案是否。

还是拿单核做假设。

情况1:

long num = 0;
while (true)
{
    num += new random().next(-100,100);
    //thread.sleep(100);
}

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

C#异步的世界(上)

C#异步的世界(上)

启动八次,八进程cpu基本爆满。

情况2:

C#异步的世界(上)

C#异步的世界(上)

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

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

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

以上就是c#异步的世界(上)的详细内容,更多关于c#异步的世界的资料请关注其它相关文章!

相关标签: c# 异步 async