一、概述

1、什么是异步?

异步操作通常用于执行完成时间可能较长的任务,如打开大文件、连接远程计算机或查询数据库。异步操作在主应用程序线程以外的线程中执行。应用程序调用方法异步执行某个操作时,应用程序可在异步方法执行其任务时继续执行其他的任务。

2、同步与异步的区别

  • 同步(Synchronous):在执行某个操作时,应用程序必须等待该操作执行完成后才能继续执行。
  • 异步(Asynchronous):在执行某个操作时,应用程序可在异步操作执行时继续执行。实质:异步操作,启动了新的线程,主线程与异步线程(线程池中的线程)并行执行。

3、异步和多线程的区别

  • 线程管理:异步线程是由线程池负责管理,而多线程,我们可以自己控制,当然在多线程中我们也可以使用线程池!
  •       应用场景:IO密集型工作,采用异步机制;计算密集型工作,采用多线程!

就拿网络扒虫而言,如果使用异步模式去实现,它使用线程池进行管理。异步操作执行时,会将操作丢给线程池中的某个工作线程来完成。当开始I/O操作的时候,异步会将工作线程还给线程池,这意味着获取网页的工作不会再占用任何CPU资源了。直到异步完成,即获取网页完毕,异步才会通过回调的方式通知线程池。

4、为什么要使用异步

  •      异步模式借助于线程池,极大地节约了CPU的资源!
  •      异步编程不会阻塞主调用线程,有较好的用户体验!

二、使用 IAsyncResult 对象的异步编程

使用IAsyncResult设计模式的异步编程是通过名为 Begin*** 和 End*** 的两个方法来实现的,这两个方法分别指代开始和结束异步操作。

例如,FileStream类提供BeginRead和EndRead方法来从文件异步读取字节,这两个方法实现了 Read 方法的异步版本。

在调用 Begin*** 后,应用程序可以继续在调用线程上执行指令,同时异步操作在另一个线程上执行。(如果有返回值还应调用 End*** 来获取操作的结果)。

Begin*** 方法:

a) Begin*** 方法带有“与该方法的同步版本相同的”参数。

b) Begin*** 方法最后两个参数:

第一个参数定义一个AsyncCallback委托,就是异步操作完成时的回调函数。

        public delegate void AsyncCallback(IAsyncResult ar)

第二个参数是用户自定义的一个object类型的对象。可以向回调函数中传递一些信息,在异步操作完成时,在回调函数中可以通过result.AsyncState获取该对象(获取后记得要进行强制类型转换),注意result为IAsyncResult类型!

注意:这两个参数都可以传递null。(但是最好不要这样)

c) Begin*** 方法会返回IAsyncResult对象。

public interface IAsyncResult
{
// 获取用户定义的对象,它限定或包含关于异步操作的信息。
object AsyncState { get; }
// 获取用于等待异步操作完成的System.Threading.WaitHandle,待异步操作完成时获得信号。
WaitHandle AsyncWaitHandle { get; }
// 获取一个值,该值指示异步操作是否同步完成。
bool CompletedSynchronously { get; }
// 获取一个值,该值指示异步操作是否已完成。
bool IsCompleted { get; }
}

End***方法:

a) End*** 方法可结束异步操作,如果调用 End*** 时,IAsyncResult对象表示的异步操作还未完成,则 End*** 将在异步操作完成之前阻塞调用线程。

b) End*** 方法的返回值与其同步副本的返回值类型相同。End*** 方法带有该方法同步版本的签名中声明的所有out 和 ref 参数以及由BeginInvoke返回的IAsyncResult,规范上 IAsyncResult 参数放最后。

注意:1、要想获得返回结果,必须调用的方法;

2、若带有out 和 ref 参数,实现上委托也要带有out 和 ref 参数,以便在回调中获得对应引用传参值做相应逻辑;

3、总是调用 End***() 方法,而且只调用一次

AsyncCallback回调:

a) 异步调用的异常在此处扑捉,也就是try catch放在回调函数里边

b) 异步调用时的同步问题(对于共享资源的访问)也在该处处理

