且BeginXXX重回值是IAsyncResult接口,就是这多少个类是BeginXXX和EndXXX的格局

读书目录

 

新进阶的程序员可能对async、await用得相比较多,却对前面的异步领会什么少。本人就是此类,因而打算回顾学习下异步的进化史。 

正文紧要是回顾async异步情势以前的异步,下篇随笔再来重点分析async异步形式。

翻阅目录

 

新进阶的程序员可能对async、await用得相比较多,却对前边的异步明白什么少。本人就是此类,由此打算回顾学习下异步的进化史。 

正文重尽管回顾async异步格局在此以前的异步,下篇著作再来重点分析async异步形式。

APM

APM 异步编程模型,Asynchronous Programming Model

早在C#1的时候就有了APM。即使不是很熟习,可是多少如故见过的。就是这些类是BeginXXX和EndXXX的主意,且BeginXXX再次来到值是IAsyncResult接口。

在业内写APM示例以前我们先付给一段同步代码:

图片 1

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

图片 2

【表达】为了更好的以身作则异步效果,这里我们应用winform程序来做示范。(因为winform始终都急需UI线程渲染界面,如果被UI线程占用则会油不过生“假死”状态)

【效果图】

图片 3

看图得知:

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

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

图片 4

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

图片 5

【效果图】

 图片 6

看图得知:

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

地点代码执行顺序:

图片 7

前方我们说过,APM的BebinXXX必须重回IAsyncResult接口。那么接下去大家解析IAsyncResult接口:

首先我们看:

图片 8

确实返回的是IAsyncResult接口。这IAsyncResult到底长的怎么样体统?:

图片 9

并从未想像中的那么复杂嘛。大家是不是可以尝试这贯彻这么些接口,然后显示自己的异步方法呢?

率先定一个类MyWebRequest,然后继续IAsyncResult:(下边是基本的伪代码实现)

图片 10

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

图片 11

这样必然是不可以用的,起码也得有个存回调函数的性能吧,下边我们略微改造下:

图片 12

接下来大家可以自定义APM异步模型了:(成对的Begin、End)

图片 13

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

图片 14

调用如下:

图片 15

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

图片 16

效果图:

图片 17

咱俩来看自己实现的坚守基本上和系统提供的基本上。

  • 启用异步方法并不曾是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)

图片 18

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

图片 19

APM

APM 异步编程模型,Asynchronous Programming Model

早在C#1的时候就有了APM。即使不是很熟谙,不过多少仍然见过的。就是那一个类是BeginXXX和EndXXX的艺术,且BeginXXX重临值是IAsyncResult接口。

在业内写APM示例在此之前咱们先付给一段同步代码:

图片 20

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

图片 21

【表达】为了更好的言传身教异步效果,这里我们拔取winform程序来做示范。(因为winform始终都需要UI线程渲染界面,假如被UI线程占用则会油不过生“假死”状态)

【效果图】

图片 22

看图得知:

  • 大家在实施措施的时候页面现身了“假死”,拖不动了。
  • 咱俩来看打印结果,方法调用前和调用后线程ID都是9(也就是同一个线程)

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

图片 23

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

图片 24

【效果图】

 图片 25

看图得知:

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

地点代码执行顺序:

图片 26

面前大家说过,APM的BebinXXX必须重返IAsyncResult接口。那么接下去我们分析IAsyncResult接口:

第一大家看:

图片 27

实在重回的是IAsyncResult接口。这IAsyncResult到底长的怎样子?:

图片 28

并从未想像中的那么复杂嘛。我们是否足以尝尝这贯彻这些接口,然后突显自己的异步方法吧?

第一定一个类MyWebRequest,然后继续IAsyncResult:(上边是主导的伪代码实现)

图片 29

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

图片 30

如此这般必然是不可以用的,起码也得有个存回调函数的属性吧,下边大家稍事改造下:

图片 31

接下来大家得以自定义APM异步模型了:(成对的Begin、End)

图片 32

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

图片 33

调用如下:

图片 34

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

图片 35

效果图:

图片 36

