08、C# Task的使用

Task

Task基础

Task在线程池的基础上进行了优化，并提供了更多的API。在FCL4.0中，如果我们要编写多线程程序，Task显然已经优于传统的方式。

若要等待单个任务完成，可以调用其 Task.Wait方法。 对方法的调用会 Wait阻止调用线程，直到单类实例执行完毕。

以下是一个简单的任务示例：

class Program {
    static void Main(string[] args) {
        Task task = new Task((() => {
            Thread.Sleep(3000);
        }));
        task.Start();
        task.ContinueWith((task1 => {
            Console.WriteLine("任务完成");
            Console.WriteLine("IsCanceled={0}\tIsCompleted={1}\tIsFaulted={2}", task1.IsCanceled, task1.IsCompleted, task1.IsFaulted);
        }));
        Console.ReadKey();
    }
}

ContinueWith是任务的串行，当任务完成后会执行ContinueWith中的代码。

Task的创建

Task的创建有很多种方式，主要分为带返回值和不带返回值的方式，这里会详细讲述。

不带返回值的方式

第一种创建方式

class Program {
    static void Main(string[] args) {
        Task task = new Task((() => {
            Thread.Sleep(3000);
            Console.WriteLine("Task Run Finish");
        }));
        task.Start();
        task.Wait(); // 或者Task.WaitAll(task);
        task.Dispose();
        Console.ReadKey();
    }
}

其中task.Wait()是等待当前Task执行完毕，而Task.WaitAll(...)可以用于等待所有任务执行完毕。

除此之外，构造函数还提供另外一种创建方式：

public Task (Action<object?> action, object? state);

其中action是要异步执行的操作委托，而state包含由 action 委托使用的数据的对象。

第二种创建方式

class Program {
    static void Main(string[] args) {
        Task task = Task.Run((() => {
            Thread.Sleep(3000);
            Console.WriteLine("Task Run Finish");
        }));
        Console.ReadKey();
    }
}

第三种创建方式

class Program {
    static void Main(string[] args) {
        Task task = Task.Factory.StartNew((() => {
            Thread.Sleep(3000);
            Console.WriteLine("Task Run Finish");
        }));
        Console.ReadKey();
    }
}

还可以将任务标记为长时间运行任务，此时任务不会使用线程池，而是在单独线程中运行。

class Program {
    static void Main(string[] args) {
        Task task = Task.Factory.StartNew(() => Thread.Sleep(3000), TaskCreationOptions.LongRunning);
        Console.ReadKey();
    }
}

在上述代码中，创建Task的格式如下所示：

public System.Threading.Tasks.Task StartNew (Action<object?> action, object? state);

其中action是要异步执行的操作委托，而state包含由 action 委托使用的数据的对象。

第四种创建方式

创建Task还可以使用async/await的方式来实现。

class Program {
    static void Main(string[] args) {
        AsyncFunction();
        Console.ReadKey();
    }

    async static void AsyncFunction() {
        await Task.Delay(3000);
        Console.WriteLine("Task Run Finish");
    }
}

带返回值的方式

第一种创建方式

class Program {
    static void Main(string[] args) {
        Task<int> task = new Task<int>((() => {
            Thread.Sleep(3000);
            Console.WriteLine("Task Run Finish");
            return 0;
        }));
        task.Start();
        int resulr = task.Result;
        Console.WriteLine("Task Result：" + resulr);
        Console.ReadKey();
    }
}

第二种创建方式

class Program {
    static void Main(string[] args) {
        Task<int> task = Task.Run((() => {
            Thread.Sleep(3000);
            Console.WriteLine("Task Run Finish");
            return 0;
        }));
        int resulr = task.Result;
        Console.WriteLine("Task Result：" + resulr);
        Console.ReadKey();
    }
}

第三种创建方式

class Program {
    static void Main(string[] args) {
        Task<int> task = Task.Factory.StartNew((() => {
            Thread.Sleep(3000);
            Console.WriteLine("Task Run Finish");
            return 0;
        }));
        Console.ReadKey();
    }
}

第四种创建方式

创建Task还可以使用async/await的方式来实现。

class Program {
    static void Main(string[] args) {
        Task<int> task = GetAsyncResult();
        int result = task.Result;  // 阻塞主线程
        task.Dispose();
        Console.WriteLine("结果是：" + result);
    }

    private async static Task<int> GetAsyncResult() {
        await Task.Delay(3000);
        Console.WriteLine("Task Run Finish");
        return 0;
    }
}