.NET中已经实现了许多IAsyncResult异步调用模式的组件,注意使用!

下面来看用该模式实现异步调用的一个栗子:

#region use APM to download file asynchronously

        private static void DownloadFileAsync(string url)
{
try
{
// Initialize an HttpWebRequest object
HttpWebRequest myHttpWebRequest = (HttpWebRequest)WebRequest.Create(url); // Create an instance of the RequestState and assign HttpWebRequest instance to its request field.
RequestState requestState = new RequestState();
requestState.request = myHttpWebRequest;
myHttpWebRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), requestState);
}
catch (Exception e)
{
Console.WriteLine("Error Message is:{0}",e.Message);
}
} // The following method is called when each asynchronous operation completes.
private static void ResponseCallback(IAsyncResult callbackresult)
{
// Get RequestState object
RequestState myRequestState = (RequestState)callbackresult.AsyncState; HttpWebRequest myHttpRequest = myRequestState.request; // End an Asynchronous request to the Internet resource
myRequestState.response = (HttpWebResponse)myHttpRequest.EndGetResponse(callbackresult); // Get Response Stream from Server
Stream responseStream = myRequestState.response.GetResponseStream();
myRequestState.streamResponse = responseStream; IAsyncResult asynchronousRead = responseStream.BeginRead(myRequestState.BufferRead, , myRequestState.BufferRead.Length, ReadCallBack, myRequestState);
} // Write bytes to FileStream
private static void ReadCallBack(IAsyncResult asyncResult)
{
try
{
// Get RequestState object
RequestState myRequestState = (RequestState)asyncResult.AsyncState; // Get Response Stream from Server
Stream responserStream = myRequestState.streamResponse; //
int readSize = responserStream.EndRead(asyncResult);
if (readSize > )
{
myRequestState.filestream.Write(myRequestState.BufferRead, , readSize);
responserStream.BeginRead(myRequestState.BufferRead, , myRequestState.BufferRead.Length, ReadCallBack, myRequestState);
}
else
{
Console.WriteLine("\nThe Length of the File is: {0}", myRequestState.filestream.Length);
Console.WriteLine("DownLoad Completely, Download path is: {0}", myRequestState.savepath);
myRequestState.response.Close();
myRequestState.filestream.Close();
}
}
catch (Exception e)
{
Console.WriteLine("Error Message is:{0}", e.Message);
}
}
#endregion

运行结果为(从运行结果也可以看出,在主线程中调用 DownloadFileAsync(downUrl)方法时,DownloadFileAsync(downUrl)方法中的myHttpWebRequest.BeginGetResponse调用被没有阻塞调用线程(即主线程),而是立即返回到主线程,是主线程后面的代码可以立即执行)

三、基于委托的异步编程模式

对于委托,编译器会为我们生成异步调用方法“BeginInvoke”和“EndInvoke”。异步委托是快速为方法构建异步调用的方式,它是基于IAsyncResult设计模式实现的异步调用:通过BeginInvoke返回IAsyncResult对象;通过EndInvoke获取结果值。

原理与IAsyncResult模式一致!

using System;
using System.Text; namespace AsynSample
{
/// <summary>
/// 下载委托
/// </summary>
/// <param name="fileName"></param>
public delegate string AysnDownloadDelegate(string fileName);
/// <summary>
/// 通过委托实现异步调用
/// </summary>
class DownloadFile
{
/// <summary>
/// 同步下载
/// </summary>
/// <param name="fileName"></param>
public string Downloading(string fileName)
{
string filestr = string.Empty;
Console.WriteLine("下载事件开始执行");
System.Threading.Thread.Sleep();
Random rand = new Random();
StringBuilder builder =new StringBuilder();
int num;
for(int i=;i<;i++)
{
num = rand.Next();
builder.Append(i);
}
filestr = builder.ToString();
Console.WriteLine("下载事件执行结束"); return filestr;
}
/// <summary>
/// 异步下载
/// </summary>
public IAsyncResult BeginDownloading(string fileName)
{
string fileStr = string.Empty;
AysnDownloadDelegate downloadDelegate = new AysnDownloadDelegate(Downloading);
return downloadDelegate.BeginInvoke(fileName, Downloaded, downloadDelegate);
}
/// <summary>
/// 异步下载完成后事件
/// </summary>
/// <param name="result"></param>
private void Downloaded(IAsyncResult result)
{
AysnDownloadDelegate aysnDelegate = result.AsyncState as AysnDownloadDelegate;
if (aysnDelegate != null)
{
string fileStr = aysnDelegate.EndInvoke(result);
if (!string.IsNullOrEmpty(fileStr))
{
Console.WriteLine("下载文件:{0}", fileStr);
}
else
{
Console.WriteLine("下载数据为空!");
}
}
else
{
Console.WriteLine("下载数据为空!");
}
}
}
}

