C# 多線程編程及其幾種方式

引言：

進程（process）：應用程序的實例要使用的資源的集合。每個進程被賦予了一個虛擬地址空間，確保在一個進程中使用的代碼和數據無法由另一個進程訪問。

線程（thread）:程序中的一個執行流，每個線程都有自己的專有寄存器（棧指針、程序計數器等），但代碼區是共享的，及不同的線程可以執行相同的函數。

多線程編程優缺點，

優點：可以提高CPU利用率。

缺點：

1、線程越多占用內存越多；

2、多線程需要協調和管理，需要CPU時間跟蹤線程；

3、線程之間對共享資源會相互影響，必須解決競用共享資源問題；

4、線程太多會導致控制太復雜，可能造成很多BUG

一、用Thread類開啟線程

　　關鍵字：前台線程，后台線程，線程優先級，線程休眠，線程阻塞。

　　前台線程：主線程結束后，前台線程將繼續執行才結束。

　　后台線程：主線程結束后，后台線程不管有沒有完成也結束線程

class MultiThreadingApplication {
        static void Main(string[] args) {
            //Thread thread1 = new Thread(new ThreadStart(Test1));
            Thread thread1 = new Thread(Test1);//線程傳入無參數委托實例
            //Thread thread2 = new Thread(new ParameterizedThreadStart(Test2));//正常傳遞
            Thread thread2 = new Thread(Test2);//簡化傳遞
            thread1.Name = "線程1";
            thread1.IsBackground = true;//設為后台線程，主線成結束后台線程自動結束;前台線程在主線程結束后繼續執行才結束
            thread2.Name = "線程2";
            thread1.Start();
            thread2.Start("HelloWorld");
            Thread thread3 = new Thread(() =>
            {
                Console.WriteLine("線程3開始");
                Console.WriteLine("線程3阻塞5秒鍾");
                Thread.CurrentThread.Join(TimeSpan.FromSeconds(5));
                Console.WriteLine("{0}的執行方法",Thread.CurrentThread.Name);
                Console.WriteLine("線程3結束");
            });
            thread3.Name = "線程3";
            thread3.Priority = ThreadPriority.Highest;//線程優先級枚舉設定，此時最高，在線程池中會優先開始
            thread3.Start();
            Console.WriteLine("Main()主函數線程結束");
        }

        static void Test1() {
            Console.WriteLine("線程1開始");
            Console.WriteLine("線程1休眠2秒鍾");
            Thread.Sleep(2000);
            Console.WriteLine("{0}調用的無參數方法",Thread.CurrentThread.Name);
            Console.WriteLine(Thread.CurrentThread.Name+"結束");
        }

        static void Test2(object s) {
            Console.WriteLine("線程2開始");
            Console.WriteLine("{0}調用的有參數方法，方法的參數是：{1}", Thread.CurrentThread.Name, s);
            Console.WriteLine(Thread.CurrentThread.Name + "結束");
        }
    }  

 　　Thread Join()使用，在兩個線程調用之間使用，阻塞當前線程，直到另一個線程結束。將兩個交替的線程合並為順序執行的線程。

比如在主線程中調用后台子線程的方法Join()，直到后台子線程執行完畢，主線程才繼續執行。

 static void Main(string[] args)
        {
            Console.WriteLine("主線程開始");
            var t = new Thread(() =>
            {
                Console.WriteLine("后台子線程開始");
                Thread.Sleep(3000);
                Console.WriteLine("后台子線程");
                Console.WriteLine("后台子線程結束");
            });
            t.IsBackground = true;
            t.Start();
            t.Join();//等待后台子線程執行完成，才繼續執行主線程，主線程在這里被阻塞。
            //t.Join(TimeSpan.FromSeconds(5));
            //t.Join(5000);//主線程阻塞等待后台子線程執行5秒鍾，然后繼續執行主線程，5秒后不管后台子線程是否執行完成。
            //Thread.CurrentThread.Join();//死鎖情況，A線程和B線程為同一個線程，將一直阻塞。
            Console.WriteLine("主線程結束");
        }

 二、通過線程池類ThreadPool開啟線程

