Asp.Net Core 輕鬆學-多線程之Task快速上手

時間 2019-11-07

標籤 asp.net asp core 輕鬆多線程 task 快速上手欄目 ASP 简体版

原文原文鏈接

前言

Task是從 .NET Framework 4 開始引入的一項基於隊列的異步任務（TAP）模式，從 .NET Framework 4.5 開始，任何使用 async/await 進行修飾的方法，都會被認爲是一個異步方法；實際上，這些異步方法都是基於隊列的線程任務，從你開始使用 Task 去運行一段代碼的時候，實際上就至關於開啓了一個線程，默認狀況下，這個線程數由線程池 ThreadPool 進行管理的。git

1. Task 的使用方法

Task 的使用用方法很是簡單，一行代碼就能夠開始一個異步任務github

1.1 最簡單的使用方式

static void EasyTask()
        {
            // 執行一個無返回值的任務
            Task.Run(() =>
            {
                Console.WriteLine("runing...");
            });

            // 執行一個返回 int 類型結果的任務
            Task.Run<int>(() =>
            {
                return new Random().Next();
            });

            // 聲明一個任務，僅聲明，不執行
            Task t = new Task(() =>
            {
                Console.WriteLine("");
            });
        }

上面的代碼看起來很是簡單，只須要一行代碼就完成了一個異步任務線程，先不要去深究其背後的原理，對於新手來講，先解決能用，再去了解爲何能夠這樣使用，否則，一開始就失去了學習的信心服務器

2.1 使用 TaskFactory 工廠開始異步任務

static void Factory()
        {
            List<Task<int>> tasks = new List<Task<int>>();
            TaskFactory factory = new TaskFactory();
            tasks.Add(factory.StartNew<int>(() =>
           {
               return 1;
           }));
            tasks.Add(factory.StartNew<int>(() =>
            {
                return 2;
            }));

            foreach (var t in tasks)
            {
                Console.WriteLine("Task:{0}", t.Result);
            }
        }

上面的代碼使用 TaskFactory 建立並運行了兩個異步任務，同時把這兩個任務加入了任務列表 tasks 中，而後當即迭代此 tasks 獲取異步任務的執行結果，使用 TaskFactory 工廠類，能夠建立一組人物，而後依次執行它們多線程

2.3 執行上面的代碼，輸出結果以下

3. 處理 Task 中的異常

異步任務中發生異常會致使任務拋出 TaskCancelException 的異常，僅表示任務退出，程序應當捕獲該異常；而後，當即調用 Task 進行狀態判斷，獲取內部異常併發

3.1 模擬拋出異常