四、基于事件的异步编程模式

简称EAP,从.NET 2.0起就提出了该异步编程模式,EAP主要是为Windows窗体开发人员创建的(C/S模式)。

  实现了基于事件的异步模式的类将具有一个或者多个以Async为后缀的方法和对应的Completed事件,并且这些类都支持异步方法的取消、进度报告和报告结果。 在.NET 类库中只有部分的类支持EAP的(共17个类):

System.Object的派生类型:

  System.Activies.WorkflowInvoke  

  System.Deployment.Application.ApplicationDeployment

  System.Deployment.Application.InPlaceHosingManager

  System.Net.Mail.SmtpClient

  System.Net.PeerToPeer.PeerNameResolver

  System.Net.PeerToPeer.Collaboration.ContactManager

  System.Net.PeerToPeer.Collaboration.Peer

  System.Net.PeerToPeer.Collaboration.PeerContact

  System.Net.PeerToPeer.Collaboration.PeerNearMe

  System.ServiceModel.Activities.WorkflowControlClient

  System.ServiceModel.Discovery.AnnoucementClient

  System.ServiceModel.Discovery.DiscoveryClient

System.ComponentModel.Component的派生类型:

     System.ComponentModel.BackgroundWorker

     System.Media.SoundPlay

     System.Net.WebClient

     System.Net.NetworkInformation.Ping

     System.Windows.Forms.PictureBox(继承于Control类,Control类派生于Component类)

举个栗子:

class Program
{
static void Main(string[] args)
{
WebClient client = new WebClient(); client.DownloadFileCompleted += new System.ComponentModel.AsyncCompletedEventHandler(client_DownloadFileCompleted); client.DownloadFileAsync(new Uri("http://imgsrc.baidu.com/baike/abpic/item/6a600c338744ebf844a0bc74d9f9d72a6159a7ac.jpg"),
"1.jpg", "图片下完了,你懂的!"); Console.WriteLine("我是主线程,我不会被阻塞!");
Console.Read();
} static void client_DownloadFileCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)
{
Console.WriteLine("\n" + e.UserState);
}
}

五、基于Task的异步编程模式

上面的集中异步编程模式在一定程度上是比较繁琐的,那么问题来了,异步编程哪家强?在.NET 4.0中提出了一个新的异步模式——基于任务的异步模式(TAP),该模式主要使用System.Threading.Tasks.Task和Task<T>类来完成异步编程,相对于前面几种异步模式来讲,TAP使异步编程模式更加简单(因为这里我们只需要关注Task这个类的使用),同时TAP也是微软推荐使用的异步编程模式。

.NET的类中“存在TaskAsync为后缀的方法”时就代表该类实现了TAP, 并且基于任务的异步模式同样也支持异步操作的取消和进度的报告的功能~

Task

  .NET 4.0推出了新一代的多线程模型Task。这里将以一个简单的Demo来看一下Task的使用,同时与Thread的创建方式做一下对比。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Threading;
using System.Threading.Tasks; namespace TestApp
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("主线程启动"); //.NET 4.5引入了Task.Run静态方法来启动一个线程
Task.Run(() => { Thread.Sleep(); Console.WriteLine("Task1启动"); }); //Task启动的是后台线程,假如要在主线程中等待后台线程执行完毕,可以调用Wait方法
Task task = Task.Run(() => { Thread.Sleep(); Console.WriteLine("Task2启动"); });
task.Wait(); Console.WriteLine("主线程结束");
}
}
}

