C#之异步编程 - 技术栈

在计算机中，一个线程就是一系列的命令，一个工作单元。操作系统可以管理多个线程，给每个线程分配cpu执行的时间片，然后切换不同的线程在这个cpu上执行。这种单核的处理器一次只能做一件事，不能同时做两件以上的事情，只是通过时间的分配来实现多个线程的执行。但是在多核处理器上，可以实现同时执行多个线程。操作系统可以将时间分配给第一个处理器上的线程，然后在另一个处理器上分配时间给另一个线程。

异步是相对于同步而言。跟多线程不能同一而论。

异步编程采用future或callback机制，以避免产生不必要的线程。（一个future代表一个将要完成的工作。）异步编程核心就是：启动了的操作将在一段时间后完成。这个操作正在执行时，不会阻塞原来的线程。启动了这个操作的线程，可以继续执行其他任务。当操作完成时，会通知它的future或者回调函数，以便让程序知道操作已经结束。

为什么要使用异步：

面向终端用户的GUI程序：异步编程提高了相应能力。可以使程序在执行任务时仍能相应用户的输入。

服务器端应用：实现了可扩展性。服务器应用可以利用线程池满足其可扩展性。

1、什么是异步？

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

2、异步和同步的区别

如果以同步方式执行某个任务时，需要等待该任务完成，然后才能再继续执行另一个任务。而用异步执行某个任务时，可以在该任务完成之前执行另一个任务。**异步最重要的体现就是不排队，不阻塞**。

图：单线程同步

图：多线程同步

3、异步跟多线程

异步可以在单个线程上实现，也可以在多个线程上实现，还可以不需要线程（一些IO操作）。

图：单线程异步

图：多线程异步

4、异步应用

.NET Framework 的许多方面都支持异步编程功能，这些方面包括：

1）文件 IO、流 IO、套接字 IO。

2）网络。

3）远程处理信道（HTTP、TCP）和代理。

4）使用 ASP.NET 创建的 XML Web services。

5）ASP.NET Web 窗体。

6）使用 MessageQueue 类的消息队列。

.NET Framework 为异步操作提供两种设计模式：

1）使用 IAsyncResult 对象的异步操作。

2）使用事件的异步操作。

IAsyncResult 设计模式允许多种编程模型，但更加复杂不易学习，可提供大多数应用程序都不要求的灵活性。可能的话，类库设计者应使用事件驱动模型实现异步方法。在某些情况下，库设计者还应实现基于 IAsyncResult 的模型。

使用 IAsyncResult 设计模式的异步操作是通过名为 Begin操作名称和End操作名称的两个方法来实现的，这两个方法分别开始和结束异步操作操作名称。例如，FileStream 类提供 BeginRead 和 EndRead 方法来从文件异步读取字节。这两个方法实现了 Read 方法的异步版本。在调用 Begin操作名称后，应用程序可以继续在调用线程上执行指令，同时异步操作在另一个线程上执行。每次调用 Begin操作名称时，应用程序还应调用 End操作名称来获取操作的结果。Begin操作名称方法开始异步操作操作名称并返回一个实现 IAsyncResult 接口的对象。 .NET Framework 允许您异步调用任何方法。定义与您需要调用的方法具有相同签名的委托；公共语言运行库将自动为该委托定义具有适当签名的 BeginInvoke 和 EndInvoke 方法。

IAsyncResult 对象存储有关异步操作的信息。下表提供了有关异步操作的信息。

名称	说明
AsyncState	获取用户定义的对象，它限定或包含关于异步操作的信息。
AsyncWaitHandle	获取用于等待异步操作完成的 WaitHandle。
CompletedSynchronously	获取一个值，该值指示异步操作是否同步完成。
IsCompleted	获取一个值，该值指示异步操作是否已完

5、应用实例

案例1-读取文件

通常读取文件是一个比较耗时的工作，特别是读取大文件的时候，常见的上传和下载。但是我们又不想让用户一直等待，用户同样可以进行其他操作，可以使得系统有良好的交互性。这里我们写了同步调用和异步调用来进行比较说明。

cs 复制代码

using System;
using System.IO;
using System.Threading;

namespace AsynSample
{
    class FileReader
    {
        /// <summary>
        /// 缓存池
        /// </summary>
        private byte[] Buffer { get; set; }
        /// <summary>
        /// 缓存区大小
        /// </summary>
        public int BufferSize { get; set; }

        public FileReader(int bufferSize)
        {
            this.BufferSize = bufferSize;
            this.Buffer = new byte[BufferSize];
        }

