一.Task与Thread

• Task是架构在Thread之上的，也就是说任务最终还是要抛给线程去执行。
• Task跟Thread不是一对一的关系，比如开10个任务并不是说会开10个线程，这一点任务有点类似线程池，但是任务相比线程池有很小的开销和精确的控制。
• Task是用于表示一个异步操作的抽象。它是一种轻量级的、可等待的对象，允许你在不阻塞当前线程的情况下执行操作
• Task用途：可以用来处理各种耗时的操作，如文件I/O、网络请求、复杂的计算等，从而提高应用程序的响应性和性能。例如，在一个图形用户界面（GUI）应用程序中，使用Task来执行长时间的文件读取操作，这样在读取文件时，用户界面仍然可以响应用户的其他操作，如点击按钮、移动窗口等
• Task为后台程序，前台程序执行完毕后，软件即可结束

二.Task是使用方法：

创建Task，无返回值的创建方法,使用Task 创建以及使用Lambda表达式创建：有返回值的创建方法，Task支持泛型编程

//方法一：
Task b = new Task(()=> Console.WriteLine(  "Task 2" ));
b.start;
//方法二
Task.Run(() =>
{
    Console.WriteLine("Task1");
});
//方法三：
 TaskFactory taskFactory = new TaskFactory();
 taskFactory.StartNew(() => { Console.WriteLine("工厂模式创建"); });

//有返回值
Task<int> taskWithResult = Task.Run(() =>
{
    return 42; // 返回一个整数结果
});
Console.WriteLine(taskWithResult.Result);

执行结果，Task创建的为后台程序，当主线程为前台程序，当前台程序执行完毕，程序结束，后台程序会出现没有执行的情况：

Task1
工厂模式创建
Task 2
42

使用以下程序进行测试：

static void Main(string[] args)
{
  
    Task.Run(() =>
    {
        Console.WriteLine("Task1");
    });
    TaskFactory taskFactory = new TaskFactory();
    taskFactory.StartNew(() => { Console.WriteLine("工厂模式创建"); });
    ///Task a =new Task(program.GetTicket);
    Task b = new Task(()=> Console.WriteLine(  "Task 2" ));
    b.Start();
    Console.WriteLine( "main主程序" );
}

执行结果如下：

//执行结果1：
main主程序
Task1
工厂模式创建
Task 2

//执行结果2:
main主程序
工厂模式创建
Task1

为了解决这个问题,Task提供一系列API进行线程控制：

Task API	意义
Task.Result	获取Task的返回值
Task.ContinueWith	一个任务完成后执行
Task.Delay	异步延迟程序，不会阻碍主线程
Task.Wait	用与阻塞当前线程，直到指定任务完成，相当于Thread.Join（）
Task.WaitAll	等待列表中的任务全部完成,传递Array
Task.WaitAny	等待列表中的任一任务全部完成，传递Array
Task.WhenAll	等待列表中的任务都完成（异步），传递Array
Task.WhenAny	等待列表中的任一任务完成（异步），传递Array

通过程序逐步演示该API使用方法：

Task task1 = new Task(()=> Console.WriteLine("Task1"));
Task task2 = task1.ContinueWith(t =>                  //t和task1为同一任务
 {
   Console.WriteLine(t ==task1);
   Console.WriteLine("task2");
  });
  task1.Start();
 // task2.Start();//持续线程不可以使用start
  task1.Wait();   //阻塞主线程，Task线程完成后在进行执行
  task2.Wait();   //阻塞主线程，Task线程完成后在进行执行
  Console.WriteLine( "main线程" );

打印结果：

Task1
True
task2
main线程

• Continue with使用，参数t指的是上一个Task：

            Task<int> task1 = Task.Run(() =>
            {
                return 10086;
                Console.WriteLine("Task1 is Running"); } 
            );
            Task<int> task2 = task1.ContinueWith(t => { 
                return t.Result + 1;
                Console.WriteLine("Task2 is Running");
           
            });
            Task<int> task3 = task2.ContinueWith(t => {
                return t.Result + 1;
                Console.WriteLine("Task2 is Running");

            });
            Console.WriteLine( task3.Result  );
            Console.WriteLine( task1.Result );
            Console.WriteLine( task2.Result );

打印结果：

10088
10086
10087

三.async和await:

async执行一个异步方法，await执行一个异步任务，当程序遇见await会单独开一个控制流，不影响主线程的执行。

 static void Main(string[] args)
 {
     Console.WriteLine($"main方法Begins:线程ID:{Thread.CurrentThread.ManagedThreadId},是否在线程池{Thread.CurrentThread.IsThreadPoolThread}");
     RunAsync();
     Console.WriteLine($"main方法Ends:线程ID:{Thread.CurrentThread.ManagedThreadId},是否在线程池{Thread.CurrentThread.IsThreadPoolThread}");
     Console.ReadLine();
}

public static async void RunAsync() //异步方法必须使用async
{
    Console.WriteLine( $"RunAsync方法Begin:线程ID:{Thread.CurrentThread.ManagedThreadId},是否在线程池{Thread.CurrentThread.IsThreadPoolThread}" );

//await开启异步任务
    await Task.Run(() =>
    {
        Console.WriteLine($"Task方法Begin:线程ID:{Thread.CurrentThread.ManagedThreadId},是否在线程池{Thread.CurrentThread.IsThreadPoolThread}");

        long sum = 0;
        for (long i = 0; i < 10000000000; i++) {
            sum += i;
        };
        Console.WriteLine();
        Console.WriteLine($"Task方法End:线程ID:{Thread.CurrentThread.ManagedThreadId},是否在线程池{Thread.CurrentThread.IsThreadPoolThread}");

    });


    Console.WriteLine($"RunAsync方法End:线程ID:{Thread.CurrentThread.ManagedThreadId},是否在线程池{Thread.CurrentThread.IsThreadPoolThread}");

}

打印结果：

main方法Begins:线程ID:1,是否在线程池False
RunAsync方法Begin:线程ID:1,是否在线程池False
main方法Ends:线程ID:1,是否在线程池False
Task方法Begin:线程ID:3,是否在线程池True

Task方法End:线程ID:3,是否在线程池True
RunAsync方法End:线程ID:3,是否在线程池True

使用async和await执行有返回值的方法,异步任务的返回值类型默认为Task，await作用有两个，分流和获取任务返回值的功能，没有await关键字，则相当于同步方法：

 static void Main(string[] args)
 {
     Console.WriteLine($"main方法Begins:线程ID:{Thread.CurrentThread.ManagedThreadId},是否在线程池{Thread.CurrentThread.IsThreadPoolThread}");
     RunAsync();
     Console.WriteLine($"main方法Ends:线程ID:{Thread.CurrentThread.ManagedThreadId},是否在线程池{Thread.CurrentThread.IsThreadPoolThread}");
     Console.ReadLine();
}

public static async void RunAsync() 
{
    long result=await GetSumAsync(); //必须使用await，getsum是任务，异步分流
    Console.WriteLine($"计算结果是：{result}");
}
public static async Task<long> GetSumAsync()
{
    return await Task.Run(() =>
    {
        long sum = 0;
        for (long i = 0; i < 1000000000; i++)
        {
            sum += i;
        }

        return sum;         
    });           
}

打印结果：

main方法Begins:线程ID:1,是否在线程池False
main方法Ends:线程ID:1,是否在线程池False
计算结果是：499999999500000000