C#中的async和await的使用详解

C#中的async和await的使用详解

1. 简单介绍

• 在C#中，在很多的时候，都需要一些异步操作，并且在做完这些异步操作之后，可以在后面接着做一些处理，在 .net framework 4.5之后，便加入了一种简洁的方式来使用异步操作，这就是async和await。
• async用来声明一个函数体，将其声明为异步方法，而await则是用在这个函数体的内部，用于等待一个异步操作的完成。
• 异步方法内部可以出现一个或者多个await，一般不要是0个，这样就失去了异步方法的意义了。

2. 异步方法中的线程切换：

(1).非UI线程中执行

        static void Main(string[] args)
        {
            MethodAsync1();
            Console.Read();
        }
        static async void MethodAsync1()
        {
            Console.WriteLine("当前主线程ID为：" + Thread.CurrentThread.ManagedThreadId );
            Console.WriteLine("是否为线程池线程：" + Thread.CurrentThread.IsThreadPoolThread);
            
            await Task.Run(() => {
                Console.WriteLine("第一个await当前线程ID为：" + Thread.CurrentThread.ManagedThreadId );
                Console.WriteLine("是否为线程池线程：" + Thread.CurrentThread.IsThreadPoolThread);
            });
            Console.WriteLine("第一个await结束后当前线程ID为：" + Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine("是否为线程池线程：" + Thread.CurrentThread.IsThreadPoolThread);
            
            await Task.Run(() => {
                Console.WriteLine("第二个await当前线程ID为：" + Thread.CurrentThread.ManagedThreadId );
                Console.WriteLine("是否为线程池线程：" + Thread.CurrentThread.IsThreadPoolThread);
            });
            Console.WriteLine("第二个await结束后当前线程ID为：" + Thread.CurrentThread.ManagedThreadId );
            Console.WriteLine("是否为线程池线程：" + Thread.CurrentThread.IsThreadPoolThread);
        }

该演示是在控制台应用程序中完成的，我们可以看到，主线程的ID为10，第一个await和紧接着之后的代码的线程ID为6和11，第二个await和紧接着之后的代码的线程ID为6，在非UI的线程中执行async异步方法，await等待的异步操作和之后接着要执行的代码，都是从线程池中获取了一个线程来执行代码，并且从线程池中获取的也不一定是同一个线程。

(2).UI线程中执行

那么，我们再来看一下，在UI线程中执行async的线程切换的规律：

        private void button1_Click(object sender, EventArgs e)
        {
            MethodAsync1();
        }
        string message;
        async void MethodAsync1()
        {
            message += ("当前主线程ID为：" + Thread.CurrentThread.ManagedThreadId + "\r\n");
            message += ("是否为线程池线程：" + Thread.CurrentThread.IsThreadPoolThread + "\r\n");
            await Task.Run(() => {
                message += ("第一个await当前线程ID为：" + Thread.CurrentThread.ManagedThreadId + "\r\n");
                message += ("是否为线程池线程：" + Thread.CurrentThread.IsThreadPoolThread + "\r\n");
            });
            message += ("第一个await结束后当前线程ID为：" + Thread.CurrentThread.ManagedThreadId + "\r\n");
            message += ("是否为线程池线程：" + Thread.CurrentThread.IsThreadPoolThread + "\r\n");
            await Task.Run(() => {
                message += ("第二个await当前线程ID为：" + Thread.CurrentThread.ManagedThreadId + "\r\n");
                message += ("是否为线程池线程：" + Thread.CurrentThread.IsThreadPoolThread + "\r\n");
            });
            message += ("第二个await结束后当前线程ID为：" + Thread.CurrentThread.ManagedThreadId + "\r\n");
            message += ("是否为线程池线程：" + Thread.CurrentThread.IsThreadPoolThread + "\r\n");
            this.richTextBox1.Text = message;
        }

这个演示可以看到，在UI线程中使用async异步方法的时候，await后紧接着的代码，一直都会是在UI线程中执行。

(3).因此，在使用的时候需要注意这一点，在UI与非UI线程中执行async异步方法的时候，需要注意这两个细节，否则将会带来不必要的麻烦。

3. 获取异步方法的返回值：

        static void Main(string[] args)
        {
            var a = MethodAsync1();
            Console.WriteLine(a.Result);
            Console.Read();
        }
        static async Task<int> MethodAsync1()
        {
            return await Task.Run(() =>
            {
                Thread.Sleep(1000);
                return 1;
            });
        }

如代码所示，定义一个Task类型返回值的异步方法，先执行这个异步方法MethodAsync1()，然后获取该异步方法的返回值，在这个获取返回值的过程中，执行异步方法的原来的线程也会一直阻塞直到等到获取到返回值，毫无意外的程序在运行一秒钟以后，输出1。
这样显然是没有问题的，需要注意的是，上面我们说过，在UI线程与非UI线程中执行异步方法是有差异的，稍不注意，是可能带来死锁的现象的。
代码如下：

        private void button1_Click(object sender, EventArgs e)
        {
            var a = MethodAsync1();
            richTextBox1.Text = a.Result.ToString();
        }
        async Task<int> MethodAsync1()
        {
            await Task.Run(() =>
            {
                Thread.Sleep(1000);
            });
            return 1;
        }

同样的是定义一个带Task类型返回值的异步方法，同样的也是先执行这个异步方法MethodAsync1()，然后获取该异步方法的返回值，但是，在这里，我们使用了WinForm程序来执行，该异步方法是在UI线程调用的，那么，现在就出现问题了，一旦点击button1按钮，程序便卡死了。

都是同样的用法，但是在这里就卡死了，什么情况呢？

上面说过了，在UI线程中调用的异步方法，在其await操作之后的一些代码，仍然实在UI线程中执行的，那么，首先，点击button1按钮按钮，异步方法执行await中的异步任务，UI线程就已经开始等这个结果了，在等的时候就把UI线程给阻塞了，而await任务执行完以后，return 1这个操作也需要在UI线程中执行，但是他已经被阻塞了，无法执行任何代码，就这样，我在等你返回值，你在等我释放UI线程来给你执行代码，谁也不相让，造成了程序的卡死。

当然了，实际上这样的操作本来就是不被允许的，UI线程不应该做任何的等待和阻塞处理，因为它需要实时地响应用户的界面请求。

 

C# Async/Await异步函数原理

原理

与同步函数相比，CLR在执行异步函数时有几个不同的特点：

1.        并非一次完成，而且分多次完成

2.        并非由同一个线程完成，而是线程池每次动态分配一个线程来处理；

结合这些特点，C#编译器将异步函数转换为一个状态机结构。这种结构能挂起和恢复。它的执行方式是一种工作流的方式。

执行步骤

1.        CLR创建一个状态机，这个状态机的操作数默认值为-1。

2.        开始执行状态机

3.        状态机通过操作数来选定执行路径

4.        状态机调用GetAwaiter方法来获取一个等待者对象awaiter,它的类型为TaskAwaiter

5.        状态机获取awaiter后，查询其IsCompleted属性。

6.        若IsCompleted为True,则操作已经以同步方式完成，状态机继续执行以处理结果。

7.        若IsCompleted为False,则操作将以异步方式来完成，状态机调用awaiter的OnCompleted方法并向它传递一个委托(引用状态机的MoveNext来实现工作流状态的变迁)。这时状态机允许线程返回原地以执行其它代码。

8.        将来某个时候，awaiter会在完成时调用委托以执行MoveNext,这时可根据状态机中的字段知道如何到达代码中的正确位置，使方法能够从它当初离开的位置继续。

9.        调用awaiter的GetResult方法获取结果，并进行处理。

10.    状态机执行完毕后，垃圾回收器会回收任何内存。

限制

1.        应用程序的Main方法不能转变成异步函数

2.        构造函数、属性、事件不能转变成异步函数

3.        不能在catch、finally、unsafe块中使用await操作符

4.        不能在支持线程锁中使用await操作符

5.        Linq中，只能在from子句的第一个集合表达式或join子句的集合表达式中使用await操作符。

 

C# 彻底搞懂async/await

转载

前言

Talk is cheap, Show you the code first！

private void button1_Click(object sender, EventArgs e)
{
    Console.WriteLine("111 balabala. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
    AsyncMethod();
    Console.WriteLine("222 balabala. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
}

private async Task AsyncMethod()
{
    var ResultFromTimeConsumingMethod = TimeConsumingMethod();
    string Result = await ResultFromTimeConsumingMethod + " + AsyncMethod. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId;
    Console.WriteLine(Result);
    //返回值是Task的函数可以不用return
}

//这个函数就是一个耗时函数，可能是IO操作，也可能是cpu密集型工作。
private Task TimeConsumingMethod()
{            
    var task = Task.Run(()=> {
        Console.WriteLine("Helo I am TimeConsumingMethod. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
        Thread.Sleep(5000);
        Console.WriteLine("Helo I am TimeConsumingMethod after Sleep(5000). My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
        return "Hello I am TimeConsumingMethod";
    });

    return task;
}

我靠，这么复杂！！！竟然有三个函数！！！竟然有那么多行！！！

别着急，慢慢看完，最后的时候你会发现使用async/await真的炒鸡优雅。

异步方法的结构

上面是一个的使用async/await的例子（为了方便解说原理我才写的这样复杂的）。
使用async/await能非常简单的创建异步方法，防止耗时操作阻塞当前线程。
使用async/await来构建的异步方法，逻辑上主要有下面三个结构：

调用异步方法

private void button1_Click(object sender, EventArgs e)
{
    Console.WriteLine("111 balabala. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
    AsyncMethod();//这个方法就是异步方法，异步方法的调用与一般方法完全一样
    Console.WriteLine("222 balabala. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
}

注意：微软建议异步方法的命名是在方法名后添加Aysnc后缀，示例是我为了读起来方便做成了前缀，在真正构建异步方法的时候请注意用后缀。(好吧我承认是我忘记了，然后图片也都截好了再修改太麻烦了。。。。就懒得重新再修改了)

异步方法的返回类型只能是void、Task、Task。示例中异步方法的返回值类型是Task。

另外，上面的AsyncMethod()会被编译器提示报警，如下图：

因为是异步方法，所以编译器提示在前面使用await关键字，这个后面再说，为了不引入太多概念导致难以理解暂时就先这么放着。

异步方法本体

private async Task AsyncMethod()
{
    var ResultFromTimeConsumingMethod = TimeConsumingMethod();
    string Result = await ResultFromTimeConsumingMethod + " + AsyncMethod. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId;
    Console.WriteLine(Result);
    //返回值是Task的函数可以不用return
}

用async来修饰一个方法，表明这个方法是异步的，声明的方法的返回类型必须为：void或Task或Task。方法内部必须含有await修饰的方法，如果方法内部没有await关键字修饰的表达式，哪怕函数被async修饰也只能算作同步方法，执行的时候也是同步执行的。

被await修饰的只能是Task或者Task类型，通常情况下是一个返回类型是Task/Task的方法，当然也可以修饰一个Task/Task变量，await只能出现在已经用async关键字修饰的异步方法中。上面代码中就是修饰了一个变量ResultFromTimeConsumingMethod。

关于被修饰的对象，也就是返回值类型是Task和Task函数或者Task/Task类型的变量：如果是被修饰对象的前面用await修饰，那么返回值实际上是void或者TResult（示例中ResultFromTimeConsumingMethod是TimeConsumingMethod()函数的返回值，也就是Task类型，当ResultFromTimeConsumingMethod在前面加了await关键字后 await ResultFromTimeConsumingMethod实际上完全等于 ResultFromTimeConsumingMethod.Result）。如果没有await，返回值就是Task或者Task。

耗时函数

//这个函数就是一个耗时函数，可能是IO密集型操作，也可能是cpu密集型工作。
private Task TimeConsumingMethod()
{            
    var task = Task.Run(()=> {
        Console.WriteLine("Helo I am TimeConsumingMethod. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
        Thread.Sleep(5000);
        Console.WriteLine("Helo I am TimeConsumingMethod after Sleep(5000). My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
        return "Hello I am TimeConsumingMethod";
    });

    return task;
}

这个函数才是真正干活的（为了让逻辑层级更分明，我把这部分专门做成了一个函数，在后面我会精简一下直接放到异步函数中，毕竟活在哪都是干）。

在示例中是一个CPU密集型的工作，我另开一线程让他拼命干活干5s。如果是IO密集型工作比如文件读写等可以直接调用.Net提供的类库，对于这些类库底层具体怎么实现的？是用了多线程还是DMA？或者是多线程+DMA？这些问题我没有深究但是从表象看起来和我用Task另开一个线程去做耗时工作是一样的。

await只能修饰Task/Task类型，所以这个耗时函数的返回类型只能是Task/Task类型。

总结：有了上面三个结构就能完成使用一次异步函数。

async/await异步函数的原理

在开始讲解这两个关键字之前,为了方便，对某些方法做了一些拆解，拆解后的代码块用代号指定：

上图对示例代码做了一些指定具体就是：

• Caller代表调用方函数，在上面的代码中就是button1_Click函数。
• CalleeAsync代表被调用函数，因为代码中被调用函数是一个异步函数，按照微软建议的命名添加了Async后缀，在上面示例代码中就是AsyncMethod()函数。
• CallerChild1代表调用方函数button1_Click在调用异步方法CalleeAsync之前的那部分代码。
• CallerChild2代表调用方函数button1_Click在调用异步方法CalleeAsync之后的那部分代码。
• CalleeChild1代表被调用方函数AsyncMethod遇到await关键字之前的那部分代码。
• CalleeChild2代表被调用方函数AsyncMethod遇到await关键字之后的那部分代码。
• TimeConsumingMethod是指被await修饰的那部分耗时代码（实际上我代码中也是用的这个名字来命名的函数）

示例代码的执行流程

为了方便观看我模糊掉了对本示例没有用的输出。
这里涉及到了两个线程，线程ID分别是1和3。

Caller函数被调用，先执行CallerChild1代码，这里是同步执行与一般函数一样，然后遇到了异步函数CalleeAsync。

在CalleeAsync函数中有await关键字，await的作用是打分裂点。

编译器会把整个函数（CalleeAsync）从这里分裂成两个函数。await关键字之前的代码作为一个函数（按照我上面定义的指代，下文中就叫这部分代码CalleeChild1）await关键字之后的代码作为一个函数（CalleeChild2）。

CalleeChild1在调用方线程执行（在示例中就是主线程Thread1），执行到await关键字之后，另开一个线程耗时工作在Thread3中执行，然后立即返回。这时调用方会继续执行下面的代码CallerChild2（注意是Caller不是Callee）。

在CallerChild2被执行期间，TimeConsumingMethod也在异步执行（可能是在别的线程也可能是CPU不参与操作直接DMA的IO操作）。

当TimeConsumingMethod执行结束后，CalleeChild2也就具备了执行条件，而这个时候CallerChild2可能执行完了也可能没有，由于CallerChild2与CalleeChild2都会在Caller的线程执行，这里就会有冲突应该先执行谁，编译器会在合适的时候在Caller的线程执行这部分代码。示意图如下：

请注意，CalleeChild2在上图中并没有画任何箭头，因为这部分代码的执行是由编译器决定的，暂时无法具体描述是什么时候执行。

总结一下：

整个流程下来，除了TimeConsumingMethod函数是在Thread3中执行的，剩余代码都是在主线程Thread1中执行的.

也就是说异步方法运行在当前同步上下文中，只有激活的时候才占用当前线程的时间，异步模型采用时间片轮转来实现（这一点我没考证，仅作参考）。

你也许会说，明明新加了一个Thread3线程怎么能说是运行在当前的线程中呢？这里说的异步方法运行在当前线程上的意思是由CalleeAsync分裂出来的CalleeChild1和CalleeChild2的确是运行在Thread1上的。

带返回值的异步函数

之前的示例代码中异步函数是没有返回值的，作为理解原理足够了，但是在实际应用场景中，带返回值的应用才是最常用的。那么，上代码：

private void button1_Click(object sender, EventArgs e)
{
    Console.WriteLine("111 balabala. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
    var ResultTask  = AsyncMethod();
    Console.WriteLine(ResultTask.Result);
    Console.WriteLine("222 balabala. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
}

private async Task AsyncMethod()
{
    var ResultFromTimeConsumingMethod = TimeConsumingMethod();
    string Result = await ResultFromTimeConsumingMethod + " + AsyncMethod. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId;
    Console.WriteLine(Result);
    return Result;
}

//这个函数就是一个耗时函数，可能是IO操作，也可能是cpu密集型工作。
private Task TimeConsumingMethod()
{            
    var task = Task.Run(()=> {
        Console.WriteLine("Helo I am TimeConsumingMethod. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
        Thread.Sleep(5000);
        Console.WriteLine("Helo I am TimeConsumingMethod after Sleep(5000). My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
        return "Hello I am TimeConsumingMethod";
    });

    return task;
}

主要更改的地方在这里：

按理说没错吧？然而，这代码一旦执行就会卡死。

死锁

是的，死锁。分析一下为什么：

按照之前我划定的代码块指定，在添加了新代码后CallerChild2与CalleeChild2的划分如上图。

这两部分代码块都是在同一个线程上执行的，也就是主线程Thread1，而且通常情况下CallerChild2是会早于CalleeChild2执行的(毕竟CalleeChild2得在耗时代码块执行之后执行)。

Console.WriteLine(ResultTask.Result);(CallerChild2)其实是在请求CalleeChild2的执行结果，此时明显CalleeChild2还没有结束没有return任何结果，那Console.WriteLine(ResultTask.Result);就只能阻塞Thread1等待，直到CalleeChild2有结果。

然而问题就在这，CalleeChild2也是在Thread1上执行的，此时CallerChild2一直占用Thread1等待CalleeChild2的结果，耗时程序结束后轮到CalleeChild2执行的时候CalleeChild2又因Thread1被CallerChild2占用而抢不到线程，永远无法return，那么CallerChild2就会永远等下去，这就造成了死锁。

解决办法有两种一个是把Console.WriteLine(ResultTask.Result);放到一个新开线程中等待(个人觉得这方法有点麻烦，毕竟要新开线程)，还有一个方法是把Caller也做成异步方法：

ResultTask.Result变成了ResultTask 的原因上面也说了，await修饰的Task/Task得到的是TResult。

之所以这样就能解决问题是因为嵌套了两个异步方法，现在的Caller也成了一个异步方法，当Caller执行到await后直接返回了（await拆分方法成两部分），CalleeChild2执行之后才轮到Caller中await后面的代码块（Console.WriteLine(ResultTask.Result);）。

另外，把Caller做成异步的方法也解决了一开始的那个警告，还记得么？

这样没省多少事啊？

到现在，你可能会说：使用async/await不比直接用Task.Run()来的简单啊？比如我用Task的TaskContinueWith方法也能实现：

private void button1_Click(object sender, EventArgs e)
{
    var ResultTask = Task.Run(()=> {
        Console.WriteLine("Helo I am TimeConsumingMethod. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
        Thread.Sleep(5000);
        Console.WriteLine("Helo I am TimeConsumingMethod after Sleep(5000). My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
        return "Hello I am TimeConsumingMethod";
    });

    ResultTask.ContinueWith(OnDoSomthingIsComplete);

}

private void OnDoSomthingIsComplete(Task t)
{
    Action action = () => {
        textBox1.Text = t.Result;
    };
    textBox1.Invoke(action);
    Console.WriteLine("Continue Thread ID :" + Thread.CurrentThread.ManagedThreadId);
}

是的，上面的代码也能实现。但是，async/await的优雅的打开方式是这样的：

private async void button1_Click(object sender, EventArgs e)
{
    var t = Task.Run(() => {
        Thread.Sleep(5000);
        return "Hello I am TimeConsumingMethod";
    });
    textBox1.Text = await t;
}

看到没，惊不惊喜，意不意外，寥寥几行就搞定了，不用再多写那么多函数，使用起来也很灵活。最让人头疼的跨线程修改控件的问题完美解决了，再也不用使用Invoke了，因为修改控件的操作压根就是在原来的线程上做的，还能不阻塞UI。

参考：
死锁问题 https://www.cnblogs.com/OpenCoder/p/4434574.html
该博主是翻译的英文资料，英文原文：http://blog.stephencleary.com/2012/07/dont-block-on-async-code.html
https://www.cnblogs.com/zhili/archive/2013/05/15/Csharp5asyncandawait.html
http://www.cnblogs.com/heyuquan/archive/2013/04/26/3045827.html
https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/concepts/async/index

 https://stackoverflow.com/questions/9011831/new-thread-and-garbage-collection

new Thread(new ThreadStart(delegate()
{
    while (true)
    {
        //something
    }
})).Start();

CLR 会跟踪所有正在运行的线程。只要有对对象的引用，它们就不会被垃圾收集。并且由于 CLR 保留对所有正在运行的线程的引用，因此 GC 不会触及它们。

不; 正在运行的线程算作根。不会收集正在运行的线程，也不会收集该线程堆栈的活动部分引用的任何内容。

https://bytes.com/topic/c-sharp/answers/244706-threads-garbage-collection

https://docs.microsoft.com/zh-cn/dotnet/standard/garbage-collection/background-gc

c# – 在.NET 4.0中使用ConcurrentDictionary中的AddOrUpdate方法

我在Concurrent集合和线程中遇到麻烦,特别是在ConcurrentDictionary中使用AddOrUpdate方法基本上…..我无法使用它…我找不到任何好的例子…而且还没有完全理解,在MSDN编程指南中ConcurrentQueue的例子..

ConcurrentDictionary中的AddOrUpdate方法基本上…..
我无法投入使用..我找不到任何好的例子……
并且也无法完全理解,在MSDN编程指南中ConcurrentQueue的例子..

解决方法

在常规字典中,您可能会看到如下代码：

1. Dictionary<string,int> dictionary = GetDictionary();
2.  
3. if (dictionary.ContainsKey("MyKey"))
4. {
5. dictionary["MyKey"] += 5;
6. }
7. else
8. {
9. dictionary.Add("MyKey",5);
10. }

这不是线程安全的代码.有多种竞争条件：可以在调用ContainsKey之后添加/删除“MyKey”,并且可以使用=运算符在行中读取和赋值之间更改与“MyKey”关联的值(如果有).

AddOrUpdate方法旨在通过提供添加或更新与给定键关联的值的机制来解决这些线程问题,具体取决于键是否存在.它类似于TryGetValue,因为它结合了多个操作(在这种情况下,检查一个键,并根据所述键的存在插入或修改一个值)成为一个不受竞争条件影响的有效原子动作.

为了使这个具体化,以下是使用AddOrUpdate修复上述代码的方法：

1. ConcurrentDictionary<string,int> dictionary = GetDictionary();
2.  
3. // Either insert the key "MyKey" with the value 5 or,// if "MyKey" is already present,increase its value by 5.
4. dictionary.AddOrUpdate("MyKey",5,(s,i) => i + 5);

 

C# Task详解

1、Task的优势

　　ThreadPool相比Thread来说具备了很多优势，但是ThreadPool却又存在一些使用上的不方便。比如：
　　◆ ThreadPool不支持线程的取消、完成、失败通知等交互性操作；
　　◆ ThreadPool不支持线程执行的先后次序；
　　以往，如果开发者要实现上述功能，需要完成很多额外的工作，现在，FCL中提供了一个功能更强大的概念：Task。Task在线程池的基础上进行了优化，并提供了更多的API。在FCL4.0中，如果我们要编写多线程程序，Task显然已经优于传统的方式。
　　以下是一个简单的任务示例：

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            Task t = new Task(() =>
            {
                Console.WriteLine("任务开始工作……");
                //模拟工作过程
                Thread.Sleep(5000);
            });
            t.Start();
            t.ContinueWith((task) =>
            {
                Console.WriteLine("任务完成，完成时候的状态为：");
                Console.WriteLine("IsCanceled={0}\tIsCompleted={1}\tIsFaulted={2}", task.IsCanceled, task.IsCompleted, task.IsFaulted);
            });
            Console.ReadKey();
        }
    }
}

2、Task的用法

　　2.1、创建任务

　　（一）无返回值的方式
　　方式1:

　　var t1 = new Task(() => TaskMethod("Task 1"));
　　t1.Start();
　　Task.WaitAll(t1);//等待所有任务结束 
　　注:任务的状态:
　　Start之前为:Created
　　Start之后为:WaitingToRun 

　　方式2:

　　Task.Run(() => TaskMethod("Task 2"));

　　方式3:

　　Task.Factory.StartNew(() => TaskMethod("Task 3")); 直接异步的方法 
　　//或者
　　var t3=Task.Factory.StartNew(() => TaskMethod("Task 3"));
　　Task.WaitAll(t3);//等待所有任务结束
　　//任务的状态:
　　Start之前为:Running
　　Start之后为:Running

 

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            var t1 = new Task(() => TaskMethod("Task 1"));
            var t2 = new Task(() => TaskMethod("Task 2"));
            t2.Start();
            t1.Start();
            Task.WaitAll(t1, t2);
            Task.Run(() => TaskMethod("Task 3"));
            Task.Factory.StartNew(() => TaskMethod("Task 4"));
            //标记为长时间运行任务,则任务不会使用线程池,而在单独的线程中运行。
            Task.Factory.StartNew(() => TaskMethod("Task 5"), TaskCreationOptions.LongRunning);

            #region 常规的使用方式
            Console.WriteLine("主线程执行业务处理.");
            //创建任务
            Task task = new Task(() =>
            {
                Console.WriteLine("使用System.Threading.Tasks.Task执行异步操作.");
                for (int i = 0; i < 10; i++)
                {
                    Console.WriteLine(i);
                }
            });
            //启动任务,并安排到当前任务队列线程中执行任务(System.Threading.Tasks.TaskScheduler)
            task.Start();
            Console.WriteLine("主线程执行其他处理");
            task.Wait();
            #endregion

            Thread.Sleep(TimeSpan.FromSeconds(1));
            Console.ReadLine();
        }

        static void TaskMethod(string name)
        {
            Console.WriteLine("Task {0} is running on a thread id {1}. Is thread pool thread: {2}",
                name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
        }
    }
}

　　async/await的实现方式:

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        async static void AsyncFunction()
        {
            await Task.Delay(1);
            Console.WriteLine("使用System.Threading.Tasks.Task执行异步操作.");
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(string.Format("AsyncFunction:i={0}", i));
            }
        }

        public static void Main()
        {
            Console.WriteLine("主线程执行业务处理.");
            AsyncFunction();
            Console.WriteLine("主线程执行其他处理");
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(string.Format("Main:i={0}", i));
            }
            Console.ReadLine();
        }
    }
}

　　（二）带返回值的方式
　　方式4:

　　Task<int> task = CreateTask("Task 1");
　　task.Start(); 
　　int result = task.Result;

 

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static Task<int> CreateTask(string name)
        {
            return new Task<int>(() => TaskMethod(name));
        }

        static void Main(string[] args)
        {
            TaskMethod("Main Thread Task");
            Task<int> task = CreateTask("Task 1");
            task.Start();
            int result = task.Result;
            Console.WriteLine("Task 1 Result is: {0}", result);

            task = CreateTask("Task 2");
            //该任务会运行在主线程中
            task.RunSynchronously();
            result = task.Result;
            Console.WriteLine("Task 2 Result is: {0}", result);

            task = CreateTask("Task 3");
            Console.WriteLine(task.Status);
            task.Start();

            while (!task.IsCompleted)
            {
                Console.WriteLine(task.Status);
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
            }

            Console.WriteLine(task.Status);
            result = task.Result;
            Console.WriteLine("Task 3 Result is: {0}", result);

            #region 常规使用方式
            //创建任务
            Task<int> getsumtask = new Task<int>(() => Getsum());
            //启动任务,并安排到当前任务队列线程中执行任务(System.Threading.Tasks.TaskScheduler)
            getsumtask.Start();
            Console.WriteLine("主线程执行其他处理");
            //等待任务的完成执行过程。
            getsumtask.Wait();
            //获得任务的执行结果
            Console.WriteLine("任务执行结果：{0}", getsumtask.Result.ToString());
            #endregion
        }

        static int TaskMethod(string name)
        {
            Console.WriteLine("Task {0} is running on a thread id {1}. Is thread pool thread: {2}",
                name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
            Thread.Sleep(TimeSpan.FromSeconds(2));
            return 42;
        }

        static int Getsum()
        {
            int sum = 0;
            Console.WriteLine("使用Task执行异步操作.");
            for (int i = 0; i < 100; i++)
            {
                sum += i;
            }
            return sum;
        }
    }
}

    async/await的实现:

using System;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        public static void Main()
        {
            var ret1 = AsyncGetsum();
            Console.WriteLine("主线程执行其他处理");
            for (int i = 1; i <= 3; i++)
                Console.WriteLine("Call Main()");
            int result = ret1.Result;                  //阻塞主线程
            Console.WriteLine("任务执行结果：{0}", result);
        }

        async static Task<int> AsyncGetsum()
        {
            await Task.Delay(1);
            int sum = 0;
            Console.WriteLine("使用Task执行异步操作.");
            for (int i = 0; i < 100; i++)
            {
                sum += i;
            }
            return sum;
        }
    }
}

　　2.2、组合任务.ContinueWith

　　 简单Demo:

using System;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        public static void Main()
        {
            //创建一个任务
            Task<int> task = new Task<int>(() =>
            {
                int sum = 0;
                Console.WriteLine("使用Task执行异步操作.");
                for (int i = 0; i < 100; i++)
                {
                    sum += i;
                }
                return sum;
            });
            //启动任务,并安排到当前任务队列线程中执行任务(System.Threading.Tasks.TaskScheduler)
            task.Start();
            Console.WriteLine("主线程执行其他处理");
            //任务完成时执行处理。
            Task cwt = task.ContinueWith(t =>
            {
                Console.WriteLine("任务完成后的执行结果：{0}", t.Result.ToString());
            });
            task.Wait();
            cwt.Wait();
        }
    }
}

　　 任务的串行:

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            ConcurrentStack<int> stack = new ConcurrentStack<int>();

            //t1先串行
            var t1 = Task.Factory.StartNew(() =>
            {
                stack.Push(1);
                stack.Push(2);
            });

            //t2,t3并行执行
            var t2 = t1.ContinueWith(t =>
            {
                int result;
                stack.TryPop(out result);
                Console.WriteLine("Task t2 result={0},Thread id {1}", result, Thread.CurrentThread.ManagedThreadId);
            });

            //t2,t3并行执行
            var t3 = t1.ContinueWith(t =>
            {
                int result;
                stack.TryPop(out result);
                Console.WriteLine("Task t3 result={0},Thread id {1}", result, Thread.CurrentThread.ManagedThreadId);
            });

            //等待t2和t3执行完
            Task.WaitAll(t2, t3);

            //t7串行执行
            var t4 = Task.Factory.StartNew(() =>
            {
                Console.WriteLine("当前集合元素个数：{0},Thread id {1}", stack.Count, Thread.CurrentThread.ManagedThreadId);
            });
            t4.Wait();
        }
    }
}

