C#学习笔记-多线程Task（任务）一

Task的定义

任务和线程的区别：
1、任务是架构在线程之上的，也就是说任务最终还是要抛给线程去执行。

2、任务跟线程不是一对一的关系，比如开10个任务并不是说会开10个线程，这一点任务有点类似线程池，但是任务相比线程池有很小的开销和精确的控制。

3、Task的优势
　　ThreadPool相比Thread来说具备了很多优势，但是ThreadPool却又存在一些使用上的不方便。比如：
　　◆ ThreadPool不支持线程的取消、完成、失败通知等交互性操作；
　　◆ ThreadPool不支持线程执行的先后次序；

详细介绍参考：https://blog.csdn.net/qq_41885871/article/details/83901318

Task(任务)相当于是Thread和ThreadPool的结合体，集合二者的有点，能够控制很小的资源开销和精确的控制。

Task的集中开启方式

1、类似于Thread开启的方式，直接创建（new）对象，编写相关的业务逻辑，通过对象的start方法启动

       public static void Test1()
        {
            Task task = new Task(() => {
                //业务逻辑
                Console.WriteLine("多线程ID:" + Thread.CurrentThread.ManagedThreadId);
            });
            task.Start();
        }

2、在创建对象时，通过调用Task的静态方法Run（）启动任务进程

      public static void Test3()
        {  
            for(int i = 0; i <= 10; i++)
            { 
            Task task = Task.Run(() => {

                //业务逻辑
                Console.WriteLine("多线程ID:" + Thread.CurrentThread.ManagedThreadId);
            });
                Thread.Sleep(200);
            }
        }

 3、创建对象时，通过以工厂的形式启动（Task.Factory.StartNew）

   public static void Test2()
        {
            Task task = Task.Factory.StartNew(() => {

                //业务逻辑
                Console.WriteLine("多线程ID:" + Thread.CurrentThread.ManagedThreadId);
            });
        }

方式2和方式3都会在创建对象时，直接启动线程，不需要向方式1那样子通过start（）方法启动。

Task的阻塞方式、延续

阻塞的三种方法：

wait（）：依次等待前面的任务执行完成

waitAll（）：等待所有的任务执行完成之后，才能执行后续的任务

waitAny（）：等待启动一个任务完成即可，执行后续的任务

        public static void Test6()
        {
            Task task1 = Task.Run(() =>
            {
                Thread.Sleep(100);
                Console.WriteLine("task1线程ID:" + Thread.CurrentThread.ManagedThreadId + "    " + "Time:" + DateTime.Now.ToString());
            });
            Task task2 = Task.Run(() =>
            {
                Thread.Sleep(5);
                Console.WriteLine("task2线程ID:" + Thread.CurrentThread.ManagedThreadId + "    " + "Time:" + DateTime.Now.ToString());
            });
            //挨个等待线程任务完成
            //task1.Wait();
            //task2.Wait();

            //等待所有线程任务完成后，执行后面的线程任务。
            // Task.WaitAll(task1, task2);

            //等待其中一个任务完成即可，执行其他线程任务
            Task.WaitAny(task1, task2);
            Console.WriteLine("主线程开始运行！Time=" + DateTime.Now.ToLongTimeString());
        }

延续

延续：whenAll和whenAny

whenAll：主线程任务不会等待启用了whenAll方法的线程执行完成，而是等待whenAll等待的任务对象全部执行完成，才会执行延续的子任务。

whenAny：主线程任务不会等待启用了whenAll方法的线程执行完成，而是等待whenAny等待的任务对象的其中一个执行完成，执行延续的子任务。

    public static void Test7()
        {
            Task task1 = Task.Run(() =>
            {
                Thread.Sleep(200);
                Console.WriteLine("task1线程ID:" + Thread.CurrentThread.ManagedThreadId + "    " + "Time:" + DateTime.Now.ToString());
            });
            Task task2 = Task.Run(() =>
            {
                Thread.Sleep(100);
                Console.WriteLine("task2线程ID:" + Thread.CurrentThread.ManagedThreadId + "    " + "Time:" + DateTime.Now.ToString());
            });
            //主线程不等待，子线程依次执行
            Task.WhenAll(task1, task2).ContinueWith(task3 => {
                //业务逻辑
                Console.WriteLine("task3线程ID:" + Thread.CurrentThread.ManagedThreadId + "    " + "Time:" + DateTime.Now.ToString());
            }); ;

            //主线程不等待，子线程任何一个完成即可去执行后续的任务。
            //Task.WhenAny(task1, task2).ContinueWith(task3=> {
            //    //业务逻辑
            //    Console.WriteLine("task3线程ID:" + Thread.CurrentThread.ManagedThreadId + "    " + "Time:" + DateTime.Now.ToString());
            //});
            Console.WriteLine("主线程开始运行！Time=" + DateTime.Now.ToLongTimeString());
        }