协程Coroutine——”伪异步“

众所周知，Unity引擎是单线程的（也就是有一个主线程）。为了满足开发者的特定的“异步”、“多线程”的开发需求，Unity也提供了一个“伪异步”的解决思想——协程。
需要注意的是，协程不是线程，也不是异步执行的，本质上其实还是在生命周期的Update中执行的。
对于协程的原理和使用本文将不做介绍，本文的重点是在后面的内容。

使用协程的好处就在于：

• 大大减少了Update函数的臃肿
• 方便开发者对代码的阅读和维护

弊端：

• 运行效率没有变化
• 不能返回值，只能注入委托调用

线程Thread——“真异步”

多线程（Thread）是C#带来的特性。
在Unity中恰当的使用多线程会提高一定的程序效率，使用多线程的场景一般是涉及到数据的加载和逻辑处理，不如文件读写，网络通信等。
非常要注意的是：子线程内不可访问游戏对象或者组件以及相关的Unity API，如果需要与主线程沟通的话需要进行回调。

利用async 和 await简化多线程异步调用

为了简化异步使用的过程，C#提供了async和await关键字，以及最重要的工具——Task组件。运行的机制如图：

对于异步方法，提供了不带返回结果和带返回结果的Task类型，示例如下：

• 创建不带返回结果的异步任务Task 类

	/// <summary>
    /// 创建并执行异步操作任务，无返回值
    /// </summary>
    private async void AsyncFunction()
    {
        await Task.Run( () => {
            // Just loop.
            int ctr = 0;
            for (ctr = 0; ctr <= 10; ctr++)
            {
                Debug.Log("Example 1 is Looping:" + ctr);
            }
            Debug.Log("Finished Example1 loop iterations");
        } );
    }

• 创建带返回结果的异步任务Task 类

	/// <summary>
    /// 创建并执行异步操作任务，带返回值
    /// </summary>
    /// <returns></returns>
    private async Task<int> AsyncFunctionWithReturnResult()
    {
        return await Task.Run( () => {
            // Just loop.
            int ctr = 0;
            for (ctr = 0; ctr <= 20; ctr++)
            {
                Debug.Log("Example 2 is Looping:" + ctr);
            }
            return ctr;
        });
    }

• 执行异步任务：

	private async void Start()
    {
        Debug.Log("Start");
        // Example 1: 运行一个不带返回值类型的异步任务
        AsyncFunction();
        
        // Example 2: 运行一个带返回值的异步任务
        // 需要注意的是：使用await的话执行的函数体必须添加async关键字（看 -> private async void Start()）
        var task = await AsyncFunctionWithReturnResult();
        Debug.Log("Finished Example2 loop iterations and return result:" + task);
    }

其中对于asyn和await关键字的使用规则和含义有几点要说明：

• 两者的功能是有区别的，但是一般都是被搭配一起使用
• await 运算符通知编译器异步方法：在等待的异步过程完成后才能继续通过该点。 同时，控制返回至异步方法的调用方。
• async关键字仅用于修饰方法体，并且方法体中一定要有await关键字存在，否则它们将永不暂停！
  
• 对Task<TResult>类型前使用await关键字，代表对该Task进行异步等待返回结果，届时会被挂起直到异步操作完成
  

拓展阅读——等待一个或多个异步任务完成

对于特殊情况下，应用程序的逻辑可能要求调用线程在一个或多个任务完成执行时才继续执行。这种时候就可以通过调用 Wait 方法或者When方法等待一个或多个任务完成来同步调用线程的执行及其启动的异步任务。

同步等待的方法

• Task.Wait方法

定义：等待Task完成执行过程。
重载：

Wait(TimeSpan)	等待 Task 在指定的时间间隔内完成执行。
Wait(Int32, CancellationToken)	等待 Task 完成执行过程。 如果在任务完成之前超时间隔结束或取消标记已取消，等待将终止。
Wait(CancellationToken)	等待 Task 完成执行过程。 如果在任务完成之前取消标记已取消，等待将终止。
Wait()	等待 Task 完成执行过程。
Wait(Int32)	等待 Task 在指定的毫秒数内完成执行。

官方示例：

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

class Program
{
    static Random rand = new Random();

    static void Main()
    {
        // Wait on a single task with no timeout specified.
        Task taskA = Task.Run( () => Thread.Sleep(2000));
        Console.WriteLine("taskA Status: {0}", taskA.Status);
        try {
          taskA.Wait();
          Console.WriteLine("taskA Status: {0}", taskA.Status);
       } 
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
    }    
}
// The example displays output like the following:
//     taskA Status: WaitingToRun
//     taskA Status: RanToCompletion