首先,必须明确一点是Task启动的线程是后台线程,不过可以通过在Main方法中调用task.Wait()方法,使应用程序等待task执行完毕。Task与Thread的一个重要区分点是:Task底层是使用线程池的,而Thread每次实例化都会创建一个新的线程。这里可以通过这段代码做一次验证:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Threading;
using System.Threading.Tasks; namespace TestApp
{
class Program
{
static void DoRun1()
{
Console.WriteLine("Thread Id =" + Thread.CurrentThread.ManagedThreadId);
} static void DoRun2()
{
Thread.Sleep();
Console.WriteLine("Task调用Thread Id =" + Thread.CurrentThread.ManagedThreadId);
} static void Main(string[] args)
{
for (int i = ; i < ; i++)
{
new Thread(DoRun1).Start();
} for (int i = ; i < ; i++)
{
Task.Run(() => { DoRun2(); });
} //让应用程序不立即退出
Console.Read();
}
}
}

运行代码,可以看到DoRun1()方法每次的Thread Id都是不同的,而DoRun2()方法的Thread Id是重复出现的。我们知道线程的创建和销毁是一个开销比较大的操作,Task.Run()每次执行将不会立即创建一个新线程,而是到CLR线程池查看是否有空闲的线程,有的话就取一个线程处理这个请求,处理完请求后再把线程放回线程池,这个线程也不会立即撤销,而是设置为空闲状态,可供线程池再次调度,从而减少开销。

Task<TResult>

  Task<TResult>是Task的泛型版本,这两个之间的最大不同是Task<TResult>可以有一个返回值,看一下代码应该一目了然:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Threading;
using System.Threading.Tasks; namespace TestApp
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("主线程开始"); Task<string> task = Task<string>.Run(() => { Thread.Sleep(); return Thread.CurrentThread.ManagedThreadId.ToString(); });
Console.WriteLine(task.Result); Console.WriteLine("主线程结束");
}
}
}

Task<TResult>的实例对象有一个Result属性,当在Main方法中调用task.Result的时候,将等待task执行完毕并得到返回值,这里的效果跟调用task.Wait()是一样的,只是多了一个返回值。

async/await 特性

  .NET 4.5 的推出,对于C#又有了新特性的增加——就是C#5.0中async和await两个关键字,这两个关键字简化了异步编程,之所以简化了,是因为编译器给我们做了更多的工作,async/await特性是与Task紧密相关的。先通过代码来感受一下这两个特性的使用。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Threading;
using System.Threading.Tasks; namespace TestApp
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("-------主线程启动-------");
Task<int> task = GetLengthAsync();
Console.WriteLine("Main方法做其他事情");
Console.WriteLine("Task返回的值" + task.Result);
Console.WriteLine("-------主线程结束-------");
} static async Task<int> GetLengthAsync()
{
Console.WriteLine("GetLengthAsync Start");
string str = await GetStringAsync();
Console.WriteLine("GetLengthAsync End");
return str.Length;
} static Task<string> GetStringAsync()
{
return Task<string>.Run(() => { Thread.Sleep(); return "finished"; });
}
}
}

首先来看一下async关键字。async用来修饰方法,表明这个方法是异步的,声明的方法的返回类型必须为:void或Task或Task<TResult>。返回类型为Task的异步方法中无需使用return返回值,而返回类型为Task<TResult>的异步方法中必须使用return返回一个TResult的值,如上述Demo中的异步方法返回一个int。

  再来看一下await关键字。await必须用来修饰Task或Task<TResult>,而且只能出现在已经用async关键字修饰的异步方法中。

  通常情况下,async/await必须成对出现才有意义,假如一个方法声明为async,但却没有使用await关键字,则这个方法在执行的时候就被当作同步方法,这时编译器也会抛出警告提示async修饰的方法中没有使用await,将被作为同步方法使用。了解了关键字async\await的特点后,我们来看一下上述Demo在控制台会输出什么吧。

  

  输出的结果已经很明确地告诉我们整个执行流程了。GetLengthAsync异步方法刚开始是同步执行的,所以"GetLengthAsync Start"字符串会被打印出来,直到遇到第一个await关键字,真正的异步任务GetStringAsync开始执行,await相当于起到一个标记/唤醒点的作用,同时将控制权放回给Main方法,"Main方法做其他事情"字符串会被打印出来。之后由于Main方法需要访问到task.Result,所以就会等待异步方法GetLengthAsync的执行,而GetLengthAsync又等待GetStringAsync的执行,一旦GetStringAsync执行完毕,就会回到await GetStringAsync这个点上执行往下执行,这时"GetLengthAsync End"字符串就会被打印出来。

  当然,我们也可以使用下面的方法完成上面控制台的输出。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Threading;