　　子任务:

using System;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        public static void Main()
        {
            Task<string[]> parent = new Task<string[]>(state =>
            {
                Console.WriteLine(state);
                string[] result = new string[2];
                //创建并启动子任务
                new Task(() => { result[0] = "我是子任务1。"; }, TaskCreationOptions.AttachedToParent).Start();
                new Task(() => { result[1] = "我是子任务2。"; }, TaskCreationOptions.AttachedToParent).Start();
                return result;
            }, "我是父任务，并在我的处理过程中创建多个子任务，所有子任务完成以后我才会结束执行。");
            //任务处理完成后执行的操作
            parent.ContinueWith(t =>
            {
                Array.ForEach(t.Result, r => Console.WriteLine(r));
            });
            //启动父任务
            parent.Start();
            //等待任务结束 Wait只能等待父线程结束,没办法等到父线程的ContinueWith结束
            //parent.Wait();
            Console.ReadLine();

        }
    }
}

　　动态并行(TaskCreationOptions.AttachedToParent) 父任务等待所有子任务完成后 整个任务才算完成

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Node
    {
        public Node Left { get; set; }
        public Node Right { get; set; }
        public string Text { get; set; }
    }


    class Program
    {
        static Node GetNode()
        {
            Node root = new Node
            {
                Left = new Node
                {
                    Left = new Node
                    {
                        Text = "L-L"
                    },
                    Right = new Node
                    {
                        Text = "L-R"
                    },
                    Text = "L"
                },
                Right = new Node
                {
                    Left = new Node
                    {
                        Text = "R-L"
                    },
                    Right = new Node
                    {
                        Text = "R-R"
                    },
                    Text = "R"
                },
                Text = "Root"
            };
            return root;
        }

        static void Main(string[] args)
        {
            Node root = GetNode();
            DisplayTree(root);
        }

        static void DisplayTree(Node root)
        {
            var task = Task.Factory.StartNew(() => DisplayNode(root),
                                            CancellationToken.None,
                                            TaskCreationOptions.None,
                                            TaskScheduler.Default);
            task.Wait();
        }

        static void DisplayNode(Node current)
        {

            if (current.Left != null)
                Task.Factory.StartNew(() => DisplayNode(current.Left),
                                            CancellationToken.None,
                                            TaskCreationOptions.AttachedToParent,
                                            TaskScheduler.Default);
            if (current.Right != null)
                Task.Factory.StartNew(() => DisplayNode(current.Right),
                                            CancellationToken.None,
                                            TaskCreationOptions.AttachedToParent,
                                            TaskScheduler.Default);
            Console.WriteLine("当前节点的值为{0};处理的ThreadId={1}", current.Text, Thread.CurrentThread.ManagedThreadId);
        }
    }
}