• Task.WaitAll方法

定义：等待所有提供的Task对象完成执行过程
重载：

WaitAll(Task[])	等待提供的所有 Task 对象完成执行过程。
WaitAll(Task[], Int32)	等待所有提供的 Task 在指定的毫秒数内完成执行。
WaitAll(Task[], CancellationToken)	等待提供的所有 Task 对象完成执行过程（除非取消等待）。
WaitAll(Task[], TimeSpan)	等待所有提供的可取消 Task 对象在指定的时间间隔内完成执行。
WaitAll(Task[], Int32, CancellationToken)	等待提供的所有 Task 对象在指定的毫秒数内完成执行，或等到取消等待。

官方示例：

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

public class Example
{
   public static void Main()
   {
      // Wait for all tasks to complete.
      Task[] tasks = new Task[10];
      for (int i = 0; i < 10; i++)
      {
          tasks[i] = Task.Run(() => Thread.Sleep(2000));
      }
      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
         Console.WriteLine("One or more exceptions occurred: ");
         foreach (var ex in ae.Flatten().InnerExceptions)
            Console.WriteLine("   {0}", ex.Message);
      }   

      Console.WriteLine("Status of completed tasks:");
      foreach (var t in tasks)
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
   }
}
// The example displays the following output:
//     Status of completed tasks:
//        Task #2: RanToCompletion
//        Task #1: RanToCompletion
//        Task #3: RanToCompletion
//        Task #4: RanToCompletion
//        Task #6: RanToCompletion
//        Task #5: RanToCompletion
//        Task #7: RanToCompletion
//        Task #8: RanToCompletion
//        Task #9: RanToCompletion
//        Task #10: RanToCompletion

-Task.WaitAny方法

定义：等待提供的任一Task对象完成执行过程。
重载：

WaitAll(Task[])	等待提供的所有 Task 对象完成执行过程。
WaitAll(Task[], Int32)	等待所有提供的 Task 在指定的毫秒数内完成执行。
WaitAll(Task[], CancellationToken)	等待提供的所有 Task 对象完成执行过程（除非取消等待）。
WaitAll(Task[], TimeSpan)	等待所有提供的可取消 Task 对象在指定的时间间隔内完成执行。
WaitAll(Task[], Int32, CancellationToken)	等待提供的所有 Task 对象在指定的毫秒数内完成执行，或等到取消等待。

官方示例：

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

public class Example
{
   public static void Main()
   {
      var tasks = new Task[3];
      var rnd = new Random();
      for (int ctr = 0; ctr <= 2; ctr++)
         tasks[ctr] = Task.Run( () => Thread.Sleep(rnd.Next(500, 3000)));

      try {
         int index = Task.WaitAny(tasks);
         Console.WriteLine("Task #{0} completed first.\n", tasks[index].Id);
         Console.WriteLine("Status of all tasks:");
         foreach (var t in tasks)
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
      }
      catch (AggregateException) {
         Console.WriteLine("An exception occurred.");
      }
   }
}
// The example displays output like the following:
//     Task #1 completed first.
//     
//     Status of all tasks:
//        Task #3: Running
//        Task #1: RanToCompletion
//        Task #4: Running

异步等待的方法

• Task.WhenAll方法

定义：所有提供的任务已完成时，创建将完成的任务。
重载：

WhenAll(IEnumerable)	创建一个任务，该任务将在可枚举集合中的所有 Task 对象都已完成时完成。
WhenAll(Task[])	创建一个任务，该任务将在数组中的所有 Task 对象都已完成时完成。
WhenAll(IEnumerable<Task>)	创建一个任务，该任务将在可枚举集合中的所有 Task 对象都已完成时完成。
WhenAll(Task[])	创建一个任务，该任务将在数组中的所有 Task 对象都已完成时完成。

官方示例：

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