        /// <summary>
        /// 同步读取文件
        /// </summary>
        /// <param name="path">文件路径</param>
        public void SynsReadFile(string path)
        {
            Console.WriteLine("同步读取文件 begin");
            using (FileStream fs = new FileStream(path, FileMode.Open))
            {                
                fs.Read(Buffer, 0, BufferSize);
                string output = System.Text.Encoding.UTF8.GetString(Buffer);
                Console.WriteLine("读取的文件信息：{0}",output);
            }
           
            Console.WriteLine("同步读取文件 end");
        }
        /// <summary>
        /// 异步读取文件
        /// </summary>
        /// <param name="path"></param>
        public void AsynReadFile(string path)
        {
            Console.WriteLine("异步读取文件 begin");
            //执行Endread时报错，fs已经释放，注意在异步中不能使用释放需要的资源
            //using (FileStream fs = new FileStream(path, FileMode.Open))
            //{
            //    Buffer = new byte[BufferSize];
            //    fs.BeginRead(Buffer, 0, BufferSize, AsyncReadCallback, fs);
            //} 
            if (File.Exists(path))
            {
                FileStream fs = new FileStream(path, FileMode.Open);
                fs.BeginRead(Buffer, 0, BufferSize, AsyncReadCallback, fs);
            }
            else
            {
                Console.WriteLine("该文件不存在");
            }

        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="ar"></param>
        void AsyncReadCallback(IAsyncResult ar)
        {
            FileStream stream = ar.AsyncState as FileStream;
            if (stream != null)
            {
                Thread.Sleep(1000);
                //读取结束
                stream.EndRead(ar);
                stream.Close();

                string output = System.Text.Encoding.UTF8.GetString(this.Buffer);
                Console.WriteLine("读取的文件信息：{0}", output);
            }
        }
    }
}

测试代码

cs 复制代码

using System;
using System.Threading;

namespace AsynSample
{
    class Program
    {
        static void Main(string[] args)
        {
            FileReader reader = new FileReader(1024);

            //改为自己的文件路径
            string path = "C:\\Windows\\DAI.log";

            Console.WriteLine("开始读取文件了...");
            //reader.SynsReadFile(path);

            reader.AsynReadFile(path);

            Console.WriteLine("我这里还有一大滩事呢.");
            DoSomething();
            Console.WriteLine("终于完事了，输入任意键，歇着！");
            Console.ReadKey();           
        }
        /// <summary>
        /// 
        /// </summary>
        static void DoSomething()
        {
            Thread.Sleep(1000);
            for (int i = 0; i < 10000; i++)
            {
                if (i % 888 == 0)
                {
                    Console.WriteLine("888的倍数：{0}",i);
                }
            }
        }
    }
}

同步输出：

异步输出：

结果分析：

如果是同步读取，在读取时，当前线程读取文件，只能等到读取完毕，才能执行以下的操作

而异步读取，是创建了新的线程，读取文件，而主线程，继续执行。我们可以开启任务管理器来进行监视。

案例二--基于委托的异步操作

系统自带一些类具有异步调用方式，如何使得自定义对象也具有异步功能呢？

我们可以借助委托来轻松实现异步。

说到BeginInvoke，EndInvoke就不得不停下来看一下委托的本质。为了便于理解委托，我定义一个简单的委托：

cs 复制代码

public delegate string MyFunc(int num, DateTime dt);

我们再来看一下这个委托在编译后的程序集中是个什么样的：

委托被编译成一个新的类型，拥有BeginInvoke，EndInvoke，Invoke这三个方法。前二个方法的组合使用便可实现异步调用。第三个方法将以同步的方式调用。其中BeginInvoke方法的最后二个参数用于回调，其它参数则与委托的包装方法的输入参数是匹配的。 EndInvoke的返回值与委托的包装方法的返回值匹配。

异步实现文件下载：

cs 复制代码

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(3000);
            Random rand = new Random();
            StringBuilder builder =new StringBuilder();
            int num;
            for(int i=0;i<100;i++)
            {
                num = rand.Next(1000);
                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("下载数据为空!");
            }
        }
    }
}

通过案例，我们发现，使用委托能够很轻易的实现异步。这样，我们就可以自定义自己的异步操作了。

Task模式的异步

Task是在Framework4.0提出来的新概念。Task本身就表示一个异步操作（*Task默认是运行在线程池里的线程上*）。它比线程更轻量，可以更高效的利用线程。并且任务提供了更多的控制操作。

实现了控制任务执行顺序
实现父子任务
实现了任务的取消操作
实现了进度报告
实现了返回值
实现了随时查看任务状态