　　2.3、取消任务 CancellationTokenSource

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        private static int TaskMethod(string name, int seconds, CancellationToken token)
        {
            Console.WriteLine("Task {0} is running on a thread id {1}. Is thread pool thread: {2}",
                name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
            for (int i = 0; i < seconds; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(1));
                if (token.IsCancellationRequested) return -1;
            }
            return 42 * seconds;
        }

        private static void Main(string[] args)
        {
            var cts = new CancellationTokenSource();
            var longTask = new Task<int>(() => TaskMethod("Task 1", 10, cts.Token), cts.Token);
            Console.WriteLine(longTask.Status);
            cts.Cancel();
            Console.WriteLine(longTask.Status);
            Console.WriteLine("First task has been cancelled before execution");
            cts = new CancellationTokenSource();
            longTask = new Task<int>(() => TaskMethod("Task 2", 10, cts.Token), cts.Token);
            longTask.Start();
            for (int i = 0; i < 5; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
                Console.WriteLine(longTask.Status);
            }
            cts.Cancel();
            for (int i = 0; i < 5; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
                Console.WriteLine(longTask.Status);
            }

            Console.WriteLine("A task has been completed with result {0}.", longTask.Result);
        }
    }
}

　　2.4、处理任务中的异常

　　单个任务:

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static int TaskMethod(string name, int seconds)
        {
            Console.WriteLine("Task {0} is running on a thread id {1}. Is thread pool thread: {2}",
                name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
            Thread.Sleep(TimeSpan.FromSeconds(seconds));
            throw new Exception("Boom!");
            return 42 * seconds;
        }

        static void Main(string[] args)
        {
            try
            {
                Task<int> task = Task.Run(() => TaskMethod("Task 2", 2));
                int result = task.GetAwaiter().GetResult();
                Console.WriteLine("Result: {0}", result);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Task 2 Exception caught: {0}", ex.Message);
            }
            Console.WriteLine("----------------------------------------------");
            Console.WriteLine();
        }
    }
}