public class Example
{
   public static void Main()
   {
      var tasks = new Task<long>[10];
      for (int ctr = 1; ctr <= 10; ctr++) {
         int delayInterval = 18 * ctr;
         tasks[ctr - 1] = Task.Run(async () => { long total = 0;
                                                 await Task.Delay(delayInterval);
                                                 var rnd = new Random();
                                                 // Generate 1,000 random numbers.
                                                 for (int n = 1; n <= 1000; n++)
                                                    total += rnd.Next(0, 1000);

                                                 return total; } );
      }
      var continuation = Task.WhenAll(tasks);
      try {
         continuation.Wait();
      }
      catch (AggregateException)
      {}
   
      if (continuation.Status == TaskStatus.RanToCompletion) {
         long grandTotal = 0;
         foreach (var result in continuation.Result) {
            grandTotal += result;
            Console.WriteLine("Mean: {0:N2}, n = 1,000", result/1000.0);
         }
   
         Console.WriteLine("\nMean of Means: {0:N2}, n = 10,000",
                           grandTotal/10000);
      }
      // Display information on faulted tasks.
      else { 
         foreach (var t in tasks)
            Console.WriteLine("Task {0}: {1}", t.Id, t.Status);
      }
   }
}
// The example displays output like the following:
//       Mean: 506.38, n = 1,000
//       Mean: 501.01, n = 1,000
//       Mean: 505.36, n = 1,000
//       Mean: 492.00, n = 1,000
//       Mean: 508.36, n = 1,000
//       Mean: 503.99, n = 1,000
//       Mean: 504.95, n = 1,000
//       Mean: 508.58, n = 1,000
//       Mean: 490.23, n = 1,000
//       Mean: 501.59, n = 1,000
//
//       Mean of Means: 502.00, n = 10,000

• Task.WhenAny方法

定义：任何提供的任务已完成时，创建将完成的任务。
重载：

WhenAny(IEnumerable)	任何提供的任务已完成时，创建将完成的任务。
WhenAny(Task[])	任何提供的任务已完成时，创建将完成的任务。
WhenAny(Task, Task)	提供的任一任务完成时，创建将完成的任务。
WhenAny(Task[])	任何提供的任务已完成时，创建将完成的任务。
WhenAny(IEnumerable<Task>)	任何提供的任务已完成时，创建将完成的任务。
WhenAny(Task, Task)	提供的任一任务完成时，创建将完成的任务。

使用等待方法的注意点

在使用等待任务方法中，为了程序的正常执行，应当将等待的部分放在try/catch中处理，尤其是等待多个任务结束。因为很有可能出现的情况是，多个任务中的个别任务引发异常，如果没有异常处理就会一直处于等待的状态。

思考：await关键字和When方法以及Wait方法的区别

• 功能效果一样
• 本质(内核)不一样，await和when做的是非阻塞式等待(异步等待)，wait是阻塞式等待(同步等待)

什么是同步阻塞和异步阻塞呢，通俗一点的解释就是：
同步阻塞：有一天你饿了，想吃饭，但是你不会做，这时候你就跟你妈说：妈，我饿了，我要吃饭。然后你妈就去厨房做饭，你就在外面等着饭做好，啥也不干，这就是同步阻塞。（调用方阻塞不能干其他的事）
异步阻塞：同样，有一天你饿了，想吃饭，但是你不会做，这时候你就跟你妈说：妈，我饿了，我要吃饭。然后你妈就去厨房做饭，然后你就去看电视了。你妈做好饭就给你说，宝，饭做好了，去厨房把饭端到餐桌上。（调用方啥也不管，等好了自己去拿结果）

也就是说await和When都不会阻塞当前的线程，当主调用函数执行到await/when时，Task还没完成的话，编译器会把未执行的语句生成委托，直到任务完成，会回到这里接着执行await的委托内容。而Wait方法的话，当主调用函数执行到Wait时，该主线程就会等Task执行完毕，才会往下跑

总结

在Unity的生命周期中若需要实现在不同的步骤执行不同的内容或者定时操作某些步骤，应当考虑使用协程的方式进行伪异步操作，这样即简化Update的臃肿又使得代码更好地维护，而且对于程序来说这样的开销并不大，也不需要考虑同步和锁的问题。

而对于想要实现与Unity没有关联的高耗时高开销操作的同时又不希望造成主线程卡顿，比如加载大量资源、数据处理、网络请求等，这种情况使用线程开启异步操作更加适合。这样可以帮主线程分担一部分压力使得程序效率更高，不过注意的是我们也不能滥用线程，过多的将开启线程会造成CPU运算下降。

采用非阻止方式编写等待任务的代码

通过阻止当前线程来等待 Task 完成的方法可能导致死锁和已阻止的上下文线程，且可能需要更复杂的错误处理方法。 下表提供了关于如何以非阻止方式处理等待任务的指南

参考文献

1. Unity中的异步机制初探
2. 使用 Async 和 Await 的异步编程