多線程之旅（Task 任務）

一、Task(任務)和ThreadPool（線程池）不同

      源碼

　　1、線程（Thread）是創建並發工具的底層類，但是在前幾篇文章中我們介紹了Thread的特點，和實例。可以很明顯發現局限性（返回值不好獲取（必須在一個作用域中）），當我們線程執行完之后不能很好的進行下一次任務的執行，需要多次銷毀和創建，所以不是很容易使用在多並發的情況下。

　　2、線程池（ThreadPool） QueueUserWorkItem是很容易發起並發任務，也解決了上面我們的需要多次創建、銷毀的性能損耗解決了，但是我們就是太簡單的，我不知道線程什么時候結束，也沒有獲取返回值的途徑，也是比較尷尬的事情。

　　3、任務（Task）表示一個通過或不通過線程實現的並發操作，任務是可組合的，使用延續（continuation）可將它們串聯在一起，它們可以使用線程池減少啟動延遲，可使用回調方法避免多個線程同時等待I/O密集操作。

二、初識Task（任務）

　　1、Task（任務）是在.NET 4.0引入的、Task是在我們線程池ThreadPool上面進行進一步的優化，所以Task默認還是線程池線程，並且是后台線程，當我們的主線程結束時其他線程也會結束

　　2、Task創建任務，也和之前差不多

 /// <summary>
        /// Task 的使用
        /// Task 的創建還是差不多的
        /// </summary>
        public static void Show()
        {
            //實例方式
            Task task = new Task(() =>
            {
                Console.WriteLine("無返回參數的委托");
            });

            //無參有返回值
            Task<string> task1 = new Task<string>(() =>
            {
                return "我是返回值";
            });

            //有參有返回值
            Task<string> task2 = new Task<string>(x =>
            {
                return "返回值 -- " + x.ToString();
            }, "我是輸入參數");
            //開啟線程
            task2.Start();
            //獲取返回值 Result會堵塞線程獲取返回值
            Console.WriteLine(task2.Result);

            //使用線程工廠創建 無參數無返回值線程
            Task.Factory.StartNew(() =>
            {
                Console.WriteLine("這個是線程工廠創建");
            }).Start();

            //使用線程工廠創建 有參數有返回值線程
            Task.Factory.StartNew(x =>
            {
                return "返回值 -- " + x.ToString(); ;
            }, "我是參數");

            //直接靜態方法運行
            Task.Run(() =>
            {
                Console.WriteLine("無返回參數的委托");
            });
        }

說明：

　　1、事實上Task.Factory類型本身就是TaskFactory（任務工廠），而Task.Run（在.NET4.5引入，4.0版本調用的是后者）是Task.Factory.StartNew的簡寫法，是后者的重載版本，更靈活簡單些。

　　2、調用靜態Run方法會自動創建Task對象並立即調用Start

　　3、Task.Run等方式啟動任務並沒有調用Start,因為它創建的是“熱”任務，相反“冷”任務的創建是通過Task構造函數。

三、Task（任務進階）

　　1、Wait 等待Task線程完成才會執行后續動作

 //創建一個線程使用Wait堵塞線程
            Task.Run(() =>
            {
                Console.WriteLine("Wait 等待Task線程完成才會執行后續動作");
            }).Wait();

　　2、WaitAll 等待Task[] 線程數組全部執行成功之后才會執行后續動作

            //創建一個裝載線程的容器
            List<Task> list = new List<Task>();
            for (int i = 0; i < 10; i++)
            {
                list.Add(Task.Run(() =>
                {
                    Console.WriteLine("WaitAll 執行");
                }));
            }
            Task.WaitAll(list.ToArray());
            Console.WriteLine("Wait執行完畢");

　　3、WaitAny 等待Task[] 線程數組任一執行成功之后就會執行后續動作

//創建一個裝載線程的容器
            List<Task> list = new List<Task>();
            for (int i = 0; i < 10; i++)
            {
                list.Add(Task.Run(() =>
                {
                    Console.WriteLine("WaitAny 執行");
                }));
            }
            Task.WaitAny(list.ToArray());
            Console.WriteLine("WaitAny 執行完畢");