大家看来自己实现的意义基本上和序列提供的几近。

  • 启用异步方法并不曾是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)

图片 37

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

图片 38

EAP

EAP 基于事件的异步情势,伊夫(Eve)nt-based Asynchronous Pattern

此格局在C#2的时候光顾。

先来看个EAP的事例:

图片 39

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

图片 40

 

【效果图】(同样不会阻塞UI界面)

图片 41

【特征】

  • 由此事件的办法注册回调函数
  • 通过 XXXAsync方法来实施异步调用

事例很简短,不过和APM格局相相比较,是不是没有那么清晰透明。为何可以这样实现?事件的注册是在干嘛?为何执行RunWorkerAsync会触发注册的函数?

感到温馨又想多了…

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

图片 42

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

EAP

EAP 基于事件的异步情势,伊芙nt-based Asynchronous Pattern

此情势在C#2的时候光顾。

先来看个EAP的事例:

图片 43

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

图片 44

 

【效果图】(同样不会阻塞UI界面)

图片 45

【特征】

  • 通过事件的法子注册回调函数
  • 透过 XXXAsync方法来举办异步调用

事例很粗略,可是和APM形式比较,是不是一向不那么清晰透明。为何可以这么实现?事件的注册是在干嘛?为何执行RunWorkerAsync会触发注册的函数?

感觉自己又想多了…

咱俩试着反编译看看源码:

图片 46

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

TAP

TAP 基于任务的异步情势,Task-based Asynchronous Pattern

到近期结束,我们认为下边的APM、EAP异步情势好用啊?好像一直不意识什么样问题。再精心想想…假诺我们有五个异步方法需要按先后顺序执行,并且需要(在主进程)拿到所有重返值。

先是定义五个委托:

图片 47

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

图片 48

接下来按照一定顺序执行:

图片 49

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

图片 50

除此之外难看、难读一点好像也没怎么 。不过实在是这样吗?

图片 51

asyncResult2是null?
显而易见在完成第一个异步操作在此之前未曾对asyncResult2举办赋值,asyncResult2执行异步等待的时候报那些。那么这么大家就不能够控制四个异步函数,遵照一定顺序执行到位后再得到重临值。(理论上或者有其他格局的,只是会然代码更加错综复杂)

 

毋庸置疑,现在该我们的TAP登场了。

图片 52

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

拿到重回值:

图片 53

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

图片 54

今日大家处理方面五个异步按序执行:

图片 55

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

图片 56

[效果图]

图片 57

我们见到,结果都得到了,且是异步按序执行的。且代码的逻辑思路卓殊清楚。假设您感受还不是很大,那么您现象即便是100个异步方法需要异步按序执行呢?用APM的异步回调,这至少也得异步回调嵌套100次。这代码的复杂度可想而知。

 

TAP

TAP 基于任务的异步格局,Task-based Asynchronous Pattern

到最近截至,咱们觉得上边的APM、EAP异步情势好用吗?好像一贯不发觉什么问题。再细致想想…假设我们有两个异步方法需要按先后顺序执行,并且需要(在主进程)拿到所有重临值。

率先定义多少个委托:

图片 58

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

图片 59

下一场遵照一定顺序执行:

图片 60

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

图片 61

除外难看、难读一点好像也没怎么 。可是确实是如此吧?

图片 62

asyncResult2是null?
有鉴于此在成功第一个异步操作以前从未对asyncResult2举行赋值,asyncResult2执行异步等待的时候报那一个。那么这样我们就不可能控制两个异步函数,按照一定顺序执行到位后再拿到重回值。(理论上依然有此外办法的,只是会然代码更加复杂)

 

科学,现在该我们的TAP登场了。

图片 63

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

取得重临值:

图片 64

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

图片 65

最近大家处理方面两个异步按序执行:

图片 66

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

图片 67

[效果图]

图片 68

大家见到,结果都取得了,且是异步按序执行的。且代码的逻辑思路特别明显。如果你感触还不是很大,那么你现象一经是100个异步方法需要异步按序执可以吗?用APM的异步回调,这至少也得异步回调嵌套100次。这代码的复杂度综上说述。

 

