C#多線程(14)：任務基礎②

時間 2020-04-29

標籤 c# 多線程任務基礎欄目 C# 简体版

原文原文鏈接

上一篇，咱們學習了任務的基礎，學會多種方式場景任務和執行，異步獲取返回結果等。上一篇講述的知識比較多，這一篇只要是代碼實踐和示例操做。html

判斷任務狀態

屬性	說明
IsCanceled	獲取此 Task 實例是否因爲被取消的緣由而已完成執行。
IsCompleted	獲取一個值，它表示是否已完成任務。
IsCompletedSuccessfully	瞭解任務是否運行到完成。
IsFaulted	獲取 Task是否因爲未經處理異常的緣由而完成。
Status	獲取此任務的 TaskStatus。

要檢測一個任務是否出錯(指任務因未經處理的異常而致使工做終止)，要使用 IsCanceled 和 IsFaulted 兩個屬性，只要任務拋出異常，IsFaulted 爲 true。可是取消任務本質是拋出 OperationCancelExcetion 異常，不表明任務出錯。api

即便任務拋出了未經處理的異常，也算是完成了任務，所以 IsCompleted 屬性，會爲 true。多線程

示例以下：dom

代碼有點多，不易觀察，請複製到程序中運行。異步

class Program
    {
        static void Main()
        {
            // 正常任務
            Task task1 = new Task(() =>
            {
            });
            task1.Start();
            Thread.Sleep(TimeSpan.FromSeconds(1));
            GetResult(task1.IsCanceled, task1.IsFaulted);
            Console.WriteLine("任務是否完成：" + task1.IsCompleted);
            Console.WriteLine("-------------------");
            
            // 異常任務
            Task task2 = new Task(() =>
            {
                throw new Exception();
            });
            task2.Start();
            Thread.Sleep(TimeSpan.FromSeconds(1));
            GetResult(task2.IsCanceled, task2.IsFaulted);
            Console.WriteLine("任務是否完成：" + task2.IsCompleted);
            Console.WriteLine("-------------------");
            Thread.Sleep(TimeSpan.FromSeconds(1));

            CancellationTokenSource cts = new CancellationTokenSource();
            // 取消任務
            Task task3 = new Task(() =>
            {
                Thread.Sleep(TimeSpan.FromSeconds(3));
            }, cts.Token);
            task3.Start();
            cts.Cancel();
            Thread.Sleep(TimeSpan.FromSeconds(1));
            GetResult(task3.IsCanceled, task3.IsFaulted);
            Console.WriteLine("任務是否完成：" + task3.IsCompleted);
            Console.ReadKey();
        }

        public static void GetResult(bool isCancel, bool isFault)
        {
            if (isCancel == false && isFault == false)
                Console.WriteLine("沒有異常發生");
            else if (isCancel == true)
                Console.WriteLine("任務被取消");
            else
                Console.WriteLine("任務引起了未經處理的異常");
        }
    }

再說父子任務

在上一篇文章中《C#多線程(13)：任務基礎①》，咱們學習了父子任務，父任務須要等待子任務完成後纔算完成任務。ide

上一章只是給出示例，沒有明確說明場景和實驗結果，這裏從新寫一個示例來補充。函數

非父子任務：oop

外層任務不會等待內嵌的任務完成，直接完成或返回結果。學習

static void Main()
        {
            //兩個任務沒有從屬關係，是獨立的
            Task<int> task = new Task<int>(() =>
            {
                // 非子任務
                Task task1 = new Task(() =>
                {
                    Thread.Sleep(TimeSpan.FromSeconds(1));
                    for (int i = 0; i < 5; i++)
                    {
                        Console.WriteLine("     內層任務1");
                        Thread.Sleep(TimeSpan.FromSeconds(0.5));
                    }
                });
                task1.Start();
                return 666;
            });
            task.Start();
            Console.WriteLine($"任務運算結果是：{task.Result}");
            Console.WriteLine("\n-------------------\n");
            Console.ReadKey();
            }