　　4、WhenAll 等待Task[] 線程數組全部執行成功之后才會執行后續動作、與WaitAll不同的是他有回調函數ContinueWith

 //創建一個裝載線程的容器
            List<Task> list = new List<Task>();
            for (int i = 0; i < 10; i++)
            {
                list.Add(Task.Run(() =>
                {
                    Console.WriteLine("WhenAll 執行");
                }));
            }
            Task.WhenAll(list.ToArray()).ContinueWith(x =>
            {
                return x.AsyncState;
            });
            Console.WriteLine("WhenAll 執行完畢");

　　5、WhenAny 等待Task[] 線程數組任一執行成功之后就會執行后續動作、與WaitAny不同的是他有回調函數ContinueWith

//創建一個裝載線程的容器
            List<Task> list = new List<Task>();
            for (int i = 0; i < 10; i++)
            {
                list.Add(Task.Run(() =>
                {
                    Console.WriteLine("WhenAny 執行");
                }));
            }
            Task.WhenAny(list.ToArray()).ContinueWith(x =>
            {
                return x.AsyncState;
            });
            Console.WriteLine("WhenAny 執行完畢");
            Console.ReadLine();

四、Parallel 並發控制

　　1、是在Task的基礎上做了封裝 4.5，使用起來比較簡單，如果我們執行100個任務，只能用到10個線程我們就可以使用Parallel並發控制

        public static void Show5()
        {
            //第一種方法是
            Parallel.Invoke(() =>
            {
                Console.WriteLine("我是線程一號");
            }, () =>
            {
                Console.WriteLine("我是線程二號");
            }, () =>
            {
                Console.WriteLine("我是線程三號");
            });

            //for 方式創建多線程
            Parallel.For(0, 5, x =>
            {
                Console.WriteLine("這個看名字就知道是for了哈哈 i=" + x);
            });

            //ForEach 方式創建多線程
            Parallel.ForEach(new string[] { "0", "1", "2", "3", "4" }, x => Console.WriteLine("這個看名字就知道是ForEach了哈哈 i=" + x));

            //這個我們包一層，就不會卡主界面了
            Task.Run(() =>
            {
                //創建線程選項
                ParallelOptions parallelOptions = new ParallelOptions()
                {
                    MaxDegreeOfParallelism = 3
                };
                //創建一個並發線程
                Parallel.For(0, 5, parallelOptions, x =>
                {
                    Console.WriteLine("限制執行的次數");
                });
            }).Wait();
            Console.WriteLine("**************************************");

            //Break  Stop  都不推薦用
            ParallelOptions parallelOptions = new ParallelOptions();
            parallelOptions.MaxDegreeOfParallelism = 3;
            Parallel.For(0, 40, parallelOptions, (i, state) =>
            {
                if (i == 20)
                {
                    Console.WriteLine("線程Break，Parallel結束");
                    state.Break();//結束Parallel
                                  //return;//必須帶上
                }
                if (i == 2)
                {
                    Console.WriteLine("線程Stop，當前任務結束");
                    state.Stop();//當前這次結束
                                 //return;//必須帶上
                }
                Console.WriteLine("我是線程i=" + i);
            });
        }

 五、多線程實例

　　1、代碼異常我信息大家都不陌生，比如我剛剛寫代碼經常會報 =>對象未定義null  的真的是讓我心痛了一地，那我們的多線程中怎么去處理代碼異常呢？ 和我們經常寫的同步方法不一樣，同步方法遇到錯誤會直接拋出，當是如果我們的多線程中出現代碼異常，那么這個異常會自動傳遞調用Wait 或者 Task<TResult> 的Result屬性上面。任務的異常會將自動捕獲並且拋給調用者，為了確保報告所有的異常，CLR會將異常封裝到AggregateExcepiton容器中，這容器是公開了InnerExceptions屬性中包含所有捕獲的異常，但是如果我們的線程沒有等待結束不會獲取到異常。