任务的执行默认是由任务调度器来实现的(*任务调用器使这些任务并行执行*)。任务的执行和线程不是一一对应的。有可能会是几个任务在同一个线程上运行，充分利用了线程，避免一些短时间的操作单独跑在一个线程里。所以任务更适合CPU密集型操作。

[Task 启动](#Task 启动)

任务可以赋值立即运行，也可以先由构造函数赋值，之后再调用。

cs 复制代码

//启用线程池中的线程异步执行
 Task t1 = Task.Factory.StartNew(() =>
            {
                Console.WriteLine("Task启动...");
            });
//启用线程池中的线程异步执行
 Task t2 = Task.Run(() =>
            {
                Console.WriteLine("Task启动...");
            });

 Task t3 = new Task(() =>
            {
                Console.WriteLine("Task启动...");
            });
 t3.Start();//启用线程池中的线程异步执行
 t3.RunSynchronously();//任务同步执行

[Task 等待任务结果，处理结果](#Task 等待任务结果，处理结果)

cs 复制代码

 Task t1 = Task.Run(() =>
            {
                Console.WriteLine("Task启动...");
            });
 Task t2 = Task.Run(() =>
            {
                Console.WriteLine("Task启动...");
            });

 //调用WaitAll() ，会阻塞调用线程，等待任务执行完成 ,这时异步也没有意义了          
 Task.WaitAll(new Task[] { t1, t2 });
 Console.WriteLine("Task完成...");

 //调用ContinueWith，等待任务完成，触发下一个任务，这个任务可当作任务完成时触发的回调函数。
 //为了获取结果，同时不阻塞调用线程，建议使用ContinueWith，在任务完成后，接着执行一个处理结果的任务。
t1.ContinueWith((t) =>
{
    Console.WriteLine("Task完成...");
});
t2.ContinueWith((t) =>
{
    Console.WriteLine("Task完成...");
});

//调用GetAwaiter()方法，获取任务的等待者，调用OnCompleted事件，当任务完成时触发
//调用OnCompleted事件也不会阻塞线程
t1.GetAwaiter().OnCompleted(() =>
{
    Console.WriteLine("Task完成...");
});
t2.GetAwaiter().OnCompleted(() =>
{
    Console.WriteLine("Task完成...");
});

[Task 任务取消](#Task 任务取消)

cs 复制代码

//实例化一个取消实例
var source = new CancellationTokenSource();
var token = source.Token;

Task t1 = Task.Run(() =>
{
    Thread.Sleep(2000);
    //判断是否任务取消
    if (token.IsCancellationRequested)
    {
        //token.ThrowIfCancellationRequested();
        Console.WriteLine("任务已取消");
    }
    Thread.Sleep(500);
    //token传递给任务
}, token);

Thread.Sleep(1000);
Console.WriteLine(t1.Status);
//取消该任务
source.Cancel();
Console.WriteLine(t1.Status);

[Task 返回值](#Task 返回值)

cs 复制代码

Task<string> t1 = Task.Run(() => TaskMethod("hello"));
t1.Wait();
Console.WriteLine(t1.Result);

public string TaskMethod(string str)
{
    return str + " from task method";
}

Task异步操作，需要注意的一点就是调用Waitxxx方法，会阻塞调用线程。

[async await 异步](#async await 异步)

首先要明确一点的就是async await 不会创建线程。并且他们是一对关键字，必须成对的出现。

如果await的表达式没有创建新的线程，那么一个异步操作就是在调用线程的时间片上执行，否则就是在另一个线程上执行。

cs 复制代码

async Task MethodAsync()
{
    Console.WriteLine("异步执行");
    await Task.Delay(4000); 
    Console.WriteLine("异步执行结束");
}

一个异步方法必须有async修饰，且方法名以Async结尾。异步方法体至少包含一个await表达式。await 可以看作是一个挂起异步方法的一个点，且同时把控制权返回给调用者。异步方法的返回值必须是Task或者Task 。即如果方法没有返回值那就用Task表示，如果有一个string类型的返回值，就用Task泛型Task 修饰。

异步方法执行流程：

主线程调用MethodAsync方法，并等待方法执行结束
异步方法开始执行，输出"异步执行"
异步方法执行到await关键字，此时MethodAsync方法挂起，等待await表达式执行完毕，同时将控制权返回给调用方主线程，主线程继续执行。
执行Task.Delay方法，同时主线程继续执行之后的方法。
Task.Delay结束，await表达式结束，MehtodAsync执行await表达式之后的语句，输出"异步执行结束"。

和其他方法一样，async方法开始时以同步方式执行。在async内部，await关键字对它的参数执行一个异步等待。它首先检查操作是否已经完成，如果完成了，就继续运行（同步方式）。否则它会暂停async方法，并返回，留下一个未完成的Task。一段时间后，操作完成，async方法就恢复运行。

一个async方法是由多个同步执行的程序块组成的，每个同步程序块之间由await语句分隔。第一个同步程序块是在调用这个方法的线程中执行，但其他同步程序块在哪里运行呢？情况比较复杂。

最常见的情况是用await语句等待一个任务完成，当该方法在await处暂停时，就可以捕获上下文（context）。如果当前SynchronizationContext不为空，这个上下文就是当前SynchronizationContext。如果为空，则这个上下文为当前TaskScheduler。该方法会在这个上下文中继续运行。一般来说，运行在UI线程时采用UI上下文，处理Asp.Net请求时采用Asp.Net请求上下文，其他很多情况下则采用线程池上下文。

因为，在上面的代码中，每个同步程序块会试图在原始的上下文中恢复运行。如果在UI线程调用async方法，该方法的每个同步程序块都将在此UI线程上运行。但是，如果在线程池中调用，每个同步程序块将在线程池上运行。

如果要避免这种行为，可以在await中使用configureAwait方法，将参数ContinueOnCapturedContext设置为false。async方法中await之前的代码会在调用的线程里运行。在被await暂停后，await之后的代码则会在线程池里继续运行。

cs 复制代码

async Task MethodAsync()
{
    Console.WriteLine("异步执行");//同步程序块1
    await Task.Delay(4000).ConfigureAwait(false); 
    Console.WriteLine("异步执行结束");//同步程序块2
}

我们可能想当然的认为Task.Delay会阻塞执行线程，就跟Thread.Sleep一样。其实他们是不一样的。Task.Delay创建一个将在设置时间后执行的任务。就相当于一个定时器，多少时间后再执行操作。不会阻塞执行线程。

当我们在异步线程中调用Sleep的时候，只会阻塞异步线程。不会阻塞到主线程。

cs 复制代码

async Task Method2Async()
{
    Console.WriteLine("await执行前..."+Thread.CurrentThread.ManagedThreadId);
    await Task.Run(() =>
    {
        Console.WriteLine("await执行..." + Thread.CurrentThread.ManagedThreadId);
        Thread.Sleep(5000);
        Console.WriteLine("await执行结束..." + Thread.CurrentThread.ManagedThreadId);
        
    });
    Console.WriteLine("await之后执行..."+ Thread.CurrentThread.ManagedThreadId);
}

//输出：
//await执行前...9
//await执行...12
//await之后执行...9
//await执行结束...12

上面的异步方法，Task创建了一个线程池线程，Thread.Sleep执行在线程池线程中。

异步案例

C#并行库Parallel类介绍

Parallel类是对线程的一个抽象。该类位于System.Threading.Tasks名称空间中，提供了数据和任务并行性。

Paraller类定义了数据并行地For和ForEach的静态方法，以及任务并行的Invoke的静态方法。Parallel.For()和Parallel.ForEach()方法在每次迭代中调用相同的代码，Paraller.Invoke()允许调用不同的方法。

1.Parallel.For

Parallel.For()方法类似C#语法的for循环语句，多次执行一个任务。但该方法并行运行迭代，迭代的顺序没有定义。

Parallel.For()方法中，前两个参数定义了循环的开头和结束，第三个参数是一个Action委托。Parallel.For方法返回类型是ParallelLoopResult结构，它提供了循环是否结束的信息。

Parallel.For有多个重载版本和多个泛型重载版本。

示例：

cs 复制代码

static void ForTest() 
{ 
    ParallelLoopResult plr = Parallel.For(0, 10, i => 
                                          {
                                              Console.WriteLine("{0},task:{1},thread:{2}", i, Task.CurrentId, Thread.CurrentThread.ManagedThreadId); 
                                              Thread.Sleep(5000); 
                                          }); 
    if (plr.IsCompleted)
    {
        Console.WriteLine("completed!");
    }  
}

输出：

任务不一定映射到一个线程上。线程也可以被不同的任务重用。

上面的例子，使用了.NET 4.5中新增的Thread.Sleep方法，而不是Task.Delay方法。Task.Delay是一个异步方法，用于释放线程供其它任务使用。

示例：

cs 复制代码

static void ForTestDelay() {
    ParallelLoopResult plr = Parallel.For(0, 10, async i = >{
        Console.WriteLine("{0},task:{1},thread:{2}", i, Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        await Task.Delay(1000);
        Console.WriteLine("{0},task:{1},thread:{2}", i, Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
    });
    if (plr.IsCompleted) Console.WriteLine("completed!");
    Console.ReadKey();
}

输出：

上面代码使用了await关键字进行延迟，输出结果显示延迟前后的代码运行在不同的线程中。而且延迟后的任务不再存在，只留下线程，这里还重用了前面的线程。另一个重要的方面是，Parallel类的For方法并没有等待延迟，而是直接完成。parallel类只等待它创建的任务，而不等待其它后台活动。所以上面代码使用了Console.ReadKey();使主线程一直运行，不然很可能看不到后面的输出。

2.提前停止Parallel.For

For()方法的一个重载版本接受第三个Action<int,ParallelLoopState>委托类型的参数。使用这个方法可以调用ParallelLoopState的Break()或Stop()方法，以停止循环。

注意，前面说到，迭代的顺序是没有定义的。

示例：

cs 复制代码

static void ForStop() {
    ParallelLoopResult plr = Parallel.For(0, 10, (int i, ParallelLoopState pls) =>{
                Console.WriteLine("{0},task:{1},thread:{2}", i, Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
                if (i > 5) pls.Break();
            });
            Console.WriteLine("is completed:{0}", plr.IsCompleted);
            Console.WriteLine("最低停止索引:{0}", plr.LowestBreakIteration);
}

输出：

迭代值在大于5时中断，但其它已开始的任务同时执行。

3.对Parallel.For中的每个线程初始化

Parallel.For方法使用多个线程来执行循环，如果需要对每个线程进行初始化，就可以使用Parallel.For ()方法。除了from和to对应的值之外，Parallel.For方法的泛型版本还接受3个委托参数：

第一个委托参数的类型是Func ，这个方法仅对用于执行迭代的每个线程调用每一次。

第二个委托参数为循环体定义了委托。该参数类型是Func<int, ParallelLoopState, TLocal, TLocal>。其中第一个参数是循环迭代，第二个参数ParallelLoopState允许停止循环，第三个参数接受从上面参数委托Func 返回的值，该委托还需返回一个TLocal类型的值。该方法对每次迭代调用。

第三个委托参数指定一个委托Action ，接受第二个委托参数的返回值。这个方法仅对用于执行迭代的每个线程调用每一次。

示例：

cs 复制代码

static void ForInit() {
    ParallelLoopResult plr = Parallel.For(0, 10, () = >{
        Console.WriteLine("init thread:{0},task:{1}", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);
        return Thread.CurrentThread.ManagedThreadId.ToString();
    },
    (i, pls, strInit) = >{
        Console.WriteLine("body:{0},strInit:{1},thraed:{2},task:{3}", i, strInit, Thread.CurrentThread.ManagedThreadId, Task.CurrentId);
        return i.ToString();
    },
    (strI) = >{
        Console.WriteLine("finally {0}", strI);
    });
}

输出：

4.Parallel.ForEach

Parallel.ForEach方法遍历实现了IEnumerable的集合，类似于foreach，但以异步方式遍历。没有确定遍历顺序。

示例：

cs 复制代码

static void ForeachTest() {
    string[] data = {
        "zero",
        "one",
        "two",
        "three",
        "four",
        "five",
        "six",
        "seven",
        "eight",
        "nine",
        "ten",
        "eleven",
        "twelve"
    };
    ParallelLoopResult plr = Parallel.ForEach < string > (data, s = >{
        Console.WriteLine(s);
    });
    if (plr.IsCompleted) Console.WriteLine("completed!");
}

如果需要中断，可以使用ForEach的重载版本和参数ParallelLoopState。

访问索引器：

cs 复制代码

ParallelLoopResult plr1 = Parallel.ForEach < string > (data, (s, pls, l) = >{
    Console.WriteLine("data:{0},index:{1}", s, l);
});

5.Parallel.Invoke

如果多个任务并行运行，可以使用Parallel.Invoke方法。该方法允许传递一个Action委托数组。

cs 复制代码

static void ParallerInvoke() {
    Action[] funs = {
        Fun1,
        Fun2
    };
    Parallel.Invoke(funs);
}
static void Fun1() {
    Console.WriteLine("f1");
    Console.WriteLine("task:{0},thread:{1}", Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
}
static void Fun2() {
    Console.WriteLine("f2");
    Console.WriteLine("task:{0},thread:{1}", Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
}