C#Task简单描述

一、Thread (System.Threading)

1.前台线程和后台线程

只要有一个前台线程在运行，应用程序的进程就在运行，直到所有前台线程完成其任务为止。
在默认情况下，用 Thread类创建的线程是前台线程。线程池中的线程总是后台线程。
在用 Thread类创建线程时，可以设置 IsBackground属性，以确定该线程是前台线程还是后台线程(默认为false)。

2.控制线程

调用 Thread对象的Start()方法，可以创建线程。但是，在调用Start()方法后，新线程仍不是处于 Running状态，而是处于 Unstarted状态。只要操作系统的线程调度器选择了要运行的线程，线程就会改为 Running状态。读取 Thread.ThreadState属性，就可以获得线程的当前状态。
使用 Thread.Sleep方法，会使线程处于 WaitSleepJoin状态，在经历Sleep()方法定义的时间段后，线程就会等待再次被唤醒。
要停止另一个线程，可以调用 Thread.Abort()方法。调用这个方法时，会在接到终止命令的线程中抛出一个 ThreadAbortException类型的异常。用一个处理程序捕获这个异常，线程可以在结束前完成一些清理工作。线程还可以在接收到调用 Thread.ResetAbort()方法的结果 ThreadAbortException异常后继续运行。如果线程没有重置终止，接收到终止请求的线程的状态就从 AbortRequested改为Aborted。
如果需要等待线程的结束，就可以调用 Thread.Join()方法。 Thread.Join()方法会停止当前线程并把它设置为 WaitSleepJoin状态，直到加入的线程完成为止。

3.线程池

ThreadPool类会在需要时增减池中线程的线程数，直到最大的线程数。池中的最大线程数是可配置的。在双核CPU中，默认设置为1023个工作线程和1000个IO线程。也可以指定在创建线程池时应立即启动的最小线程数，以及线程池中可用的最大线程数。
如果有更多的作业要处理，线程池中线程的个数也到了极限，最新的作业就要排队，且必须等待线程完成其任务。

二、Task （System.Threading.Tasks）

.NET 4 包含新名称空间 System.Threading.Tasks，它包含的类抽象出了线程功能。在后台使用ThreadPool。任务表示应完成的某个单元的工作。这个单元的工作可以在单独的线程中运行，也可以以同步方式启动一个任务，这需要等待主调线程。使用任务不仅可以获得一个抽象层，还可以对底层线程进行很多控制。
在安排需要完成的工作时，任务提供了非常大的灵活性。例如，可以定义连续的工作，在一个任务完成后该执行什么工作。这可以区分任务成功与否。另外，还可以在层次结构中安排任务。例如，父任务可以创建新的子任务。这可以创建一种依赖关系，这样，取消父任务，也会取消其子任务。

与Thread的区别
static void Main(string[] args)
{
    Console.WriteLine("Thread  Start !");
    for (int i = 0; i <= 5; i++)
    {
        new Thread(Dotaskfunction).Start("Thread" + i);
    }
    Console.WriteLine("Thread End !");

    Console.WriteLine("Task   Start !");
    for (int i = 0; i <= 5; i++)
    {
        new Task(Dotaskfunction, "Task" + i).Start();
    }
    Console.WriteLine("Task End !");
    Console.ReadLine();

}

public static void Dotaskfunction(object name)
{
    Console.WriteLine("{0} ThreadID: {1} ", name, Thread.CurrentThread.ManagedThreadId);
}
注：可以看到Thread方法每次的Thread Id都是不同的，而Task方法的Thread Id是重复出现的。线程的创建和销毁是一个开销比较大的操作，Task每次执行将不会立即创建一个新线程，而是到CLR线程池查看是否有空闲的线程，有的话就取一个线程处理这个请求，处理完请求后再把线程放回线程池，这个线程也不会立即撤销，而是设置为空闲状态，可供线程池再次调度，从而减少开销。

1.Delay

Thread.Sleep()是同步延迟，Task.Delay()是异步延迟。
Thread.Sleep()会阻塞线程，Task.Delay()不会。
Thread.Sleep()不能取消，Task.Delay()可以。
Task.Delay()实质创建一个运行给定时间的任务，Thread.Sleep()使当前线程休眠给定时间。
Task.Delay()在内部使用System.Threading.Timer,其分辨率约为15ms.
Task.Delay()和Thread.Sleep()最大的区别是Task.Delay()旨在异步运行，在同步代码中使用Task.Delay()是没有意义的；在异步代码中使用Thread.Sleep()是一个非常糟糕的主意。通常使用await关键字调用Task.Delay()。
Task.Delay()，async/await和CancellationTokenSource组合起来使用可以实现可控制的异步延迟。

2.ContinueWith

创建一个在目标 System.Threading.Tasks.Task 完成时接收调用方提供的状态信息并执行的延续任务。

等待任务完成，并得到任务结果

class Program
{
    static void WriteLine(object line)
    {
        Console.WriteLine(DateTime.Now.ToString("mm:ss.ffff") + " " + line);
    }

    static void Main(string[] args)
    {
        WriteLine("Task Test Start!");
        Task t1 = new Task(taskDo, "T1");
        Task<int> t2 = t1.ContinueWith(taskDoNext, "T2");
        Task<int> t3 = t2.ContinueWith(taskDoNext, "T3");
        t1.Start();   //启动任务1
        t3.Wait();    //等待任务3完成
        WriteLine(t2.Result);
        WriteLine("Task Test End!");
        Console.ReadKey();
    }

    static void taskDo(object doStr)
    {
        WriteLine("开始--" + doStr);
        Task.Delay(2000).Wait();   //Delay是异步的，不加Wait是无效的
        WriteLine("结束--" + doStr);
    }