class Program
      {
         static void Main(string[] args)
         {
              try
             {
                  Task.Run(() =>
                  {
                      throw new Exception("錯誤");
                 }).Wait();
             }
             catch (AggregateException axe)
             {
                 foreach (var item in axe.InnerExceptions)
                 {
                     Console.WriteLine(item.Message);
                 }
            }
             Console.ReadKey();
         }
     }

 /// <summary>
        /// 多線程捕獲異常 
        /// 多線程會將我們的異常吞了，因為我們的線程執行會直接執行完代碼，不會去等待你捕獲到我的異常。
        /// 我們的線程中最好是不要出現異常，自己處理好。
        /// </summary>
        public static void Show()
        {
            //創建一個多線程工廠
            TaskFactory taskFactory = new TaskFactory();
            //創建一個多線程容器
            List<Task> tasks = new List<Task>();
            //創建委托
            Action action = () =>
            {
                try
                {
                    string str = "sad";
                    int num = int.Parse(str);
                }
                catch (AggregateException ax)
                {
                    Console.WriteLine("我是AggregateException 我抓到了異常啦 ax:" + ax);
                }
                catch (Exception)
                {
                    Console.WriteLine("我是線程我已經報錯了");
                }
            };
            //這個是我們經常需要做的捕獲異常
            try
            {
                //創建10個多線程
                for (int i = 0; i < 10; i++)
                {
                    tasks.Add(taskFactory.StartNew(action));
                }
                Task.WaitAll(tasks.ToArray());
            }
            catch (Exception ex)
            {
                Console.WriteLine("異常啦");
            }
            Console.WriteLine("我已經執行完了");
        }

　　2、多線程取消機制，我們的Task在外部無法進行暫停 Thread().Abort() 無法很好控制，上上篇中Thread我們也講到了Thread().Abort() 的不足之處。有問題就有解決方案。如果我們使用一個全局的變量控制，就需要不斷的監控我們的變量取消線程。那么說當然有對應的方法啦。CancellationTokenSource （取消標記源）我們可以創建一個取消標記源，我們在創建線程的時候傳入我們取消標記源Token。Cancel()方法 取消線程，IsCancellationRequested 返回一個bool值，判斷是不是取消了線程了。

 /// <summary>
        /// 多線程取消機制 我們的Task在外部無法進行暫停 Thread().Abort() 無法很好控制，我們的線程。
        /// 如果我們使用一個全局的變量控制，就需要不斷的監控我們的變量取消線程。
        /// 我們可以創建一個取消標記源，我們在創建線程的時候傳入我們取消標記源Token
        /// Cancel() 取消線程，IsCancellationRequested 返回一個bool值，判斷是不是取消了線程了
        /// </summary>
        public static void Show1()
        {
            //創建一個取消標記源
            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            //創建一個多線程工廠
            TaskFactory taskFactory = new TaskFactory();
            //創建一個多線程容器
            List<Task> tasks = new List<Task>();
            //創建委托
            Action<object> action = x =>
            {
                try
                {
                    //每個線程我等待2秒鍾，不然
                    Thread.Sleep(2000);
                    //判斷是不是取消線程了
                    if (cancellationTokenSource.IsCancellationRequested)
                    {
                        Console.WriteLine("放棄執行后面線程");
                        return;
                    }
                    if (Convert.ToUInt32(x) == 20)
                    {
                        throw new Exception(string.Format("{0} 執行失敗", x));
                    }
                    Console.WriteLine("我是正常的我在執行");
                }
                catch (AggregateException ax)
                {
                    Console.WriteLine("我是AggregateException 我抓到了異常啦 ax:" + ax);
                }
                catch (Exception ex)
                {
                    //異常出現取消后面執行的所有線程
                    cancellationTokenSource.Cancel();
                    Console.WriteLine("我是線程我已經報錯了");
                }
            };
            //這個是我們經常需要做的捕獲異常
            try
            {
                //創建10個多線程
                for (int i = 0; i < 50; i++)
                {
                    int k = i;
                    tasks.Add(taskFactory.StartNew(action, k, cancellationTokenSource.Token));
                }
                Task.WaitAll(tasks.ToArray());
            }
            catch (Exception ex)
            {
                Console.WriteLine("異常啦");
            }
            Console.WriteLine("我已經執行完了");
        }

　　3、多線程創建臨時變量，當我們啟動線程之后他們執行沒有先后快慢之分，正常的循環中的變量也沒有作用。這個時候就要創建一個臨時變量存儲信息，解決不訪問一個數據源。

 /// <summary>
        /// 線程臨時變量
        /// </summary>
        public static void Show2()
        {
            //創建一個線程工廠
            TaskFactory taskFactory = new TaskFactory();
            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            //創建一個委托
            Action<object> action = x =>
            {
                Console.WriteLine("傳入參數 x:" + x);
            };
            for (int i = 0; i < 20; i++)
            {
                //這最主要的就是會創建20個k的臨時變量
                int k = i;
                taskFactory.StartNew(action, k);
            }
            Console.ReadLine();
        }

 

 　　4、多線程鎖，之前我們有提到過我們的多線程可以同時公共資源，如果我們有個變量需要加一，但是和這個時候我們有10個線程同時操作這個會怎么樣呢？

        public static List<int> list = new List<int>();
        public static int count = 0;

        public static void Show3()
        {
            //創建線程容器
            List<Task> tasks = new List<Task>();
            for (int i = 0; i < 10000; i++)
            {
                //添加線程
                tasks.Add(Task.Run(() =>
                {
                        list.Add(i);
                        count++;
                }));
            }
            Task.WaitAll(tasks.ToArray());
            Console.WriteLine("list 行數:" + list.Count + " count 總數:" + count);
            Console.ReadLine();
        }

 我們上面的代碼本來是count++到10000，但是我們看到結果的時候，我們是不是傻了呀,怎么是不是說好的10000呢，其實的數據讓狗吃了？真的是小朋友有很多問號？？？？？？

 

