多線線程async與await關鍵字

建立線程

        //這裏面須要注意的是，建立Thread的實例以後，須要手動調用它的Start方法將其啓動。
        //可是對於Task來講，StartNew和Run的同時，既會建立新的線程，而且會當即啓動它。
        static void Main()
        {
            new Thread(Go).Start();  // .NET 1.0 開始就有的
            Task.Factory.StartNew(Go); // .NET 4.0 引入了 TPL
            Task.Run(new Action(Go)); // .NET 4.5 新增了一個Run的方法
            Console.ReadLine();
        }

        public static void Go()
        {
            Console.WriteLine("我是另外一個線程");
        }

線程池 

    //線程的建立是比較佔用資源的一件事情，.NET 爲咱們提供了線程池來幫助咱們建立和管理線程。
    //Task是默認會直接使用線程池，可是Thread不會。若是咱們不使用Task，又想用線程池的話，可使用ThreadPool類。
    class Program
    {
        static void Main()
        {
            Console.WriteLine("我是主線程：Thread Id {0}", Thread.CurrentThread.ManagedThreadId);
            ThreadPool.QueueUserWorkItem(Go);
            Console.ReadLine();
        }

        public static void Go(object data)
        {
            Console.WriteLine("我是另外一個線程:Thread Id {0}", Thread.CurrentThread.ManagedThreadId);
        }
    }

傳入參數

        static void Main()
        {
            new Thread(Go).Start("arg1"); // 沒有匿名委託以前，咱們只能這樣傳入一個object的參數

            new Thread(delegate()
            {  // 有了匿名委託以後...
                GoGoGo("arg1", "arg2", "arg3");
            });

            new Thread(() =>
            {  // 固然,還有 Lambada
                GoGoGo("arg1", "arg2", "arg3");
            }).Start();

            Task.Run(() =>
            {  // Task能這麼靈活，也是由於有了Lambda呀。
                GoGoGo("arg1", "arg2", "arg3");
            });
        }

        public static void Go(object name)
        {
            // TODO
        }

        public static void GoGoGo(string arg1, string arg2, string arg3)
        {
            // TODO
        }

 

返回值

        //Thead是不能返回值的，可是做爲更高級的Task固然要彌補一下這個功能。
        static void Main()
        {
            // GetDayOfThisWeek 運行在另一個線程中
            var dayName = Task.Run<string>(() => { return GetDayOfThisWeek(); });
            Console.WriteLine("今天是：{0}", dayName.Result);
            Console.ReadLine();
        }

        static string GetDayOfThisWeek()
        {
            return "星期一";
        }

鎖

    //加上鎖以後，被鎖住的代碼在同一個時間內只容許一個線程訪問，其它的線程會被阻塞，
    //只有等到這個鎖被釋放以後其它的線程才能執行被鎖住的代碼。
    class Program
    {
        private static bool _isDone = false;
        private static object _lock = new object();
        static void Main()
        {
            new Thread(Done).Start();
            new Thread(Done).Start();
            Console.ReadLine();
        }

        static void Done()
        {
            lock (_lock)
            {
                if (!_isDone)
                {
                    Console.WriteLine("Done"); // 猜猜這裏面會被執行幾回？
                    _isDone = true;
                }
            }
        }
    }

Semaphore 信號量

    //SemaphoreSlim 它能夠控制對某一段代碼或者對某個資源訪問的線程的數量，超過這個數量以後，其它的線程就得等待，
    //只有等如今有線程釋放了以後，下面的線程才能訪問。這個跟鎖有類似的功能，
    //只不過不是獨佔的，它容許必定數量的線程同時訪問。
    class Program
    {
        static SemaphoreSlim _sem = new SemaphoreSlim(3);    // 咱們限制能同時訪問的線程數量是3
        static void Main()
        {
            for (int i = 1; i <= 10; i++) new Thread(Enter).Start(i);
            Console.ReadLine();
        }

        static void Enter(object id)
        {
            Console.WriteLine(id + " 開始排隊...");
            _sem.Wait();
            Console.WriteLine(id + " 開始執行！");
            Thread.Sleep(1000 * (int)id);
            Console.WriteLine(id + " 執行完畢，離開！");
            _sem.Release();
        }
    }