　　多个任务:

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static int TaskMethod(string name, int seconds)
        {
            Console.WriteLine("Task {0} is running on a thread id {1}. Is thread pool thread: {2}",
                name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
            Thread.Sleep(TimeSpan.FromSeconds(seconds));
            throw new Exception(string.Format("Task {0} Boom!", name));
            return 42 * seconds;
        }


        public static void Main(string[] args)
        {
            try
            {
                var t1 = new Task<int>(() => TaskMethod("Task 3", 3));
                var t2 = new Task<int>(() => TaskMethod("Task 4", 2));
                var complexTask = Task.WhenAll(t1, t2);
                var exceptionHandler = complexTask.ContinueWith(t =>
                        Console.WriteLine("Result: {0}", t.Result),
                        TaskContinuationOptions.OnlyOnFaulted
                    );
                t1.Start();
                t2.Start();
                Task.WaitAll(t1, t2);
            }
            catch (AggregateException ex)
            {
                ex.Handle(exception =>
                {
                    Console.WriteLine(exception.Message);
                    return true;
                });
            }
        }
    }
}

    async/await的方式:

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static async Task ThrowNotImplementedExceptionAsync()
        {
            throw new NotImplementedException();
        }

        static async Task ThrowInvalidOperationExceptionAsync()
        {
            throw new InvalidOperationException();
        }

        static async Task Normal()
        {
            await Fun();
        }

        static Task Fun()
        {
            return Task.Run(() =>
            {
                for (int i = 1; i <= 10; i++)
                {
                    Console.WriteLine("i={0}", i);
                    Thread.Sleep(200);
                }
            });
        }

        static async Task ObserveOneExceptionAsync()
        {
            var task1 = ThrowNotImplementedExceptionAsync();
            var task2 = ThrowInvalidOperationExceptionAsync();
            var task3 = Normal();


            try
            {
                //异步的方式
                Task allTasks = Task.WhenAll(task1, task2, task3);
                await allTasks;
                //同步的方式
                //Task.WaitAll(task1, task2, task3);
            }
            catch (NotImplementedException ex)
            {
                Console.WriteLine("task1 任务报错!");
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine("task2 任务报错!");
            }
            catch (Exception ex)
            {
                Console.WriteLine("任务报错!");
            }

        }

        public static void Main()
        {
            Task task = ObserveOneExceptionAsync();
            Console.WriteLine("主线程继续运行........");
            task.Wait();
        }
    }
}

