多线线程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方法