　　5、那么我們要怎么去解決這個問題呢？方法還是有的今天我們要將到一個語法糖lock、它能做什么呢？它相當於一個代碼塊鎖，它主要鎖的是一個對象，當它鎖住對象的時候會當其他線程發生堵塞，因為當它鎖住代碼時候也是鎖住了對象的訪問鏈，是其他的線程不能訪問。必須等待對象訪問鏈被釋放之后才能被一個線程訪問。我們的使用lock鎖代碼塊的時候，盡量減少鎖入代碼塊范圍，因為我們鎖代碼之后會導致只有一個線程可以拿到數據，盡量只要必須使用lock的地方使用。

　　6、Lock使用要注意的地方

 　　　  1、lock只能鎖引用類型的對象.

　　　　2、不能鎖空對象null某一對象可以指向Null，但Null是不需要被釋放的。（請參考：認識全面的null）。

　　　　3、lock 盡量不要去鎖string 類型雖然它是引用類型，但是string是享元模式，字符串類型被CLR“暫留”
這意味着整個程序中任何給定字符串都只有一個實例，就是這同一個對象表示了所有運行的應用程序域的所有線程中的該文本。因此，只要在應用程序進程中的任何位置處具有相同內容的字符串上放置了鎖，就將鎖定應用程序中該字符串的所有實例。因此，最好鎖定不會被暫留的私有或受保護成員。

　　　　4、lock就避免鎖定public 類型或不受程序控制的對象。例如，如果該實例可以被公開訪問，則 lock(this) 可能會有問題，因為不受控制的代碼也可能會鎖定該對象。這可能導致死鎖，即兩個或更多個線程等待釋放同一對象。出於同樣的原因，鎖定公共數據類型（相比於對象）也可能導致問題。

 /// <summary>
        /// 創建一個靜態對象，主要是用於鎖代碼塊，如果是靜態的就會全局鎖，如果要鎖實例類，就不使用靜態就好了
        /// </summary>
        private readonly static object obj = new object();
        public static List<int> list = new List<int>();
        public static int count = 0;
        /// <summary>
        /// lock 多線程鎖
        /// 當我們的線程訪問同一個全局變量、同時訪問同一個局部變量、同一個文件夾，就會出現線程不安全
        /// 我們的使用lock鎖代碼塊的時候，盡量減少鎖入代碼塊范圍，因為我們鎖代碼之后會導致只有一個線程可以
        /// 訪問到我們代碼塊了
        /// </summary>
        public static void Show3()
        {
            //創建線程容器
            List<Task> tasks = new List<Task>();
            //鎖代碼
            for (int i = 0; i < 10000; i++)
            {
                //添加線程
                tasks.Add(Task.Run(() =>
                {
                    //鎖代碼
                    lock (obj)
                    {
                        //這個里面就只會出現一個線程訪問，資源。
                        list.Add(i);
                        count++;
                    }
                    //lock 是一個語法糖，就是下面的代碼
                    Monitor.Enter(obj);

                    Monitor.Exit(obj);
                }));
            }
            Task.WaitAll(tasks.ToArray());
            Console.WriteLine("list 行數:" + list.Count + " count 總數:" + count);
            Console.ReadLine();
        }

7、總結實例篇，雙色球實例。

　　1、雙色球：投注號碼由6個紅色球號碼和1個藍色球號碼組成。紅色球號碼從01--33中選擇（不重復）藍色球號碼從01--16中選擇（可以跟紅球重復），代碼我已經實現了大家可以下載源碼。只有自己多多倒騰才能讓自己的技術成長。 下一次我們async和await這兩個關鍵字下篇記錄