使用task.Result方式同步获取结果会阻塞主线程。如果想要返回异步的结果，则使用如下方式：

private static Task<int> GetAsyncResult() {
    Console.WriteLine("Task Run Finish");
    return Task.FromResult(0);
}

组合任务-ContinueWith

任务并行

下面是一个简单的实例，task1开启子线程执行异步操作，主线程处理其他的操作。

class Program {
    static void Main(string[] args) {
        Task<int> task1 = new Task<int>((() => {
            Console.WriteLine("使用Task执行异步操作.");
            int sum = 0;
            for (int i = 0; i < 100; i++) {
                sum += i;
            }
            return sum;
        }));
        task1.Start();
        Console.WriteLine("主线程执行其他操作");
        Task task2 = task1.ContinueWith((task => {
            Console.WriteLine("任务完成后的执行结果{0}", task.Result.ToString());
        }));
        task1.Wait();
        task2.Wait();
    }
}

输出结果如下：

主线程执行其他操作
使用Task执行异步操作.
任务完成后的执行结果4950

任务串行

创建四个任务，task1串行执行，task2和task3并行执行完毕后，task4串行执行。

class Program {
    static void Main(string[] args) {
        // Task1串行执行
        Task task1 = Task.Factory.StartNew((() => {
            Console.WriteLine("task1 Execute");
        }));
        // task2 和 task3并行执行
        Task task2 = task1.ContinueWith((task => {
            Console.WriteLine("task2 Execute");
        }));
        Task task3 = task1.ContinueWith((task => {
            Console.WriteLine("task3 Execute");
        }));
        Task.WaitAll(task2, task3);
        // task4 串行执行
        Task task4 = Task.Factory.StartNew((() => {
            Console.WriteLine("task4 Execute");
        }));
        task4.Wait();
    }
}

输出结果如下：

task1 Execute
task3 Execute
task2 Execute
task4 Execute

父子任务

在父子任务中，TaskCreationOptions指定用于控制任务的创建和执行的可选行为的标志。

AttachedToParent：指定将任务附加到任务层次结构中的某个父级。
DenyChildAttach：指定任何尝试作为附加的子任务执行(即，使用AttachedToParent选项创建)的子任务都无法附加到父任务，会改成作为分离的子任务执行。
HideScheduler：防止环境计划程序被视为已创建任务的当前计划程序。
LongRunning：指定任务将是长时间运行的，粗粒度的操作，涉及比细化的系统更少、更强大的组件。
None：指定应使用默认行为。
PreferFairness：提示TaskScheduler以一种尽可能公平的方式安排任务
RunContinuationsAsynchronously：强制异步执行添加到当前任务的延续任务。

简单的代码演示如下：

class Program {
    static void Main(string[] args) {
        Task<int> parentTask = new Task<int>(state => {
            Console.WriteLine(state);
            // 创建并启动子任务
            new Task((() => {
                Console.WriteLine("task1 Execute");
            }), TaskCreationOptions.AttachedToParent).Start();
            new Task((() => {
                Console.WriteLine("task2 Execute");
            }), TaskCreationOptions.AttachedToParent).Start();
            return 0;
        }, "父任务，所有子任务完成后才执行");
        // 任务完成后执行的操作
        parentTask.ContinueWith((task => {
            Console.WriteLine("Parent Task Finish");
        }));
        parentTask.Start();
        Console.ReadKey();
    }
}

输出结果如下：

父任务，所有子任务完成后才执行
task1 Execute
task2 Execute
Parent Task Finish

取消任务

class Program {
    static void Main(string[] args) {
        CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
        Task task = new Task((() => {
            for (int i = 0; i < 100; i++) {
                Thread.Sleep(1000);
                Console.WriteLine("Task Execute{0}", i);
            }
        }), cancellationTokenSource.Token);
        task.Start();
        // 取消任务的运行
        cancellationTokenSource.Cancel();
        Console.ReadKey();
    }
}

任务进度

使用IProgress实现异步编程的进程通知。

class Program {
    static void Main(string[] args) {
        Task task = displayProgress();
        task.Wait();
    }

    private static async Task displayProgress() {
        Progress<int> progress = new Progress<int>(percent => {
            Console.WriteLine("{0}%", percent);
        });
        await Task.Run((() => DoProcessing(progress)));
        Console.WriteLine("Finish");
    }

    private static void DoProcessing(IProgress<int> progress) {
        for (int i = 0; i < 100; i++) {
            Thread.Sleep(100);
            progress.Report(i);
        }
    }
}

输出结果：

0%
1%
2%
3%
......
Finish