static void SimpleTask()
        {
            var task = Task.Run(() =>
            {
                Console.WriteLine("SimpleTask");
                Task.Delay(1000).Wait();
                throw new Exception("SimpleTask Error");
            });
            try
            {
                task.Wait();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
             if (task.IsCompletedSuccessfully)
            {
                Console.WriteLine("IsCompleted");
            }
        }

上面的代碼模擬了 Task 內部發生的異常，並捕獲了異常，一般狀況下，推薦使用 Task 的任務狀態判斷以進行下一步的任務處理（若是須要），若是僅僅是簡單的執行一個異步任務，直接捕獲異常便可，這裏使用了狀態判斷，若是任務已完成，則打印一則消息：IsCompleted；很明顯，在上面的代碼中，此「IsCompleted」消息並不會被打印到控制檯
注意，這裏使用了 task.IsCompletedSuccessfully 而不是 task.IsCompleted，這二者的區別在於，前者只有在任務正常執行完成，無異常，無中途退出指令的狀況下才會表示已完成，而 task.IsCompleted 則僅僅表示「任務完成」dom

3.2 執行程序，輸出結果

4. 同步上下文

在 WinForm/WPF 應用程序中，也經常須要在 UI 上開闢異步任務，一般狀況下，窗體控件僅容許建立其的線程訪問，在沒有 Task 的時代，處理異步上下文到同步上下文是一件很是複雜的事情，在 Task 出現之後，提供了 TaskScheduler 任務調度器，讓咱們能夠很是方便的在異步線程中訪問 UI 線程的資源異步

4.1 獲取當前線程上下文對象

static void TaskSynchronizationContext()
        {
            var UISyncContext = TaskScheduler.FromCurrentSynchronizationContext();

            var t1 = Task.Factory.StartNew<int>(() =>
               {
                   return 1;
               });
            t1.ContinueWith((atnt) =>
            {
                // 從這裏訪問 UI 線程的資源
                Console.WriteLine("從這裏訪問 UI 線程的資源");

            }, UISyncContext);
        }

從上面的代碼能夠發現，僅僅須要調用 TaskScheduler.FromCurrentSynchronizationContext() 得到當前線程的同步上下文，而後在執行異步任務的時候傳入，便可訪問當前線程建立的 UI 資源async

5. Task 的運行方式

5.1 基於 ThreadPool 線程池的方式

一個異步任務老是處於隊列中，任務隊列基於先進先出的原則，最新進入隊列的任務老是最早被執行；可是，在多線程的環境下，最早執行並不意味着最早結束，意識到這一點很重要，每一個任務可調度的資源和處理的進度決定了任務的完成時間。
默認狀況下，全部的任務都使用 ThreadPool 的資源，當你開啓一個 Task 的時候，實際上，是由 ThreadPool 分配了一個線程，ThreadPool 的上限取決於不少方面的因素，例如虛擬內存的大小，當 Task 開啓的數量超過ThreadPool 的上限的時候，Task 將進入排隊狀態，能夠手動設置 ThreadPool 的大小學習

static void SetThreadPool()
        {
            var available = ThreadPool.SetMaxThreads(8, 16);
            Console.WriteLine("Result:{0}", available);
        }

上面的代碼表示設置當前程序可以使用的線程池大小，可是，SetMaxThreads 的值不該該小於託管服務器的 CPU 核心數量，不然，變量 available 的值將顯示爲 false，表示未成功設置線程池上限
注意：ThreadPool 上的全部線程都是後臺線程，也就是說，其IsBackground屬性是true，在託管程序退出後，ThreadPool 也將會退出。線程

5.2 長時間運行於後臺的任務

在建立 Task 的時候，咱們可能須要作一些長時間運行的業務，這個時候若是使用默認的 ThreadPool 資源，在併發狀態下，這是不合適的，由於該任務老是長時間的佔用線程池中的資源，致使線程池數量受限，這種狀況下，能夠在建立任務的時候使用指定 TaskCreationOptions.LongRunning 方式建立 Task

static void LongTask()
        {
            Task.Factory.StartNew(() =>
            {
                Console.WriteLine("LongRunning Task");
            }, TaskCreationOptions.LongRunning);
        }

上面的代碼看起來和建立普通的 Task 任務並無多大的區別，惟一不一樣的是，在參數中傳入了 TaskCreationOptions.LongRunning，指定這個是一個 LongRunning 類型的任務，當TaskFactory 收到這樣一個類型的任務時，將會爲這個任務開闢一個獨立的線程，而不是從 ThreadPool 中建立

6. 有條件的 Task

Task 內部提供多種多樣的基於隊列的鏈式任務管理方法，經過使用這些快捷方式，可讓異步隊列有序的執行，好比ContinueWith()，ContinueWhenAll()，ContinueWhenAny(),WaitAll()，WaitAny()，WhenAll(),WhenAny()

6.1 使用演示

static void WithTask()
        {
            var order1 = Task.Run(() =>
            {
                Console.WriteLine("Order 1");
            });

            // 匿名委託將等待 order1 執行完成後執行，並將 order1 對象做爲參數傳入
            order1.ContinueWith((task) =>
            {
                Console.WriteLine("Order 1 Is Completed");
            });

            var t1 = Task.Run(() => { Task.Delay(1500).Wait(); Console.WriteLine("t1"); });
            var t2 = Task.Run(() => { Task.Delay(2000).Wait(); Console.WriteLine("t2"); });
            var t3 = Task.Run(() => { Task.Delay(3000).Wait(); Console.WriteLine("t3"); });
            Task.WaitAll(t1, t2, t3);
            // t1,t2,t3 完成後輸出下面的消息
            Console.WriteLine("t1,t2,t3 Is Complete");

            var t4 = Task.Run(() => { Task.Delay(1500).Wait(); Console.WriteLine("t4"); });
            var t5 = Task.Run(() => { Task.Delay(2000).Wait(); Console.WriteLine("t5"); });
            var t6 = Task.Run(() => { Task.Delay(3000).Wait(); Console.WriteLine("t6"); });
            Task.WaitAny(t4, t5, t6);
            // 當任意任務完成時，輸出下面的消息，目前按延遲時間計算，在 t4 完成後當即輸出下面的信息
            Console.WriteLine("t4,t5,t6 Is Complete");

            var t7 = Task.Run(() => { Task.Delay(1500).Wait(); Console.WriteLine("t7"); });
            var t8 = Task.Run(() => { Task.Delay(2000).Wait(); Console.WriteLine("t8"); });
            var t9 = Task.Run(() => { Task.Delay(3000).Wait(); Console.WriteLine("t9"); });
            var whenAll = Task.WhenAll(t7, t8, t9);
            // WhenAll 不會等待，因此這裏必須顯示指定等待
            whenAll.Wait();
            // 當全部任務完成時，輸出下面的消息
            Console.WriteLine("t7,t8,t9 Is Complete");

            var t10 = Task.Run(() => { Task.Delay(1500).Wait(); Console.WriteLine("t10"); });
            var t11 = Task.Run(() => { Task.Delay(2000).Wait(); Console.WriteLine("t11"); });
            var t12 = Task.Run(() => { Task.Delay(3000).Wait(); Console.WriteLine("t12"); });
            var whenAny = Task.WhenAll(t10, t11, t12);
            // whenAny 不會等待，因此這裏必須顯示指定等待
            whenAny.Wait();
            // 當任意任務完成時，輸出下面的消息，目前按延遲時間計算，在 t10 完成後當即輸出下面的信息
            Console.WriteLine("t10,t11,t12 Is Complete");
        }

6.2 執行上面的代碼，輸出結果以下

值得注意的是，當調用 WhenAll 方法時，會返回執行任務的狀態，此狀態是全部任務的統一狀態，若是執行了 3 個任務，而其中一個出錯，則返回任務狀態表示爲：Faulted，若是任意任務被取消，則狀態爲：Canceled；
當調用 WhenAny() 方法時，表示任意任務完成便可表示完成，此時，會返回最早完成的任務信息
注意：WhenAll 和 WhenAny 方法正常執行，無異常，無取消，則所返回的完成狀態表示爲：RanToCompletion