　　2.5、Task.FromResult的应用

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static IDictionary<string, string> cache = new Dictionary<string, string>()
        {
            {"0001","A"},
            {"0002","B"},
            {"0003","C"},
            {"0004","D"},
            {"0005","E"},
            {"0006","F"},
        };

        public static void Main()
        {
            Task<string> task = GetValueFromCache("0006");
            Console.WriteLine("主程序继续执行。。。。");
            string result = task.Result;
            Console.WriteLine("result={0}", result);

        }

        private static Task<string> GetValueFromCache(string key)
        {
            Console.WriteLine("GetValueFromCache开始执行。。。。");
            string result = string.Empty;
            //Task.Delay(5000);
            Thread.Sleep(5000);
            Console.WriteLine("GetValueFromCache继续执行。。。。");
            if (cache.TryGetValue(key, out result))
            {
                return Task.FromResult(result);
            }
            return Task.FromResult("");
        }

    }
}

　　2.6、使用IProgress实现异步编程的进程通知

　　IProgress<in T>只提供了一个方法void Report(T value)，通过Report方法把一个T类型的值报告给IProgress,然后IProgress<in T>的实现类Progress<in T>的构造函数接收类型为Action<T>的形参，通过这个委托让进度显示在UI界面中。

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void DoProcessing(IProgress<int> progress)
        {
            for (int i = 0; i <= 100; ++i)
            {
                Thread.Sleep(100);
                if (progress != null)
                {
                    progress.Report(i);
                }
            }
        }

        static async Task Display()
        {
            //当前线程
            var progress = new Progress<int>(percent =>
            {
                Console.Clear();
                Console.Write("{0}%", percent);
            });
            //线程池线程
            await Task.Run(() => DoProcessing(progress));
            Console.WriteLine("");
            Console.WriteLine("结束");
        }

        public static void Main()
        {
            Task task = Display();
            task.Wait();
        }
    }
}

