Unity C# 之 Task、async和 await 、Thread 基础使用的Task的简单整理

Unity C# 之 Task、async和 await 、Thread 基础使用的Task的简单整理

目录

Unity C# 之 Task、async和 await 、Thread 基础使用的Task的简单整理

一、Task、async和 await 、Thread 基础概念

1、线程，多线程

2、Task

 3、async （await ）

二、Task 的基础使用，Task 的创建 和 启动

1、创建并运行一个Task

2、创建有返回值的 Task

3、Task提供了 task.RunSynchronously()用于同步执行Task任务

三、Task的阻塞方法（Wait/WaitAll/WaitAny）

1、Thread 阻塞主线程方法 ： thread.Join()方法

2、Task提供了 Wait/WaitAny/WaitAll 方法，可以更方便地控制线程阻塞

四、Task的延续操作（WhenAny/WhenAll/ContinueWith）

1、Task 的延续操作（WhenAny/WhenAll/ContinueWith）

 2、Task.Factory 的延续操作（WhenAny/WhenAll/ContinueWith）

五、Task 的任务取消(CancellationTokenSource)

1、Thread 的任务取消

 2、Task 的任务取消

3、 CancellationTokenSource  中 source.Token.Register 和 source.CancelAfter(XXXXms)

 五、异步方法(async/await)

六、Task、async和 await 、Thread 简单小结

一、Task、async和 await 、Thread 基础概念

1、线程，多线程

线程（Thread）是进程中的基本执行单元，是操作系统分配CPU时间的基本单位，一个进程可以包含若干个线程，在进程入口执行的第一个线程被视为这个进程的主线程。

在.NET应用程序中，都是以Main()方法作为入口的，当调用此方法时系统就会自动创建一个主线程。线程主要是由CPU寄存器、调用栈和线程本地存储器（Thread Local Storage，TLS）组成的。

CPU寄存器主要记录当前所执行线程的状态，调用栈主要用于维护线程所调用到的内存与数据，TLS主要用于存放线程的状态信息。

多线程：可以同时完成多个任务；可以使程序的响应速度更快；可以让占用大量处理时间的任务或当前没有进行处理的任务定期将处理时间让给别的任务；可以随时停止任务；可以设置每个任务的优先级以优化程序性能。

class Program
    {
        static void Main(string[] args)
        {
            //创建无参的线程
            Thread thread1 = new Thread(new ThreadStart(Thread1));
            //调用Start方法执行线程
            thread1.Start();

            Console.ReadKey();
        }

        /// <summary>
        /// 创建无参的方法
        /// </summary>
        static void Thread1()
        {
            Console.WriteLine("这是无参的方法");
        }
    }

2、Task

Task 是在ThreadPool的基础上推出的，我们简单了解下ThreadPool。

• ThreadPool中有若干数量的线程，如果有任务需要处理时，会从线程池中获取一个空闲的线程来执行任务，任务执行完毕后线程不会销毁，而是被线程池回收以供后续任务使用。
• 当线程池中所有的线程都在忙碌时，又有新任务要处理时，线程池才会新建一个线程来处理该任务
• 如果线程数量达到设置的最大值，任务会排队，等待其他任务释放线程后再执行。
• 线程池能减少线程的创建，节省开销，如下看一个ThreadPool的使用

 static void Main(string[] args)
 {
       for (int i = 1; i <=10; i++)
       {
                //ThreadPool执行任务
                ThreadPool.QueueUserWorkItem(new WaitCallback((obj) => {
                    Console.WriteLine($"第{obj}个执行任务");
                }),i);
       }
     Console.ReadKey();
}

上边的代码通过ThreadPool执行了10个任务，执行结果为

 3、async （await ）

async  异步主要用于修饰方法。

当一个方法被调用时，调用者需要等待该方法执行完毕并返回才能继续执行，我们称这个方法是同步方法；

当一个方法被调用时，立即返回，并获取一个线程执行该方法内部的业务，调用者不用等待该方法执行完毕，我们称这个方法为异步方法。