父子任務：測試

父任務等待子任務完成後，才能算完成任務，而後返回結果。

static void Main()
        {
            // 父子任務
            Task<int> task = new Task<int>(() =>
            {
                // 子任務
                Task task1 = new Task(() =>
                {
                    Thread.Sleep(TimeSpan.FromSeconds(1));
                    for (int i = 0; i < 5; i++)
                    {
                        Console.WriteLine("     內層任務1");
                        Thread.Sleep(TimeSpan.FromSeconds(0.5));
                    }
                }, TaskCreationOptions.AttachedToParent);
                task1.Start();

                Console.WriteLine("最外層任務");
                return 666;
            });

            task.Start();
            Console.WriteLine($"任務運算結果是：{task.Result}");
            Console.WriteLine("\n-------------------\n");

            Console.ReadKey();
        }

組合任務/延續任務

Task.ContinueWith() 方法建立一個在任務(Task)實例完成時異步執行的延續任務。

Task.ContinueWith() 的重載方法很是多，能夠參考：https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.continuewith?view=netcore-3.1#--

這裏咱們使用的構造函數定義以下：

public Task ContinueWith(Action<Task> continuationAction);

一個簡單的示例：

Task task = new Task(() =>
            {
                Console.WriteLine("     第一個任務");
                Thread.Sleep(TimeSpan.FromSeconds(2));
            });

            // 接下來第二個任務
            task.ContinueWith(t =>
            {
                Console.WriteLine($"     第二個任務}");
                Thread.Sleep(TimeSpan.FromSeconds(2));
            });
            task.Start();

一個任務(Task) 是能夠設置多個延續任務的，這些任務是並行的，例如：

static void Main()
        {
            Task task = new Task(() =>
            {
                Console.WriteLine("     第一個任務");
                Thread.Sleep(TimeSpan.FromSeconds(1));
            });

            // 任務①
            task.ContinueWith(t =>
            {
                for (int i = 0; i < 5; i++)
                {
                    Console.WriteLine($"    任務① ");
                    Thread.Sleep(TimeSpan.FromSeconds(1));
                }
            });

            // 任務②
            task.ContinueWith(t =>
            {
                for (int i = 0; i < 5; i++)
                {
                    Console.WriteLine($"     任務②");
                    Thread.Sleep(TimeSpan.FromSeconds(1));
                }
            });

            // 任務① 和 任務② 屬於同級並行任務

            task.Start();
            }

經過屢次實現延續/組合任務，會實現強有力的任務流程。

複雜的延續任務

通過上一小節，咱們學習了 ContinueWith() 來延續任務，如今咱們來學習更多的重載方法，實現更加複雜的延續。

ContinueWith() 重載方法不少，它們的參數都含有下面幾種參數之一或多個。

continuationAction

類型：Action 或 Func

一個要執行的任務。

state

類型：Object

給延續任務傳遞的參數。

cancellationToken

類型：CancellationToken

取消標記。

continuationOptions

類型：TaskContinuationOptions

控制延續任務的建立和特性。

scheduler

類型：TaskScheduler

要與延續任務關聯並用於其執行過程的 TaskScheduler。

前面四個參數(類型)，在以往的文章中已經出現過，這裏就再也不贅述；TaskScheduler 類型，這裏先講解，後面再說。

注意 TaskCreationOptions 和 TaskContinuationOptions 的區別，在前一篇咱們學習過 TaskCreationOptions。這裏來學習 TaskContinuationOptions 。

TaskContinuationOptions 能夠在如下重載上使用：

ContinueWith(Action, CancellationToken, TaskContinuationOptions, TaskScheduler)