　　2.7、Factory.FromAsync的应用 (简APM模式(委托)转换为任务)(BeginXXX和EndXXX)

　　带回调方式的

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        private delegate string AsynchronousTask(string threadName);

        private static string Test(string threadName)
        {
            Console.WriteLine("Starting...");
            Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
            Thread.Sleep(TimeSpan.FromSeconds(2));
            Thread.CurrentThread.Name = threadName;
            return string.Format("Thread name: {0}", Thread.CurrentThread.Name);
        }

        private static void Callback(IAsyncResult ar)
        {
            Console.WriteLine("Starting a callback...");
            Console.WriteLine("State passed to a callbak: {0}", ar.AsyncState);
            Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
            Console.WriteLine("Thread pool worker thread id: {0}", Thread.CurrentThread.ManagedThreadId);
        }

        //执行的流程是 先执行Test--->Callback--->task.ContinueWith
        static void Main(string[] args)
        {
            AsynchronousTask d = Test;
            Console.WriteLine("Option 1");
            Task<string> task = Task<string>.Factory.FromAsync(
                d.BeginInvoke("AsyncTaskThread", Callback, "a delegate asynchronous call"), d.EndInvoke);

            task.ContinueWith(t => Console.WriteLine("Callback is finished, now running a continuation! Result: {0}",
                t.Result));

            while (!task.IsCompleted)
            {
                Console.WriteLine(task.Status);
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
            }
            Console.WriteLine(task.Status);

        }
    }
}