异步的好处在于非阻塞(调用线程不会暂停执行去等待子线程完成)，因此我们把一些不需要立即使用结果、较耗时的任务设为异步执行，可以提高程序的运行效率。

C# 中的 async 和 await 关键字，异步编程非常流行。

1）当我们在处理 UI 时，在点击按钮时，我们使用了一个长时间运行的方法，比如读取一个大文件或其他需要很长时间的东西

2）在这种情况下，整个应用程序必须等待完成整个任务。

3）换句话说，如果同步应用程序中的任何进程被阻塞，整个应用程序都会被阻塞，我们的应用程序会停止响应，直到整个任务完成。

异步编程在这种情况下非常有用。通过使用异步编程，应用程序可以继续进行不依赖于整个任务完成的其他工作。

net4.0在ThreadPool的基础上推出了Task类，微软极力推荐使用Task来执行异步任务，现在C#类库中的异步方法基本都用到了Task；

net5.0推出了async/await，让异步编程更为方便。

二、Task 的基础使用，Task 的创建 和 启动

我们知道了ThreadPool的弊端：

（1）我们不能控制线程池中线程的执行顺序，

（2）也不能获取线程池内线程取消/异常/完成的通知。

net4.0在ThreadPool的基础上推出了Task

（1）Task拥有线程池的优点

（2）同时也解决了使用线程池不易控制的弊端

1、创建并运行一个Task

首先看一下怎么去创建并运行一个Task，Task的 创建 和 启动 执行的方式有如下三种：

• Task task = new Task(); task.Start();
• Task task = Task.Factory.StartNew();
• Task task = Task.Run();

 		 static void Main(string[] args)
        {
            //1.new方式实例化一个Task，需要通过Start方法启动
            Task task = new Task(() =>
            {
                Thread.Sleep(100);
                Console.WriteLine($"hello, task1的线程ID为{Thread.CurrentThread.ManagedThreadId}");
            });
            task.Start();

            //2.Task.Factory.StartNew(Action action)创建和启动一个Task
            Task task2 = Task.Factory.StartNew(() =>
              {
                  Thread.Sleep(100);
                  Console.WriteLine($"hello, task2的线程ID为{ Thread.CurrentThread.ManagedThreadId}");
              });

            //3.Task.Run(Action action)将任务放在线程池队列，返回并启动一个Task
            Task task3 = Task.Run(() =>
              {
                  Thread.Sleep(100);
                  Console.WriteLine($"hello, task3的线程ID为{ Thread.CurrentThread.ManagedThreadId}");
              });
            Console.WriteLine("执行主线程！");
            Console.ReadKey();
        }

运行结果如下，我们看到先打印"执行主线程"，然后再打印各个任务，说明了Task不会阻塞主线程：

2、创建有返回值的 Task

上边的代码中 Task 都没有返回值，我们也可以创建有返回值的 Task，用法和没有返回值的基本一致,我们简单修改一下上边的栗子，代码如下：

 Task<数据类型>，task.Result 获取结果

值得注意的是 ：task.Resut获取结果时会阻塞线程，即如果task没有执行完成，会等待task执行完成获取到Result，然后再执行后边的代码

• Task<string> task = new Task(); task.Start();
• Task<string> task = Task.Factory.StartNew();
• Task<string> task = Task.Run();

         static void Main(string[] args)
        {
            //1.new方式实例化一个Task，需要通过Start方法启动
            Task<string> task = new Task<string>(() =>
            {
                return $"hello, task1的ID为{Thread.CurrentThread.ManagedThreadId}";
            });
            task.Start();

            //2.Task.Factory.StartNew(Func func)创建和启动一个Task
           Task<string> task2 =Task.Factory.StartNew<string>(() =>
            {
                return $"hello, task2的ID为{ Thread.CurrentThread.ManagedThreadId}";
            });

            //3.Task.Run(Func func)将任务放在线程池队列，返回并启动一个Task
           Task<string> task3= Task.Run<string>(() =>
            {
                return $"hello, task3的ID为{ Thread.CurrentThread.ManagedThreadId}";
            });

            Console.WriteLine("执行主线程！");
            Console.WriteLine(task.Result);
            Console.WriteLine(task2.Result);
            Console.WriteLine(task3.Result);
            Console.ReadKey();
        }