static void Main(string[] args)
        {
            Console.WriteLine("主線程開始");
            ThreadPool.QueueUserWorkItem(DownLoadFile);
            //使用ThreadPool線程池開啟一個線程
            ThreadPool.QueueUserWorkItem((p) =>
            {
                Console.WriteLine("是否線程池線程：{0}",Thread.CurrentThread.IsThreadPoolThread);
                Console.WriteLine("開啟了一個線程，線程ID：{0}",Thread.CurrentThread.ManagedThreadId);
            });
            Thread.Sleep(5000);
            Console.WriteLine("主線程結束");
        }

        static void DownLoadFile(object state)
        {
            Console.WriteLine("開始下載...    線程ID：" + Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(2000);
            Console.WriteLine("下載完成！");
        }

 三、Task或TaskFactory方式開啟，叫法不同了，任務並行編程

Task需要啟動任務執行，TaskFactory創建及開始執行

Task開啟的是后台線程

 static void Main(string[] args)
        {
            Console.WriteLine("主線程開始");
            //.net framework 4.0 TPL（Task Parallel Library, 簡稱TPL）任務並行庫方式，類似於線程處理方式，抽象級別更高
            //任務並行，一個或多個任務同時運行
            //系統資源的使用效率更高，可伸縮性更好
            //TPL提供了一組簡單豐富的 API，這些 API 支持等待、取消、繼續、可靠的異常處理、詳細狀態、自定義計划等功能。
            //降低多線程編碼和並行編程的復雜度，提升開發效率
            //使用Task開啟一個任務(其實也是一個線程)
            Task task = new Task(new Action(() =>
            {
                Console.WriteLine("是否線程池線程：{0}", Thread.CurrentThread.IsThreadPoolThread);
                Console.WriteLine("開啟了一個線程，線程ID：{0}", Thread.CurrentThread.ManagedThreadId);
            }));
            task.Start();

            Task.Factory.StartNew(() =>
            {
                Console.WriteLine("是否線程池線程：{0}", Thread.CurrentThread.IsThreadPoolThread);
                Console.WriteLine("開啟了一個線程，線程ID：{0}", Thread.CurrentThread.ManagedThreadId);
            });

            TaskFactory tf = new TaskFactory();
            tf.StartNew(() =>
            {
                Console.WriteLine("是否線程池線程：{0}", Thread.CurrentThread.IsThreadPoolThread);
                Console.WriteLine("開啟了一個線程，線程ID：{0}", Thread.CurrentThread.ManagedThreadId);
            });29 
            Thread.Sleep(2000);
            Console.WriteLine("主線程結束");
        }

 CancellationToken 傳入取消令牌，外部控制任務內部結束

 static void Main(string[] args)
        {
            Console.WriteLine("主線程開始");
            var cts = new CancellationTokenSource();
            var task = new Task<int>(()=> {
                return TaskAction("task", 10, cts.Token);
            });
            task.Start();
            Console.WriteLine(task.Status);
            cts.Cancel();
            Console.WriteLine(task.Status);
            task.Wait();
            Thread.Sleep(2000);
            Console.WriteLine(task.Status);
            Console.WriteLine("task結果：{0}",task.Result);
            Console.WriteLine("主線程結束");
        }

        static int TaskAction(string name, int seconds, CancellationToken token) {
            Console.WriteLine("Task:{0} is runing on Thread:{1}",name,Thread.CurrentThread.ManagedThreadId);
            for (int i = 0; i < seconds; i++)
            {
                Thread.Sleep(1000);
                if (token.IsCancellationRequested)
                {
                    Console.WriteLine("請求取消令牌產生作用");
                    return -1;
                }
            }
            return 42 * seconds;
        }

 創建任務集合及返回結果

static void Main(string[] args)
        {
            //Task<T>，Result等待任務調用完成得到結果，有Wait的作用
            var tasks = new List<Task<string>>() {
                Task.Factory.StartNew(()=> {
                    return "task1";
                }),
                Task.Factory.StartNew(()=> {
                    return "task2";
                }),
                Task.Factory.StartNew(()=> {
                    return "task3";
                }),
            };

            foreach (var task in tasks)
            {
                Console.WriteLine(task.Result);
            }
        }

異常捕獲

通過Catch捕獲Task的異常是AggregateException，一個被封裝的異常，需要通過InnerException訪問底層異常

推薦使用GetWaiter和GetResult方法訪問Task的結果，可以獲取到原始異常；

通過ContinueWith處理OnlyOnFaulted事件，捕獲的異常也是一個被封裝的異常，需要通過InnerException訪問底層異常

 static void Main(string[] args)
        {
            Console.WriteLine("主線程開始");
            Task<int> task = null;
            try
            {
                task = Task.Run(() => TaskExceptionAction("Task1", 2));
                var result = task.Result;
                Console.WriteLine(result);
            }
            catch (Exception e)
            {
                Console.WriteLine("Task 1 Exception,type:" + e.GetType() + ",Message:" + e.Message);
            }
            Console.WriteLine("==============================");
            try
            {
                task = Task.Run(() => TaskExceptionAction("Task2", 2));
                var result = task.GetAwaiter().GetResult();
                Console.WriteLine(result);
            }
            catch (Exception e)
            {
                Console.WriteLine("Task 2 Exception,type:" + e.GetType() + ",Message:" + e.Message);
            }

            var task3 = new Task<int>(() =>
            {
                return TaskExceptionAction("task3", 2);
            });
            var continueTask = Task.WhenAll(task3);
            continueTask.ContinueWith(t =>
            {
                Console.WriteLine("Task 3 Exception,type:" + t.Exception.GetType() + ",Message:" + t.Exception.Message);
            }, TaskContinuationOptions.OnlyOnFaulted);
            task3.Start();
            task3.Wait();
            Console.WriteLine("主線程結束");
        }

        static int TaskExceptionAction(string name, int seconds)
        {
            Console.WriteLine("任務：{0} 在線程：{1}上運行", name, Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(seconds * 1000);
            throw new Exception("Error");
        }

 多任務的串行化

 static void Main(string[] args)
        {
            Console.WriteLine("主線程開始");
            var queryTask = new Task<string>(() =>
            {
                Console.WriteLine("Start queryTask!");
                return "QueryResult";
            });
            var analyzeTask = queryTask.ContinueWith((queryResult) =>
            {
                Console.WriteLine("Start AnalyzeTask!");
                return "Analyzed Data:" + queryResult.Result;
            });
            var reportTask = analyzeTask.ContinueWith((analyzeResult) =>
            {
                Console.WriteLine("Start ReportTask!");
                return "Reporting Data:" + analyzeResult.Result;
            });
            queryTask.Start();
            Console.WriteLine(reportTask.Result);
            Console.WriteLine("主線程結束");
        }

 除非所有子任務（子任務的子任務）結束運行，否則創建任務（父任務）不會認為已經結束

父任務異常不會影響子任務執行

子任務異常不會影響父任務執行

 static void Main(string[] args)
        {
            Console.WriteLine("主線程開始");
            var parentTask = Task.Factory.StartNew(() =>
            {
                Console.WriteLine("創建一個父任務");
                var subTask = Task.Factory.StartNew(() =>
                {
                    Console.WriteLine("創建一個子任務");
                    throw new Exception("subTask Error");
                }, TaskCreationOptions.AttachedToParent);
                Console.WriteLine("父任務結束");
            });
            Thread.Sleep(5000);
            Console.WriteLine("主線程結束");
        }

 四、異步委托開啟多線程

//TODO

部分內容來自：https://www.cnblogs.com/tianqing/p/6970331.html