    static int taskDoNext(Task t, object doStr)
    {
        WriteLine("开始--" + doStr);
        Task.Delay(2000).Wait();
        WriteLine("结束--" + doStr);
        return 5;
    }

}

Task.Delay会创建一个任务，增加线程的开销。而Task.Delay.Wait相对与Thread.Sleep，效果一样，但是增加了一个线程。所以正常情况下，如果真的是要阻塞线程，最好用Thread.Sleep。其实最好的是用async/await，后续会讲到。

3.Task[ ]

WaitAll (等待所有任务完成) WaitAny（等待任意一个完成）

static void Main(string[] args)
{
    WriteLine("Task Test Start!");
    Task[] tasks = new Task[3];
    for (int i = 0; i < tasks.Length; i++)
    {
        tasks[i] = new Task(taskDo, "T" + i);
    }
    for (int i = 0; i < tasks.Length; i++)
    {
        tasks[i].Start();
    }
    Task.WaitAll(tasks);
    WriteLine("Task Test End!");
    Console.ReadKey();
}

注：通过结果发现，WaitAll会阻止代码继续运行，需等待任务数组中的任务全部结束

WhenAny （创建一个任务，任务数组中任何一个完成时完成） WhenAll (任务数组全部完成时完成)

static void Main(string[] args)
{
    WriteLine("Task Test Start!");
    Task[] tasks = new Task[3];
    for (int i = 0; i < tasks.Length; i++)
    {
        tasks[i] = new Task(taskDo, "T" + i);
    }
    for (int i = 0; i < tasks.Length; i++)
    {
        tasks[i].Start();
    }
    Task.WhenAny(tasks).ContinueWith(taskDoNext, "Any");
    WriteLine("Task Test End!");
    Console.ReadKey();
}

注：通过结果发现，WhenAny没有阻止代码继续运行，会在任务数组中任何一个完成时完成并Continue一个任务

4.async和await

async和await需同时使用，单独使用async是没效果的，而单独使用await会报错。

（1） async

使用async修饰符可将方法、lambda表达式或匿名方法指定为异步。如果对方法或表达式使用此修饰符，则其称为异步方法。
异步方法同步运行，直至到达其第一个 await 表达式，此时会将方法挂起，直到等待的任务完成。
如果 async关键字修改的方法不包含 await 表达式或语句，则该方法将同步执行。

static void Main(string[] args)
{
    WriteLine("Task Test Start!");
    taskDo("async");
    WriteLine("Task Test End!");
    Console.ReadKey();
}

static async void taskDo(object doStr)
{
    WriteLine("开始--" + doStr);
    WriteLine("结束--" + doStr);
}

注：通过结果发现，没有用await时，async方法和不用async是一样的

（2） await

await运算符暂停对其所属的 async方法的求值，直到其操作数表示的异步操作完成。
异步操作完成后，await运算符将返回操作的结果（如果有）。
当 await运算符应用到表示已完成操作的操作数时，它将立即返回操作的结果，而不会暂停其所属的方法。
await运算符不会阻止计算异步方法的线程。
当 await运算符暂停其所属的异步方法时，控件将返回到方法的调用方。

static void Main(string[] args)
{
    WriteLine("Task Test Start!");
    taskDo("async");
    WriteLine("Task Test End!");
    Console.ReadKey();
}

static async void taskDo(object doStr)
{
    WriteLine("Sleep");
    Thread.Sleep(1000);
    WriteLine("开始--" + doStr);
    await Task.Delay(2000);
    WriteLine("结束--" + doStr);
}

注：通过结果发现，在遇到await之前都是同步运行的，到await时就变成异步运行了

static void Main(string[] args)
{
    WriteLine("Task Test Start!");
    taskDo("async");
    WriteLine("Task Test End!");
    Console.ReadKey();
}

static Task<int> task1()
{
    Task<int> t = Task.Factory.StartNew<int>(() => { return 5; });
    t.Wait();
    return t;
}

static async Task taskDo(object doStr)
{
    WriteLine("开始--" + doStr);
    int x = await task1();
    WriteLine(x);
    Thread.Sleep(1000);
    WriteLine("结束--" + doStr);
}

注：通过结果发现，当await的是一个已经完成的任务，并不会开启异步执行

static void Main(string[] args)
{
    WriteLine("Task Test Start!");
    taskDo("async");
    WriteLine("Task Test End!");
    Console.ReadKey();
}

static Task<int> task1()
{
    Task<int> t = Task.Factory.StartNew<int>(() => { return 5; });
    return t;
}

static async Task taskDo(object doStr)
{
    WriteLine("开始--" + doStr);
    int x = await task1();
    WriteLine(x);
    Thread.Sleep(1000);
    WriteLine("结束--" + doStr);
}

注：和上一例就减少了 t.Wait()这一行，就开启异步执行了

static void Main(string[] args)
{
    WriteLine("Task Test Start!");
    taskDo("async");
    WriteLine("Task Test End!");
    Console.ReadKey();
}

static async Task<int> task1()
{
    Task<int> t = Task.Factory.StartNew<int>(() => { return 5; });
    await t;
    return t.Result;
}

static async Task taskDo(object doStr)
{
    WriteLine("开始--" + doStr);
    int x = await task1();
    WriteLine(x);
    Thread.Sleep(1000);
    WriteLine("结束--" + doStr);
}

注： await只能加在非阻止api和开启新线程的前面

posted @ 2022-04-12 22:46 Bridgebug 阅读(326) 评论(0) 编辑收藏举报

刷新页面返回顶部

有人

有人住高楼，有人在深沟，有人光万丈，有人一身锈