运行结果如下：

3、Task提供了 task.RunSynchronously()用于同步执行Task任务

上边的所有代码中Task的执行都是异步的，不会阻塞主线程。有些场景下我们想让Task同步执行怎么办呢？Task提供了 task.RunSynchronously()用于同步执行Task任务

• Task task = new Task(); task.RunSynchronously();

        static void Main(string[] args)
        {
            Task task = new Task(() =>
            {
                Thread.Sleep(100);
                Console.WriteLine("执行Task结束!");
            });
            //同步执行，task会阻塞主线程
            task.RunSynchronously();
            Console.WriteLine("执行主线程结束！");
            Console.ReadKey();
        }

运行结果如下：

三、Task的阻塞方法（Wait/WaitAll/WaitAny）

1、Thread 阻塞主线程方法 ： thread.Join()方法

Thread的 Join 方法 可以阻塞调用线程，但是有一些弊端：

①如果我们要实现很多线程的阻塞时，每个线程都要调用一次Join方法；

②如果我们想让所有的线程执行完毕(或者任一线程执行完毕)时，立即解除阻塞，使用Join方法不容易实现。

参考代码如下

          static void Main(string[] args)
        {
            Thread th1 = new Thread(() => {
                Thread.Sleep(500);
                Console.WriteLine("线程1执行完毕！");
            });
            th1.Start();
            Thread th2 = new Thread(() => {
                Thread.Sleep(1000);
                Console.WriteLine("线程2执行完毕！");
            });
            th2.Start();
            //阻塞主线程
            th1.Join();
            th2.Join();
            Console.WriteLine("主线程执行完毕！");
            Console.ReadKey();
        }

运行结果如下：

2、Task提供了 Wait/WaitAny/WaitAll 方法，可以更方便地控制线程阻塞

• Task.Wait() 表示等待task执行完毕，功能类似于thead.Join()；
• Task.WaitAll(Task[] tasks) 表示只有所有的task都执行完成了再解除阻塞；
• Task.WaitAny(Task[] tasks)表示只要有一个task执行完毕就解除阻塞；

参考代码如下：

        static void Main(string[] args)
        {
            Task task1 = new Task(() => {
                Thread.Sleep(500);
                Console.WriteLine("线程1执行完毕！");
            });
            task1.Start();
            Task task2 = new Task(() => {
                Thread.Sleep(1000);
                Console.WriteLine("线程2执行完毕！");
            });
            task2.Start();
            //阻塞主线程。task1,task2都执行完毕再执行主线程
            //执行【task1.Wait();task2.Wait();】可以实现相同功能
            Task.WaitAll(new Task[] { task1, task2 });
            Console.WriteLine("主线程执行完毕！");
            Console.ReadKey();
        }

运行结果如下

四、Task的延续操作（WhenAny/WhenAll/ContinueWith）

1、Task 的延续操作（WhenAny/WhenAll/ContinueWith）

上边的 Wait/WaitAny/WaitAll 方法返回值为 void，这些方法单纯的实现阻塞线程。

我们现在想：让所有 task 执行完毕 (或者任一task执行完毕) 后，开始执行后续操作，怎么实现呢？

这时就可以用到WhenAny/WhenAll方法了，这些方法执行完成返回一个task实例。

• task.WhenAll(Task[] tasks) 表示所有的task都执行完毕后再去执行后续的操作
• task.WhenAny(Task[] tasks) 表示任一task执行完毕后就开始执行后续操作

