c task执行线程异步操作

合集下载

C#线程学习笔记七：Task详细用法

C#线程学习笔记七：Task详细⽤法⼀、Task类简介Task类是在.NET Framework 4.0中提供的新功能，主要⽤于异步操作的控制。

它⽐Thread和ThreadPool提供了更为强⼤的功能，并且更⽅便使⽤。

Task和Task<TResult>类：前者接收的是Action委托类型；后者接收的是Func<TResult>委托类型。

任务Task和线程Thread的区别：1、任务是架构在线程之上。

也就是说任务最终还是要抛给线程去执⾏，它们都是在同⼀命名空间System.Threading下。

2、任务跟线程并不是⼀对⼀的关系。

⽐如说开启10个任务并不⼀定会开启10个线程，因为使⽤Task开启新任务时，是从线程池中调⽤线程，这点与ThreadPool.QueueUserWorkItem类似。

⼆、Task的创建2.1创建⽅式1：调⽤构造函数class Program{static void Main(string[] args){#region⼯作者线程：使⽤任务实现异步ThreadPool.SetMaxThreads(1000, 1000);PrintMessage("Main thread start.");//调⽤构造函数创建Task对象Task<int> task = new Task<int>(n => AsyncMethod((int)n), 10);//启动任务task.Start();//等待任务完成task.Wait();Console.WriteLine("The method result is: " + task.Result);Console.ReadLine();#endregion}///<summary>///打印线程池信息///</summary>///<param name="data"></param>private static void PrintMessage(string data){//获得线程池中可⽤的⼯作者线程数量及I/O线程数量ThreadPool.GetAvailableThreads(out int workThreadNumber, out int ioThreadNumber);Console.WriteLine("{0}\n CurrentThreadId is:{1}\n CurrentThread is background:{2}\n WorkerThreadNumber is:{3}\n IOThreadNumbers is:{4}\n",data,Thread.CurrentThread.ManagedThreadId,Thread.CurrentThread.IsBackground.ToString(),workThreadNumber.ToString(),ioThreadNumber.ToString());}///<summary>///异步⽅法///</summary>///<param name="n"></param>///<returns></returns>private static int AsyncMethod(int n){Thread.Sleep(1000);PrintMessage("Asynchoronous method.");int sum = 0;for (int i = 1; i < n; i++){//运算溢出检查checked{sum += i;}}return sum;}}View Code2.2创建⽅式2：任务⼯⼚class Program{static void Main(string[] args){#region⼯作者线程：使⽤任务⼯⼚实现异步////⽆参⽆返回值//ThreadPool.SetMaxThreads(1000, 1000);//Task.Factory.StartNew(() => PrintMessage("Main thread."));//Console.Read();//有参有返回值ThreadPool.SetMaxThreads(1000, 1000);PrintMessage("Main thread start.");var task = Task.Factory.StartNew(n => AsyncMethod((int)n), 10);//等待任务完成task.Wait();Console.WriteLine("The method result is: " + task.Result);Console.ReadLine();#endregion}///<summary>///打印线程池信息///</summary>///<param name="data"></param>private static void PrintMessage(string data){//获得线程池中可⽤的⼯作者线程数量及I/O线程数量ThreadPool.GetAvailableThreads(out int workThreadNumber, out int ioThreadNumber);Console.WriteLine("{0}\n CurrentThreadId is:{1}\n CurrentThread is background:{2}\n WorkerThreadNumber is:{3}\n IOThreadNumbers is:{4}\n", data,Thread.CurrentThread.ManagedThreadId,Thread.CurrentThread.IsBackground.ToString(),workThreadNumber.ToString(),ioThreadNumber.ToString());}///<summary>///异步⽅法///</summary>///<param name="n"></param>///<returns></returns>private static int AsyncMethod(int n){Thread.Sleep(1000);PrintMessage("Asynchoronous method.");int sum = 0;for (int i = 1; i < n; i++){//运算溢出检查checked{sum += i;}}return sum;}}View Code2.3创建⽅式3：Run⽅法class Program{static void Main(string[] args){#region⼯作者线程：使⽤Task.Run实现异步ThreadPool.SetMaxThreads(1000, 1000);PrintMessage("Main thread start.");var task = Task.Run(() => AsyncMethod(10));//等待任务完成task.Wait();Console.WriteLine("The method result is: " + task.Result);Console.ReadLine();#endregion}///<summary>///打印线程池信息///</summary>///<param name="data"></param>private static void PrintMessage(string data){//获得线程池中可⽤的⼯作者线程数量及I/O线程数量ThreadPool.GetAvailableThreads(out int workThreadNumber, out int ioThreadNumber);Console.WriteLine("{0}\n CurrentThreadId is:{1}\n CurrentThread is background:{2}\n WorkerThreadNumber is:{3}\n IOThreadNumbers is:{4}\n", data,Thread.CurrentThread.ManagedThreadId,Thread.CurrentThread.IsBackground.ToString(),workThreadNumber.ToString(),ioThreadNumber.ToString());}///<summary>///异步⽅法///</summary>///<param name="n"></param>///<returns></returns>private static int AsyncMethod(int n){Thread.Sleep(1000);PrintMessage("Asynchoronous method.");int sum = 0;for (int i = 1; i < n; i++){//运算溢出检查checked{sum += i;}}return sum;}}View Code三、Task的简略⽣命周期可通过Status属性获取。

c语言同步异步处理

c语言同步异步处理英文回答：Synchronous and asynchronous processing are two different approaches to handling tasks in C programming.Synchronous processing refers to a method where tasks are executed one after another, in a sequential manner. In other words, the program waits for each task to complete before moving on to the next one. This can be useful when the order of execution is important, or when tasks depend on the results of previous tasks. However, synchronous processing can also be time-consuming, as the program has to wait for each task to finish before proceeding.On the other hand, asynchronous processing allows tasks to run concurrently, without waiting for each other to complete. This means that the program can initiate multiple tasks and continue with its execution without blocking. Asynchronous processing is often used when tasks can beexecuted independently and when the order of execution is not critical. It can improve efficiency and performance, especially in situations where there are long-running tasks or when tasks involve waiting for external resources.To implement synchronous processing in C, you can use functions that block until a task is completed, such as the sleep() function or blocking I/O operations. These functions pause the execution of the program until the task is finished.In contrast, asynchronous processing in C can be achieved by using non-blocking I/O operations or by implementing event-driven programming using libraries like libevent or libuv. These libraries allow you to handle multiple tasks concurrently by registering callbacks or event handlers for specific events.中文回答：同步和异步处理是C编程中处理任务的两种不同方法。

C#异步和多线程以及THREAD、THREADPOOL、TASK区别和使用方法

C#异步和多线程以及THREAD、THREADPOOL、TASK区别和使⽤⽅法本⽂的⽬的是为了让⼤家了解什么是异步？什么是多线程？如何实现多线程？对于当前C#当中三种实现多线程的⽅法如何实现和使⽤？什么情景下选⽤哪⼀技术更好？第⼀部分主要介绍在C#中异步（async/await）和多线程的区别，以及async/await使⽤⽅法。

第⼆部分主要介绍在C#多线程当中Thread、ThreadPool、Task区别和使⽤⽅法。

-------------------------------------------------------------------------------------------------------------------------async/await这⾥的异步只是⼀种编程模式，⼀个编程接⼝设计为异步的，⼤多数时候都是为了灵活地处理并发流程需求的，对于async/await⽤法请看以下代码：static void Main(string[] args){_ = Async1();Console.WriteLine("...............按任意键退出");Console.ReadKey();}static async Task Async1(){Console.WriteLine("异步开始");var r = await Async2();var x = await Async3(r);Console.WriteLine("结果是 {0}", r + x);}static async Task<int> Async2(){await Task.Delay(1000);//⼀种异步延迟⽅法return 100;}static async Task<int> Async3(int x){await Task.Delay(1000);return x % 7;}执⾏结果：使⽤async关键字修饰的⽅法为异步⽅法，async关键字要和await关键字⼀同使⽤才会⽣效。

C#多线程和异步（二）——Task和asyncawait详解

C#多线程和异步（⼆）——Task和asyncawait详解⼀、什么是异步同步和异步主要⽤于修饰⽅法。

当⼀个⽅法被调⽤时，调⽤者需要等待该⽅法执⾏完毕并返回才能继续执⾏，我们称这个⽅法是同步⽅法；当⼀个⽅法被调⽤时⽴即返回，并获取⼀个线程执⾏该⽅法内部的业务，调⽤者不⽤等待该⽅法执⾏完毕，我们称这个⽅法为异步⽅法。

异步的好处在于⾮阻塞(调⽤线程不会暂停执⾏去等待⼦线程完成)，因此我们把⼀些不需要⽴即使⽤结果、较耗时的任务设为异步执⾏，可以提⾼程序的运⾏效率。

net4.0在ThreadPool的基础上推出了Task类，微软极⼒推荐使⽤Task来执⾏异步任务，现在C#类库中的异步⽅法基本都⽤到了Task；net5.0推出了async/await，让异步编程更为⽅便。

本篇主要介绍Task、async/await相关的内容，其他异步操作的⽅式会在下⼀篇介绍。

⼆、Task介绍 Task是在ThreadPool的基础上推出的，我们简单了解下ThreadPool。

ThreadPool中有若⼲数量的线程，如果有任务需要处理时，会从线程池中获取⼀个空闲的线程来执⾏任务，任务执⾏完毕后线程不会销毁，⽽是被线程池回收以供后续任务使⽤。

当线程池中所有的线程都在忙碌时，⼜有新任务要处理时，线程池才会新建⼀个线程来处理该任务，如果线程数量达到设置的最⼤值，任务会排队，等待其他任务释放线程后再执⾏。

线程池能减少线程的创建，节省开销，看⼀个ThreadPool的栗⼦吧static void Main(string[] args){for (int i = 1; i <=10; i++){//ThreadPool执⾏任务ThreadPool.QueueUserWorkItem(new WaitCallback((obj) => {Console.WriteLine($"第{obj}个执⾏任务");}),i);}Console.ReadKey();} 上边的代码通过ThreadPool执⾏了10个任务，执⾏结果为： ThreadPool相对于Thread来说可以减少线程的创建，有效减⼩系统开销；但是ThreadPool不能控制线程的执⾏顺序，我们也不能获取线程池内线程取消/异常/完成的通知，即我们不能有效监控和控制线程池中的线程。

C语言异步编程详解

C语言异步编程详解异步编程是一种在计算机科学中常用的编程模式，它允许同时执行多个任务，提高程序的并发性和响应速度。

C语言作为一种通用的高级编程语言，也有自己的异步编程方式。

本文将详细介绍C语言中的异步编程方法和技巧。

一、异步编程的概念和优势异步编程是一种非阻塞式的编程模式，意味着程序在等待某个任务完成时不会被阻塞，而是会继续执行其他任务。

这种方式可以提高程序的效率和性能，特别适用于处理大量的IO操作和并发任务。

在传统的同步编程中，程序需要等待每个任务完成才能继续执行下一个任务，这样会导致程序的响应速度变慢。

而异步编程则能够在等待某个任务完成的同时，继续执行其他任务，从而提高了程序的并发性和响应速度。

二、C语言中的异步编程方法在C语言中，异步编程可以通过以下几种方法实现。

1. 回调函数（Callback）回调函数是一种常见的异步编程技术，它允许在某个任务完成后自动调用指定的函数。

在C语言中，可以通过注册回调函数的方式实现异步操作。

下面是一个简单的示例，演示了如何使用回调函数实现异步编程：```c#include <stdio.h>void asyncOperation(void (*callback)(void)) { // 模拟异步操作printf("正在执行异步操作...\n");// 模拟异步操作完成后的回调callback();}void callback() {printf("异步操作已完成\n");}int main() {asyncOperation(callback);// 执行其他任务printf("继续执行其他任务...\n");return 0;}```在上面的示例中，`asyncOperation`函数模拟了一个异步操作，在操作完成后调用了注册的回调函数`callback`。

通过这种方式，程序可以在等待异步操作完成时继续执行其他任务，而无需等待异步操作的完成。

c语言task用法

c语言task用法C语言中的task用法在C语言中，task通常用于管理并发执行的多个任务。

任务是独立执行的代码块，可以同时运行，但彼此之间没有相互干扰。

这种并发执行可以提高程序的效率和响应性。

要在C语言中使用task，你需要使用多线程库，如pthread库。

下面是一些你可以使用task的一般步骤：1. 导入头文件：在你的C程序中，首先需要导入pthread.h头文件。

这个头文件包含了创建和管理task所需的函数和数据类型。

2. 创建task：使用pthread_create函数来创建新的task。

这个函数接受四个参数：指向task标识符的指针、task属性、task函数的指针和传递给task函数的参数。

创建task后，它将在系统中运行并独立执行。

3. 定义task函数：你需要定义一个函数，作为task的入口点。

这个函数将在task启动后执行，并完成你需要并发执行的任务。

4. 等待task完成：你可以使用pthread_join函数等待task的完成。

这个函数将阻塞主线程，直到指定的task结束执行。

5. 终止task：你还可以使用pthread_cancel函数提前终止一个正在执行的task。

这个函数会发送一个信号给指定的task，以请求其提前终止执行。

除了以上提到的基本步骤外，你还可以使用其他pthread库提供的函数来管理和同步task之间的并发执行。

总结：在C语言中，使用task可以实现并发执行任务的能力。

通过使用pthread库，你可以创建、管理和同步多个task。

这样可以提高程序的效率和响应性。

记得始终遵守C语言的语法规范和良好的编码实践，以确保任务的正确执行。

C#多线程实现异步接口

C#多线程实现异步接⼝异步接⼝的声明我们已经了解到，如果⼀个⽅法是异步的，那么这个⽅法的返回值类型是Task<T>，那么接⼝中该如何规定异步⽅法呢？⼀样的，如果接⼝中的⽅法是异步的，那么规定⽅法的返回值类型是Task<T>即可，看下⾯的代码：interface ITest{/// <summary>/// ⽅法的返回类型是Task<T>/// </summary>/// <returns></returns>Task<string> GetAsync();}注意：⽅法的前⾯不能添加async标注。

因为从语法上来讲，接⼝只能定义⾏为，不能定义实现，如果标注为async，就属于实现了。

我们在⽅法前⾯标注async，看看是什么效果：我们看到，⽅法直接就报错了。

⽽接⼝的实现类中的⽅法可以标注为async，也可以不标注为async，看下⾯的代码：/// <summary>/// 定义接⼝/// </summary>interface ITest{/// <summary>/// ⽅法的返回类型是Task<T>/// </summary>/// <returns></returns>///不能标注为asyncTask<string> GetAsync();}public class Test : ITest{/// <summary>/// ⽅法不标注为async 返回⼀个Task<string>类型/// </summary>/// <returns></returns>//public Task<string> GetAsync()//{// return Task.Run<string>(() =>// {// return "2";// });//}/// <summary>/// ⽅法标注为async 直接返回⼀个string类型/// </summary>/// <returns></returns>public async Task<string> GetAsync(){return "3";}}到此这篇关于C#多线程实现异步接⼝的⽂章就介绍到这了。

c语言同步和异步

c语言同步和异步在编程领域中，同步和异步是很常见的概念。

这两个概念涉及到程序执行的方式和资源利用的方式。

了解这两个概念对于写出高效的程序以及优化程序性能至关重要。

本文将详细介绍C语言中的同步和异步，帮助读者理解并正确应用它们。

首先，我们来了解同步（Synchronous）编程。

同步编程在程序执行过程中，代码会顺序地执行，即每个操作都会等待前一个操作完成后再执行。

这意味着程序会按照顺序逐步执行，而不会并行执行。

当执行一个操作时，它会阻塞后续操作的执行，直到该操作完成并返回结果。

这种方式适用于简单的、线性的任务。

同步编程简单易懂，但对于大规模或者复杂的任务来说效率并不高。

例如，如果一个操作需要花费很长的时间才能完成，那么后续的操作就必须等待，导致程序执行的效率低下。

同时，如果一个操作发生错误或异常，整个程序可能会中断或进入无限等待状态。

为了解决同步编程的问题，我们引入了异步（Asynchronous）编程。

异步编程在执行过程中，代码会同时进行多个操作，而不会阻塞其他操作的执行。

相比于同步编程，异步编程能够更充分地利用计算资源，提高程序的执行效率。

在C语言中，使用异步编程的一种方式是利用回调函数（Callback Function）。

通过使用回调函数，我们可以在操作完成后异步地执行任务。

在执行一个需要等待时间的操作时，C语言会立即返回并继续执行后续的代码，而不会等待操作完成。

当操作完成后，系统会调用事先指定的回调函数，执行后续任务。

这样就实现了非阻塞的异步执行。

异步编程带来的一个挑战是对于程序流程的控制。

由于异步操作的执行顺序不确定，我们不能简单地通过顺序编写代码来控制程序的执行流程。

为了解决这个问题，我们可以使用事件驱动编程（Event-driven Programming）的方式。

通过定义事件处理函数，在某个异步操作完成时触发相应的事件，再执行相应的操作。

这样可以实现程序的灵活控制和协调。

异步编程在处理网络请求、文件读写、图形界面等场景中非常常见。

C#Task任务详解及其使用方式

C#Task任务详解及其使⽤⽅式C#多线程编程笔记(4.3)-Task任务中实现取消选项1.Task类介绍：Task 类的表⽰单个操作不返回⼀个值，通常以异步⽅式执⾏。

Task 对象是⼀个的中⼼思想基于任务的异步模式⾸次引⼊.NET Framework 4 中。

因为由执⾏⼯作 Task 对象通常以异步⽅式执⾏在线程池线程上⽽不是以同步⽅式在主应⽤程序线程，您可以使⽤ Status 属性，以及IsCanceled, ，IsCompleted, ，和 IsFaulted 属性，以确定任务的状态。

⼤多数情况下，lambda 表达式⽤于指定的任务是执⾏的⼯作。

对于返回值的操作，您使⽤ Task 类。

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

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

Task和Thread⼀样，位于System.Threading命名空间下!⼀、创建TaskTask 类还提供了构造函数对任务进⾏初始化，但的未计划的执⾏。

出于性能原因， Task.Run 或 TaskFactory.StartNew（⼯⼚创建）⽅法是⽤于创建和计划计算的任务的⾸选的机制，但对于创建和计划必须分开的⽅案，您可以使⽤的构造函数（new⼀个出来），然后调⽤ Task.Start ⽅法来计划任务，以在稍后某个时间执⾏。

//第⼀种创建⽅式，直接实例化：必须⼿动去Startvar task1 = new Task(() =>{//TODO you code});task1.Start（）；//第⼆种创建⽅式，⼯⼚创建，直接执⾏var task2 = Task.Factory.StartNew(() =>{//TODO you code});⼆、Task的简略⽣命周期：⽅法名说明Created表⽰默认初始化任务，但是“⼯⼚创建的”实例直接跳过。

c语言task 用法 -回复

c语言task 用法-回复标题：C语言Task用法详解：实现高效编程的利器引言：C语言作为一种高效、强大的编程语言，经常被用于开发底层应用，系统软件以及嵌入式系统。

其灵活性和效率使其成为广大开发者的首选。

而在C语言中，Task（任务）是管理和执行并发操作的重要工具。

本文将详细介绍C语言Task的用法，帮助读者深入了解并充分利用这一强大功能。

一、任务的概念与创建任务（Task）是指在多核或单核环境中，能够并发执行的代码片段。

在C语言中，任务可以通过创建线程或进程的方式实现。

在这两种方式中，线程更为常用和广泛，因此本文将主要关注于线程的概念和创建。

要创建一个线程，可以使用C语言提供的pthread库。

以下为创建一个线程的基本步骤：1. 引入pthread库的头文件：c#include <pthread.h>2. 定义线程函数：线程函数是需要并发执行的代码，可以定义为如下格式：cvoid* function_name(void* arg);3. 创建线程：在主函数中使用pthread_create函数来创建线程，创建时需要传入线程的标识符、线程属性和线程函数，具体如下：cint pthread_create(pthread_t* thread, const pthread_attr_t* attr, void* (*start_routine)(void*), void* arg);二、任务的同步与互斥在多任务并发执行时，往往存在共享数据的访问问题。

为了保证数据的正确性和一致性，需要采用同步和互斥的机制。

C语言通过信号量、互斥锁和条件变量等机制来实现任务的同步与互斥。

1. 信号量（Semaphore）：信号量是用来控制多个任务对共享资源的访问的一种机制。

C语言通过sem_init、sem_wait和sem_post等函数来实现信号量的创建、等待和释放。

2. 互斥锁（Mutex）：互斥锁是一种保护共享资源的机制，保证同一时间只能有一个任务对资源进行操作。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

c task执行线程异步操作在C#4.0之前需要执行一个复杂的异步操作时，只能使用CLR线程池技术来执行一个任务。

线程池执行异步任务时,不知道任务何时完成,以及任务的在任务完成后不能获取到返回值。

但是在C#4.0中引人了一个的任务（System.Threading.Tasks命名空间的类型）机制来解决异步操作完成时间和完成后返回值的问题。

1.使用Task类创建并执行简单任务通过使用Task的构造函数来创建任务，并调用Start方法来启动任务并执行异步操作。

创建任务时，必须传递一个Action或Action<Object>类型的委托回调方法，可以选择的传递任务执行时说需要的数据对象等。

Task类的构造函数如下：public Task(Action action);public Task(Action<object> action, object state);public Task(Action action, CancellationToken cancellationToken);public Task(Action action, TaskCreationOptions creationOptions);public Task(Action<object> action, object state, CancellationToken cancellationToken);public Task(Action<object> action, object state, TaskCreationOptions creationOptions);public Task(Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions);public Task(Action<object> action, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions);示例代码：1: static void Main(string[] args)2: {3: Console.WriteLine("主线程执行业务处理.");4: //创建任务5: Task task = new Task(() => {6: Console.WriteLine("使用System.Threading.Tasks.Task执行异步操作.");7: for (int i = 0; i < 10; i++)8: {9: Console.WriteLine(i);10: }11: });12: //启动任务,并安排到当前任务队列线程中执行任务(System.Threading.Tasks.TaskScheduler)13: task.Start();14: Console.WriteLine("主线程执行其他处理");15: //主线程挂起1000毫秒，等待任务的完成。

16: Thread.Sleep(1000);17: }任务调度结果：2.等待任务的完成并获取返回值使用任务执行异步操作时，最主要的是要后的任务完成时的返回值。

在任务类中有一个实例方法Wait（有许多重载版本）他能等待任务的完成，我们也可以通过Task类的派生类Task<TResult>创建一个异步任务，并指定任务完成时返回值的类型，这样可以通过Task<TResult>的实例对象获取到任务完成后的返回值。

创建一个异步任务并执行0到100求和操作返回最后的计算结果，示例代码：1: static void TaskWait() {2: //创建任务3: Task<int> task = newTask<int>(() =>4: {5: int sum = 0;6: Console.WriteLine("使用Task执行异步操作.");7: for (int i = 0; i < 100; i++)8: {9: sum+=i;10: }11: return sum;12: });13: //启动任务,并安排到当前任务队列线程中执行任务(System.Threading.Tasks.TaskScheduler)14: task.Start();15:16: Console.WriteLine("主线程执行其他处理");17: //等待任务的完成执行过程。

18: task.Wait();19: //获得任务的执行结果20: Console.WriteLine("任务执行结果：{0}", task.Result.ToString());21: }执行结果：Task类还有一些静态方法，WaitAll用于等待提供的所有System.Threading.Tasks.Task 对象完成执行过程和Wait用于等待提供的任一个System.Threading.Tasks.Task 对象完成执行过程，这两个方法都有一些重载版本。

//等待所有任务完成public static void WaitAll(params Task[] tasks);//等待任意一个任务完成public static int WaitAny(params Task[] tasks);3.使用ContinueWith方法在任务完成时启动一个新任务在使用能够Task类的Wait方法等待一个任务时或派生类的Result属性获得任务执行结果都有可能阻塞线程，为了解决这个问题可以使用ContinueWith方法，他能在一个任务完成时自动启动一个新的任务来处理执行结果。

示例代码：1: static void TaskContinueWith()2: {3: //创建一个任务4: Task<int> task = newTask<int>(() =>5: {6: int sum = 0;7: Console.WriteLine("使用Task执行异步操作.");8: for (int i = 0; i < 100; i++)9: {10: sum += i;11: }12: return sum;13: });14: //启动任务,并安排到当前任务队列线程中执行任务(System.Threading.Tasks.TaskScheduler)15: task.Start();16: Console.WriteLine("主线程执行其他处理");17: //任务完成时执行处理。

18: Task cwt = task.ContinueWith(t => { 19: Console.WriteLine("任务完成后的执行结果：{0}", t.Result.ToString());20: });21: Thread.Sleep(1000);22: }执行结果：上述示例中任务不是等待完成来显示执行结果，而是使用ContinueWith方法，它能够知道任务在什么时候完成并启动一个新的任务来执行任务完成后的处理。

ContinueWith方法具有一些重载版本，这些重载版本允许指定延续任务需要使用的数据、延续任务的工作方式（System.Threading.Tasks.TaskContinuationOptions的枚举值按位OR运行的结果）等。

4.创建父子任务和任务工厂的使用通过Task类创建的任务是顶级任务，可以通过使用TaskCreationOptions.AttachedToParent 标识把这些任务与创建他的任务相关联，所有子任务全部完成以后父任务才会结束操作。

示例如下：1: static void ParentChildTask() {2: Task<string[]> parent = newTask<string[]>(state => {3: Console.WriteLine(state);4: string[] result=new string[2];5: //创建并启动子任务6: new Task(() => { result[0]= "我是子任务1。

"; },TaskCreationOptions.AttachedToParent).Start();7: new Task(() => { result[1] = "我是子任务2。

"; },TaskCreationOptions.AttachedToParent).Start();8: return result;9: },"我是父任务，并在我的处理过程中创建多个子任务，所有子任务完成以后我才会结束执行。

"); 10: //任务处理完成后执行的操作11: parent.ContinueWith(t => {12: Array.ForEach(t.Result,r=>Console.WriteLine(r));13: });14: //启动父任务15: parent.Start();16: Console.Read();17: }执行结果：如果需要创建一组具有相同状态的任务时，可以使用TaskFactory类或TaskFactory<TResult>类。

这两个类创建一组任务时可以指定任务的CancellationToken、TaskCreationOptions、TaskContinuationOptions和TaskScheduler默认值。

示例代码:1: static void TaskFactoryApply()2: {3: Task parent = new Task(() =>4: {5: CancellationTokenSource cts = new CancellationTokenSource(5000);6: //创建任务工厂7: TaskFactory tf = new TaskFactory(cts.Token, TaskCreationOptions.AttachedToParent, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);8: //添加一组具有相同状态的子任务9: Task[] task = new Task[]{10: tf.StartNew(() =>{ Console.WriteLine("我是任务工厂里的第一个任务。