using System.Threading.Tasks; namespace TestApp
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("-------主线程启动-------");
Task<int> task = GetLengthAsync();
Console.WriteLine("Main方法做其他事情");
Console.WriteLine("Task返回的值" + task.Result);
Console.WriteLine("-------主线程结束-------");
} static Task<int> GetLengthAsync()
{
Console.WriteLine("GetLengthAsync Start");
Task<int> task = Task<int>.Run(() => { string str = GetStringAsync().Result;
Console.WriteLine("GetLengthAsync End");
return str.Length; });
return task;
} static Task<string> GetStringAsync()
{
return Task<string>.Run(() => { Thread.Sleep(); return "finished"; });
}
}
} //不使用async\await

对比两种方法,是不是async\await关键字的原理其实就是通过使用一个线程完成异步调用吗?答案是否定的。async关键字表明可以在方法内部使用await关键字,方法在执行到await前都是同步执行的,运行到await处就会挂起,并返回到Main方法中,直到await标记的Task执行完毕,才唤醒回到await点上,继续向下执行。

async/await 实际应用

  微软已经对一些基础类库的方法提供了异步实现,接下来将实现一个例子来介绍一下async/await的实际应用。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Threading;
using System.Threading.Tasks;
using System.Net; namespace TestApp
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("开始获取博客园首页字符数量");
Task<int> task1 = CountCharsAsync("http://www.cnblogs.com");
Console.WriteLine("开始获取百度首页字符数量");
Task<int> task2 = CountCharsAsync("http://www.baidu.com"); Console.WriteLine("Main方法中做其他事情"); Console.WriteLine("博客园:" + task1.Result);
Console.WriteLine("百度:" + task2.Result);
} static async Task<int> CountCharsAsync(string url)
{
WebClient wc = new WebClient();
string result = await wc.DownloadStringTaskAsync(new Uri(url));
return result.Length;
}
}
} //Demo