参考代码如下：

        static void Main(string[] args)
        {
            Task task1 = new Task(() => {
                Thread.Sleep(500);
                Console.WriteLine("线程1执行完毕！");
            });
            task1.Start();
            Task task2 = new Task(() => {
                Thread.Sleep(1000);
                Console.WriteLine("线程2执行完毕！");
            });
            task2.Start();
            //task1，task2执行完了后执行后续操作
            Task.WhenAll(task1, task2).ContinueWith((t) => {
                Thread.Sleep(100);
                Console.WriteLine("执行后续操作完毕！");
            });

            Console.WriteLine("主线程执行完毕！");
            Console.ReadKey();
        }

运行结果如下：

 2、Task.Factory 的延续操作（WhenAny/WhenAll/ContinueWith）

上边的栗子也可以通过 Task.Factory.ContinueWhenAll(Task[] tasks, Action continuationAction)和 Task.Factory.ContinueWhenAny(Task[] tasks, Action continuationAction) 来实现

修改上边代码如下

        static void Main(string[] args)
        {
            Task task1 = new Task(() => {
                Thread.Sleep(500);
                Console.WriteLine("线程1执行完毕！");
            });
            task1.Start();
            Task task2 = new Task(() => {
                Thread.Sleep(1000);
                Console.WriteLine("线程2执行完毕！");
            });
            task2.Start();
            //通过TaskFactroy实现
            Task.Factory.ContinueWhenAll(new Task[] { task1, task2 }, (t) =>
            {
                Thread.Sleep(100);
                Console.WriteLine("执行后续操作");
            });

            Console.WriteLine("主线程执行完毕！");
            Console.ReadKey();
        }

运行结果不变，如下

五、Task 的任务取消(CancellationTokenSource)

1、Thread 的任务取消

在Task前我们执行任务采用的是Thread，Thread怎么取消任务呢？

一般流程是：

• 1）设置一个变量来控制任务是否停止，如设置一个变量isStop
• 2）然后线程轮询查看isStop，如果isStop为true就停止

参考代码如下：

        static void Main(string[] args)
        {
            bool isStop = false;
            int index = 0;
            //开启一个线程执行任务
            Thread th1 = new Thread(() =>
            {
                while (!isStop)
                {
                    Thread.Sleep(1000);
                    Console.WriteLine($"第{++index}次执行，线程运行中...");
                }
            });
            th1.Start();
            //五秒后取消任务执行
            Thread.Sleep(5000);
            isStop = true;
            Console.ReadKey();
        }

运行结果如下

 2、Task 的任务取消

Task中有一个专门的类 CancellationTokenSource 来取消任务执行

还是使用上边的例子，调整代码如下

        static void Main(string[] args)
        {
            CancellationTokenSource source = new CancellationTokenSource();
            int index = 0;
            //开启一个task执行任务
            Task task1 = new Task(() =>
            {
                while (!source.IsCancellationRequested)
                {
                    Thread.Sleep(1000);
                    Console.WriteLine($"第{++index}次执行，线程运行中...");
                }
            });
            task1.Start();
            //五秒后取消任务执行
            Thread.Sleep(5000);
            //source.Cancel()方法请求取消任务，IsCancellationRequested会变成true
            source.Cancel();
            Console.ReadKey();
        }

程序运行的效果不变，如下

3、 CancellationTokenSource  中 source.Token.Register 和 source.CancelAfter(XXXXms)

CancellationTokenSource 的功能不仅仅是取消任务执行，我们可以使用

• source.CancelAfter(5000)实现5秒后自动取消任务
• source.Token.Register(Action action) 可以注册取消任务触发的回调函数，即任务被取消时注册的action会被执行

参考代码如下

        static void Main(string[] args)
        {
            CancellationTokenSource source = new CancellationTokenSource();
            //注册任务取消的事件
            source.Token.Register(() =>
            {
                Console.WriteLine("任务被取消后执行xx操作！");
            });

            int index = 0;
            //开启一个task执行任务
            Task task1 = new Task(() =>
            {
                while (!source.IsCancellationRequested)
                {
                    Thread.Sleep(1000);
                    Console.WriteLine($"第{++index}次执行，线程运行中...");
                }
            });
            task1.Start();
            //延时取消，效果等同于Thread.Sleep(5000);source.Cancel();
            source.CancelAfter(5000);
            Console.ReadKey();
        }