　　不带回调方式的

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        private delegate string AsynchronousTask(string threadName);

        private static string Test(string threadName)
        {
            Console.WriteLine("Starting...");
            Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
            Thread.Sleep(TimeSpan.FromSeconds(2));
            Thread.CurrentThread.Name = threadName;
            return string.Format("Thread name: {0}", Thread.CurrentThread.Name);
        }

        //执行的流程是 先执行Test--->task.ContinueWith
        static void Main(string[] args)
        {
            AsynchronousTask d = Test;
            Task<string> task = Task<string>.Factory.FromAsync(
                d.BeginInvoke, d.EndInvoke, "AsyncTaskThread", "a delegate asynchronous call");
            task.ContinueWith(t => Console.WriteLine("Task is completed, now running a continuation! Result: {0}",
                t.Result));
            while (!task.IsCompleted)
            {
                Console.WriteLine(task.Status);
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
            }
            Console.WriteLine(task.Status);

        }
    }
}

---

//Task启动带参数和返回值的函数任务
//下面的例子test2 是个带参数和返回值的函数。

private int test2(object i)
{
    this.Invoke(new Action(() =>
    {
        pictureBox1.Visible = true;
    }));
    System.Threading.Thread.Sleep(3000);
    MessageBox.Show("hello:" + i);
    this.Invoke(new Action(() =>
    {
        pictureBox1.Visible = false;
    }));
    return 0;
}