C#秘密武器之异步编程的更多相关文章

  1. 第一章-第七题( 有人认为,“中文编程”, 是解决中国程序员编程效率一个秘密武器,请问它是一个 “银弹” 么? )--By 侯伟婷

    首先,“银弹”在百度百科中的解释是银色的子弹,我们更熟知的“银弹”一词,应该是在<人月神话>中提到的.银弹原本应该是指某种策略.技术或者技巧可以极大地提高程序员的生产力[1].此题目中关于 ...

  2. C#与C++的发展历程第三 - C#5.0异步编程巅峰

    系列文章目录 1. C#与C++的发展历程第一 - 由C#3.0起 2. C#与C++的发展历程第二 - C#4.0再接再厉 3. C#与C++的发展历程第三 - C#5.0异步编程的巅峰 C#5.0 ...

  3. async 与 await异步编程活用基础

    [本文转自:http://www.cnblogs.com/x-xk/archive/2013/06/05/3118005.html  作者:肅] 好久没写博客了,时隔5个月,奉上一篇精心准备的文章,希 ...

  4. async And await异步编程活用基础

    原文:async And await异步编程活用基础 好久没写博客了,时隔5个月,奉上一篇精心准备的文章,希望大家能有所收获,对async 和 await 的理解有更深一层的理解. async 和 a ...

  5. C#异步编程(一)

    异步编程简介 前言 本人学习.Net两年有余,是第一次写博客,虽然写的很认真,当毕竟是第一次,肯定会有很多不足之处, 希望大家照顾照顾新人,有错误之处可以指出来,我会虚心接受的. 何谓异步 与同步相对 ...

  6. TypeScript: Angular 2 的秘密武器(译)

    本文整理自Dan Wahlin在ng-conf上的talk.原视频地址: https://www.youtube.com/watch?v=e3djIqAGqZo 开场白 开场白主要分为三部分: 感谢了 ...

  7. 关于如何提高Web服务端并发效率的异步编程技术

    最近我研究技术的一个重点是java的多线程开发,在我早期学习java的时候,很多书上把java的多线程开发标榜为简单易用,这个简单易用是以C语言作为参照的,不过我也没有使用过C语言开发过多线程,我只知 ...

  8. 异步编程 In .NET

    概述 在之前写的一篇关于async和await的前世今生的文章之后,大家似乎在async和await提高网站处理能力方面还有一些疑问,博客园本身也做了不少的尝试.今天我们再来回答一下这个问题,同时我们 ...

  9. C#异步编程(二)

    async和await结构 序 前篇博客异步编程系列(一) 已经介绍了何谓异步编程,这篇主要介绍怎么实现异步编程,主要通过C#5.0引入的async/await来实现. BeginInvoke和End ...

随机推荐

  1. 【cocos2d-js教程】cocos2d-js 遮挡层(禁止触摸事件传递层)

    在游戏中,我们经常会碰到一些弹窗,这些弹窗禁止点透,也就是禁止触摸事件传递到底层,我们称之为遮挡层,这些遮挡层,需要开发遮挡层,我们首先得了解cocos2d-js的触摸传递机制,本文主要针对cocos ...

  2. [BZOJ5011][JXOI2017]颜色

    5011: [Jx2017]颜色 Time Limit: 30 Sec  Memory Limit: 512 MBSubmit: 84  Solved: 46[Submit][Status][Disc ...

  3. 【推导】【NTT】hdu6061 RXD and functions(NTT)

    题意:给定一个n次多项式f(x)的各项系数,让你求f(x-Σai)的各项系数. http://blog.csdn.net/v5zsq/article/details/76780053 推导才是最关键的 ...

  4. 【二项式定理】【推导】计蒜客17115 2017 ACM-ICPC 亚洲区(西安赛区)网络赛 B. Coin

    题意:投一枚硬币向上的概率是q/p.问你投K枚硬币,向上的枚数为偶数枚的概率是? 要求的即为. 这个东西是个二项展开式的偶数项系数和,来,我们复习一下高中数学,设f(x)=(ax+b)^n,则其偶数项 ...

  5. 【Trie】MIPT-2016 Pre-Finals Workshop, Taiwan NTU Contest, Sunday, March 27, 2016 Problem B. Be Friends

    题意:一个n个点的完全图,点带权,边权是两端点点权的异或值.问你最小生成树. 一个性质,把所有点按照二进制最高位是否为1划分为2个集合,那么这两个集合间只会有一条边.可以递归处理. 把所有点建成01T ...

  6. Java 导出大批量数据excel(百万级)(转载)

    参考资料:http://bbs.51cto.com/thread-1074293-1-1.html                 http://bbs.51cto.com/viewthread.ph ...

  7. [转]spring4.x注解概述

    1. 背景 注解可以减少代码的开发量,spring提供了丰富的注解功能,因项目中用到不少注解,因此下定决心,经spring4.x中涉及到的注解罗列出来,供查询使用. 2. spring注解图     ...

  8. CDOJ 1280 772002画马尾 每周一题 div1 矩阵快速幂

    772002画马尾 题目连接: http://acm.uestc.edu.cn/#/problem/show/1280 Description 众所周知772002很喜欢马尾,所以他决定画几幅马尾送给 ...

  9. MYSQL数据库迁移总结

    Auth: JinDate: 2014-04-03 前端操作,后续测试对外开放不在本文 准备阶段操作阶段后续阶段 需求:phpcms和anquanzuo在一个mysql实例中anquanzuo有一张视 ...

  10. [工具开发]Proxpy Web Scan设计与实现

    组内交流培训