延伸思考

  • WaitOne完成等待的原理

  • 异步为何会升级性能

  • 线程的运用数据和CPU的使用率有早晚的牵连吗

 

题目1:WaitOne完成等待的法则

以前,大家先来简单的问询下多线程信号控制AutoReset伊芙(Eve)nt类。

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

此代码会在 WaitOne 的地点会直接等候下去。除非有另外一个线程执行 AutoReset伊夫nt 的set方法。

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

如此这般,到了 WaitOne 就足以从来实施下去。没有有其他等待。

现今我们对APM 异步编程模型中的 WaitOne 等待是不是领略了点什么吗。大家回头来促成往日自定义异步方法的异步等待。

图片 69

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

图片 70

辛酉革命代码就是增创的异步等待。

【执行步骤】

图片 71

 

题目2:异步为何会提升性能

诸如同步代码:

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

这么些代码需要20秒。

比方是异步:

图片 72

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

图片 73

这么就假若10秒了。这样就省去了10秒。

如果是:

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

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

或者:

图片 74

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

图片 75

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

再有一种情景:

假定是单核CPU举办高密集运算操作,那么异步也是从未意思的。(因为运算是那么些耗CPU,而网络请求等待不耗CPU)

 

题材3:线程的行使数据和CPU的使用率有自然的关联呢

答案是否。

抑或拿单核做假使。

情况1:

图片 76

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

图片 77

单核下,大家只启动一个线程,就足以让您CPU爆满。

图片 78图片 79

开端八次,八进程CPU基本满员。

情况2:

图片 80

图片 81

一千五个线程,而CPU的使用率竟然是0。由此,我们拿到了此前的结论,线程的应用数据和CPU的使用率没有一定的交换。

即使这样,可是也不可能不用节制的敞开线程。因为:

  • 拉开一个新的线程的经过是相比较耗资源的。(不过使用线程池,来降低开启新线程所消耗的资源)
  • 多线程的切换也是索要时刻的。
  • 各样线程占用了肯定的内存保存线程上下文新闻。

 

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

延伸思考

  • WaitOne完成等待的原理

  • 异步为何会升级性能

  • 线程的利用数据和CPU的使用率有早晚的关联呢

 

题目1:WaitOne完成等待的原理

此前,我们先来简单的问询下多线程信号控制AutoReset伊夫nt类。

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

此代码会在 WaitOne 的地点会一直守候下去。除非有此外一个线程执行 AutoReset伊芙(Eve)nt 的set方法。

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

这样,到了 WaitOne 就可以一向实施下去。没有有另外等待。

目前大家对APM 异步编程模型中的 WaitOne 等待是不是知道了点什么呢。大家回头来促成以前自定义异步方法的异步等待。

图片 82

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

图片 83

革命代码就是增创的异步等待。

【执行步骤】

图片 84

 

问题2:异步为啥会升级性能

例如同步代码:

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

其一代码需要20秒。

一旦是异步:

图片 85

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

图片 86

诸如此类就假设10秒了。这样就省去了10秒。

如果是:

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

异步执行中间没有耗时的代码那么这么的异步将是没有趣味的。

或者:

图片 87

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

图片 88

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

还有一种状态:

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

 

题目3:线程的拔取数据和CPU的使用率有必然的联系吗

答案是否。

如故拿单核做假若。

情况1:

图片 89

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

图片 90

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

图片 91图片 92

起步八次,八经过CPU基本满员。

情况2:

图片 93

图片 94

一千四个线程,而CPU的使用率竟然是0。由此,大家取得了事先的结论,线程的采用数据和CPU的使用率没有一定的维系。

虽说这样,可是也无法毫无节制的拉开线程。因为:

  • 敞开一个新的线程的经过是相比较耗资源的。(不过使用线程池,来降低开启新线程所耗费的资源)
  • 多线程的切换也是需要时刻的。
  • 各样线程占用了肯定的内存保存线程上下文音信。

 

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

相关文章