//测试调用
private void call()
{
    //Func<string, string> funcOne = delegate(string s){ return "fff"; };
    object i = 55;
    var t = Task<int>.Factory.StartNew(new Func<object, int>(test2), i);
}

//= 下载网站源文件例子 == == == == == == == == == == == ==
//HttpClient 引用System.Net.Http
private async Task< int> test2(object i)
{
    this.Invoke(new Action(() =>
    {
        pictureBox1.Visible = true;
    }));

    HttpClient client = new HttpClient();
    var a = await client.GetAsync("http://www.baidu.com");
    Task<string> s = a.Content.ReadAsStringAsync();
    MessageBox.Show (s.Result);

    //System.Threading.Thread.Sleep(3000);
    //MessageBox.Show("hello:"+ i);
    this.Invoke(new Action(() =>
    {
        pictureBox1.Visible = false;
    }));
    return 0;
}

async private void call()
{
    //Func<string, string> funcOne = delegate(string s){ return "fff"; };
    object i = 55;
    var t = Task<Task<int>>.Factory.StartNew(new Func<object, Task<int>>(test2), i);
}

//----------或者----------

private async void test2()
{
    this.Invoke(new Action(() =>
    {
        pictureBox1.Visible = true;
    }));
    HttpClient client = new HttpClient();
    var a = await client.GetAsync("http://www.baidu.com");
    Task<string> s = a.Content.ReadAsStringAsync();
    MessageBox.Show (s.Result);
    this.Invoke(new Action(() =>
    {
        pictureBox1.Visible = false;
    }));
}

private void call()
{
    var t = Task.Run(new Action(test2));
    //相当于
    //Thread th= new Thread(new ThreadStart(test2));
    //th.Start();
}