运行结果如下

 五、异步方法(async/await)

在 C# 5.0 中出现的 async 和 await ，让异步编程变得更简单。

此方法利用了 .NET Framework 4.5 及更高版本、.NET Core 和 Windows 运行时中的异步支持。

编译器可执行开发人员曾进行的高难度工作，且应用程序保留了一个类似于同步代码的逻辑结构。

• async 用在方法定义前面，await只能写在带有async标记的方法中。
• 注意await异步等待的地方，await后面的代码和前面的代码执行的线程可能不一样
• async关键字创建了一个状态机，类似yield return 语句；await会解除当前线程的阻塞，完成其他任务

这里实现同步异步读取文件内容的方式。

我们可以看到异步读取代码和同步读取代码基本一致。async/await让异步编码变得更简单，我们可以像写同步代码一样去写异步代码。

注意一个小问题：异步方法中方法签名返回值为Task，代码中的返回值为T。

代码中GetContentAsync的签名返回值为Task，而代码中返回值为string。牢记这一细节对我们分析异步代码很有帮助。

异步方法签名的返回值有以下三种：

• ① Task：如果调用方法想通过调用异步方法获取一个T类型的返回值，那么签名必须为Task；
• ② Task:如果调用方法不想通过异步方法获取一个值，仅仅想追踪异步方法的执行状态，那么我们可以设置异步方法签名的返回值为Task;
• ③ void:如果调用方法仅仅只是调用一下异步方法，不和异步方法做其他交互，我们可以设置异步方法签名的返回值为void，这种形式也叫做“调用并忘记”。

参考代码如下

        static void Main(string[] args)
        {
            //Console.WriteLine(" Environment.CurrentDirectory "+ Environment.CurrentDirectory);
            string content = GetContentAsync(Environment.CurrentDirectory + @"/test.txt").Result;
            //调用同步方法
            //string content = GetContent(Environment.CurrentDirectory + @"/test.txt");
            Console.WriteLine(content);
            Console.ReadKey();
        }
 
        /// <summary>
        /// 异步读取文件内容
        /// </summary>
        /// <param name="filename"></param>
        /// <returns></returns>
        async static Task<string> GetContentAsync(string filename)
        {

            FileStream fs = new FileStream(filename, FileMode.Open);
            var bytes = new byte[fs.Length];
            //ReadAync方法异步读取内容，不阻塞线程
            Console.WriteLine("开始读取文件");
            int len = await fs.ReadAsync(bytes, 0, bytes.Length);
            string result = Encoding.UTF8.GetString(bytes);
            return result;
        }

        /// <summary>
        /// 同步读取文件内容
        /// </summary>
        /// <param name="filename"></param>
        /// <returns></returns>
        static string GetContent(string filename)
        {
            FileStream fs = new FileStream(filename, FileMode.Open);
            var bytes = new byte[fs.Length];
            //Read方法同步读取内容，阻塞线程
            int len = fs.Read(bytes, 0, bytes.Length);
            string result = Encoding.UTF8.GetString(bytes);
            return result;
        }

运行结果如下：

六、Task、async和 await 、Thread 简单小结

最后我们简单记住一些特性，就可以有个较好的理解他们了：

• 1）async/await是基于Task的
• 2）而Task是对ThreadPool的封装改进，主要是为了更有效的控制线程池中的线程(ThreadPool中的线程，我们很难通过代码控制其执行顺序，任务延续和取消等等)；
• 3）ThreadPool基于Thread的，主要目的是减少Thread创建数量和管理Thread的成本。
• 4）async/await Task是C#中更先进的，也是微软大力推广的特性
• 5）我们在开发中可以尝试使用Task来替代Thread/ThreadPool，处理本地IO和网络IO任务是尽量使用async/await来提高任务执行效率。