ContinueWith(Action>, TaskContinuationOptions

在延續中，這樣使用是無效的：

Task task = new Task(() =>
            {
                Console.WriteLine("     第一個任務");
                Thread.Sleep(TimeSpan.FromSeconds(1));
            });
            task.ContinueWith(t =>
            {
                for (int i = 0; i < 5; i++)
                {
                    Console.WriteLine($"    任務① ");
                    Thread.Sleep(TimeSpan.FromSeconds(1));
                }
            },TaskContinuationOptions.AttachedToParent);

由於 TaskContinuationOptions 須要有嵌套關係的父子任務，才能生效。

正確使用方法：

static void Main()
        {
            // 父子任務
            Task<int> task = new Task<int>(() =>
            {
                // 子任務
                Task task1 = new Task(() =>
                {
                    Thread.Sleep(TimeSpan.FromSeconds(1));
                    Console.WriteLine("     內層任務1");
                    Thread.Sleep(TimeSpan.FromSeconds(0.5));
                }, TaskCreationOptions.AttachedToParent);

                task1.ContinueWith(t =>
                {
                    Thread.Sleep(TimeSpan.FromSeconds(1));
                    Console.WriteLine("內層延續任務，也屬於子任務");
                    Thread.Sleep(TimeSpan.FromSeconds(0.5));
                }, TaskContinuationOptions.AttachedToParent);

                task1.Start();

                Console.WriteLine("最外層任務");
                return 666;
            });

            task.Start();
            Console.WriteLine($"任務運算結果是：{task.Result}");
            Console.WriteLine("\n-------------------\n");

            Console.ReadKey();
        }

並行(異步)處理任務

這裏咱們來學習 Task.WhenAll() 方法的使用。

Task.WhenAll() ：等待提供的全部 Task 對象完成執行過程

使用示例以下：

static void Main()
        {
            List<Task> tasks = new List<Task>();

            for (int i = 0; i < 5; i++)
                tasks.Add(Task.Run(() =>
                {
                    Console.WriteLine($"任務開始執行");
                }));

            // public static Task WhenAll(IEnumerable<Task> tasks);

            // 至關於多個任務，生成一個任務
            Task taskOne = Task.WhenAll(tasks);
            // 不須要等待的話就去除
            taskOne.Wait();

            Console.ReadKey();
        }

Task taskOne = Task.WhenAll(tasks); 能夠寫成 Task.WhenAll(tasks);，返回的 Task 對象能夠用來判斷任務執行狀況。

要注意，下面這樣是無效的：

你能夠修改上面的代碼進行測試。

tasks.Add(new Task(() =>
                {
                    Console.WriteLine($"任務開始執行");
                }));

我也不知道爲啥 new Task() 不行。。。

若是任務有返回值，則可使用下面這種方法

static void Main()
        {
            List<Task<int>> tasks = new List<Task<int>>();

            for (int i = 0; i < 5; i++)
                tasks.Add(Task.Run<int>(() =>
                {
                    Console.WriteLine($"任務開始執行");
                    return new Random().Next(0,10);
                }));

            Task<int[]> taskOne = Task.WhenAll(tasks);

            foreach (var item in taskOne.Result)
                Console.WriteLine(item);

            Console.ReadKey();
        }

並行(同步)處理任務

Task.WaitAll()：等待提供的全部 Task 對象完成執行過程。

咱們來看看 Task.WaitAll() 其中一個重載方法的定義：

public static bool WaitAll (Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken);

tasks 類型：Task[]

要執行的全部任務。

millisecondsTimeout 任務：Int32

等待的毫秒數，-1 表示無限期等待。

cancellationToken 類型：CancellationToken

等待任務完成期間要觀察的 CancellationToken。

Task.WaitAll() 的示例以下：

static void Main()
        {
            List<Task> tasks = new List<Task>();

            for (int i = 0; i < 5; i++)
                tasks.Add(Task.Run(() =>
                {
                    Console.WriteLine($"任務開始執行");
                }));

            Task.WaitAll(tasks.ToArray());

            Console.ReadKey();
        }

Task.WaitAll() 會讓當前線程等待全部任務執行完畢。而且 Task.WaitAll() 是沒有泛型的，也麼沒有返回結果。

並行任務的 Task.WhenAny

Task.WhenAny() 和 Task.WhenAll() 使用上差很少，Task.WhenAll() 當全部任務都完成時，纔算完成，而 Task.WhenAny() 只要其中一個任務完成，都算完成。

這一點能夠參考上面的 父子任務。

參考使用示例以下：

static void Main()
        {
            List<Task> tasks = new List<Task>();

            for (int i = 0; i < 5; i++)
                tasks.Add(Task.Run(() =>
                {
                    Thread.Sleep(TimeSpan.FromSeconds(new Random().Next(0, 5)));
                    Console.WriteLine("     正在執行任務");
                }));
            Task taskOne = Task.WhenAny(tasks);
            taskOne.Wait(); // 任意一個任務完成，就能夠解除等待

            Console.WriteLine("有任務已經完成了");

            Console.ReadKey();
        }

固然，Task.WhenAny() 也有泛型方法，能夠返回結果。

並行任務狀態

Task.Status 屬性能夠獲取任務的狀態。其屬性類型是一個 TaskStatus 枚舉，其定義以下：

枚舉	值	說明
Canceled	6	已經經過 CancellationToken 取消任務。
Created	0	該任務已初始化，但還沒有被計劃。
Faulted	7	因爲未處理異常的緣由而完成的任務。
RanToCompletion	5	已成功完成執行的任務。
Running	3	該任務正在運行，但還沒有完成。
WaitingForActivation	1	該任務正在等待 .NET Framework 基礎結構在內部將其激活並進行計劃。
WaitingForChildrenToComplete	4	該任務已完成執行，正在隱式等待附加的子任務完成。
WaitingToRun	2	該任務已被計劃執行，但還沒有開始執行。

在使用並行任務時，Task.Status 的值，有必定規律：

若是有其中一個任務出現未經處理的異常，那麼返回TaskStatus.Faulted；
若是全部任務都出現未經處理的異常，會返回 TaskStatus. RanToCompletion ；
若是其中一個任務被取消(即便出現未經處理的異常)，會返回 TaskStaus.Canceled；

循環中值變化問題

請運行測試下面兩個示例：

static void Main()
        {
            for (int i = 0; i < 5; i++)
                new Thread(() =>
                {
                    Console.WriteLine($"i = {i}");
                }).Start();

            Console.ReadKey();
        }

static void Main()
        {
            List<Task> tasks = new List<Task>();

            for (int i = 0; i < 5; i++)
                tasks.Add(Task.Run(() =>
                {
                    Console.WriteLine($"i = {i}");
                }));
            Task taskOne = Task.WhenAll(tasks);
            taskOne.Wait();

            Console.ReadKey();
        }

你會發現，兩個示例的結果並非 1,2,3,4,5，而是 5,5,5,5,5。

這個問題稱爲 Race condition(競爭條件)，能夠參考維基百科：

https://en.wikipedia.org/wiki/Race_condition

微軟文檔裏面也有關於此問題的說明，請參考：

https://docs.microsoft.com/zh-cn/archive/blogs/ericlippert/closing-over-the-loop-variable-considered-harmful

因爲 i 在整個生命週期，內存都是在同一個位置，每一個線程或任務對其值得使用，都是指向相同位置的。

這樣就好了：

static void Main()
        {
            for (int i = 0; i < 5; i++)
            {
                int tmp = i;
                new Thread(() =>
                {
                    Console.WriteLine($"i = {tmp}");
                }).Start();
            }

            Console.ReadKey();
        }

這樣是無效的：

for (int i = 0; i < 5; i++)
                new Thread(() =>
                {
                    int tmp = i;
                    Console.WriteLine($"i = {tmp}");
                }).Start();