異常處理

    class Program
    {
        public static void Main()
        {
            try
            {
                new Thread(Go).Start();
            }
            catch (Exception ex)
            {
                // 其它線程裏面的異常，咱們在主線程面是捕獲不到的。
                Console.WriteLine("Exception!");
            }
        }
        static void Go() { throw null; }
    }

 

    class Program
    {
        public static void Main()
        {
            try
            {
                var task = Task.Run(() => { Go(); });
                task.Wait();  // 在調用了這句話以後，主線程才能捕獲task裏面的異常

                // 對於有返回值的Task, 咱們接收了它的返回值就不須要再調用Wait方法了
                // GetName 裏面的異常咱們也能夠捕獲到
                var task2 = Task.Run(() => { return GetName(); });
                var name = task2.Result;
            }
            catch (Exception ex)
            {
                Console.WriteLine("Exception!");
            }
        }
        static void Go() { throw null; }
        static string GetName() { throw null; }
    }

一個小例子認識async & await

        static void Main(string[] args)
        {   
            // 這個方法實際上是多餘的, 原本能夠直接寫下面的方法
            // await GetName() 
            // 可是因爲控制檯的入口方法不支持async,全部咱們在入口方法裏面不能 用 await
            Console.WriteLine("主線程開始,線程線程Id :{0}", Thread.CurrentThread.ManagedThreadId);
            Test();
            Console.WriteLine("主線程結束,線程線程Id :{0}", Thread.CurrentThread.ManagedThreadId);
            Console.ReadLine();
        }

        static async Task Test()
        {
            // 方法打上async關鍵字，就能夠用await調用一樣打上async的方法
            // await 後面的方法將在另一個線程中執行
            Console.WriteLine("Test線程開始,線程線程Id :{0}", Thread.CurrentThread.ManagedThreadId);
            await GetName();
            Console.WriteLine("Test線程結束,線程線程Id :{0}", Thread.CurrentThread.ManagedThreadId);
        }

        static async Task GetName()
        {
            Console.WriteLine("GetName線程開始,線程線程Id :{0}", Thread.CurrentThread.ManagedThreadId);
            // Delay 方法來自於.net 4.5
            // 返回值前面加 async 以後，方法裏面就能夠用await了
            await Task.Delay(1000);
            Console.WriteLine("GetName線程結束,線程線程Id :{0}", Thread.CurrentThread.ManagedThreadId);
        }

只有async方法在調用前才能加await麼？

    //答案很明顯：await並非針對於async的方法，而是針對async方法所返回給咱們的Task，
    //這也是爲何全部的async方法都必須返回給咱們Task。因此咱們一樣能夠在Task前面也加上await關鍵字，
    //這樣作其實是告訴編譯器我須要等這個Task的返回值或者等這個Task執行完畢以後才能繼續往下走。
    class Program
    {
        static void Main()
        {
            Test();
            Console.WriteLine("程序結束!");
            Console.ReadLine();
        }

        static async void Test()
        {
            Task<string> task = Task.Run(() =>
            {
                Thread.Sleep(5000);
                return "Hello World";
            });
            string str = await task;  //5 秒以後纔會執行這裏
            Console.WriteLine(str);
        }
    }

不用await關鍵字，如何確認Task執行完畢了？

    class Program
    {
        static void Main()
        {
            var task = Task.Run(() =>
            {
                return GetName();
            });

            task.GetAwaiter().OnCompleted(() =>
            {
                // 2 秒以後纔會執行這裏
                var name = task.Result;
                Console.WriteLine("My name is: " + name);
            });

            Console.WriteLine("主線程執行完畢");
            Console.ReadLine();
        }

        static string GetName()
        {
            Console.WriteLine("另一個線程在獲取名稱");
            Thread.Sleep(2000);
            return "haha";
        }
    }

Task.GetAwaiter()和await Task 的區別？

• 加上await關鍵字以後，後面的代碼會被掛起等待，直到task執行完畢有返回值的時候纔會繼續向下執行，這一段時間主線程會處於掛起狀態。
• GetAwaiter方法會返回一個awaitable的對象（繼承了INotifyCompletion.OnCompleted方法）咱們只是傳遞了一個委託進去，等task完成了就會執行這個委託，可是並不會影響主線程，下面的代碼會當即執行。這也是爲何咱們結果裏面第一句話會是 「主線程執行完畢」！

Task如何讓主線程掛起等待？

    class Program
    {
        static void Main()
        {
            var task = Task.Run(() =>
            {
                return GetName();
            });

            var name = task.GetAwaiter().GetResult();
            Console.WriteLine("My name is:{0}", name);

            Console.WriteLine("主線程執行完畢");
            Console.ReadLine();
        }

        static string GetName()
        {
            Console.WriteLine("另一個線程在獲取名稱");
            Thread.Sleep(2000);
            return "haha";
        }
    }

await 實質是在調用awaitable對象的GetResult方法