上一篇，我们学习了任务的基础，学会多种方式场景任务和执行，异步获取返回结果等。上一篇讲述的知识比较多，这一篇只要是代码实践和示例操作。
| 属性 | 说明 |
|---|---|
| iscanceled | 获取此 task 实例是否由于被取消的原因而已完成执行。 |
| iscompleted | 获取一个值，它表示是否已完成任务。 |
| iscompletedsuccessfully | 了解任务是否运行到完成。 |
| isfaulted | 获取 task是否由于未经处理异常的原因而完成。 |
| status | 获取此任务的 taskstatus。 |
要检测一个任务是否出错(指任务因未经处理的异常而导致工作终止)，要使用 iscanceled 和 isfaulted 两个属性，只要任务抛出异常，isfaulted 为 true。但是取消任务本质是抛出 operationcancelexcetion 异常，不代表任务出错。
即使任务抛出了未经处理的异常，也算是完成了任务，因此 iscompleted 属性，会为 true。
示例如下：
代码有点多，不易观察，请复制到程序中运行。
我要评论 class program
{
static void main()
{
// 正常任务
task task1 = new task(() =>
{
});
task1.start();
thread.sleep(timespan.fromseconds(1));
getresult(task1.iscanceled, task1.isfaulted);
console.writeline("任务是否完成：" + task1.iscompleted);
console.writeline("-------------------");
// 异常任务
task task2 = new task(() =>
{
throw new exception();
});
task2.start();
thread.sleep(timespan.fromseconds(1));
getresult(task2.iscanceled, task2.isfaulted);
console.writeline("任务是否完成：" + task2.iscompleted);
console.writeline("-------------------");
thread.sleep(timespan.fromseconds(1));
cancellationtokensource cts = new cancellationtokensource();
// 取消任务
task task3 = new task(() =>
{
thread.sleep(timespan.fromseconds(3));
}, cts.token);
task3.start();
cts.cancel();
thread.sleep(timespan.fromseconds(1));
getresult(task3.iscanceled, task3.isfaulted);
console.writeline("任务是否完成：" + task3.iscompleted);
console.readkey();
}
public static void getresult(bool iscancel, bool isfault)
{
if (iscancel == false && isfault == false)
console.writeline("没有异常发生");
else if (iscancel == true)
console.writeline("任务被取消");
else
console.writeline("任务引发了未经处理的异常");
}
}
在上一篇文章中《c#多线程(13)：任务基础①》，我们学习了父子任务，父任务需要等待子任务完成后才算完成任务。
上一章只是给出示例，没有明确说明场景和实验结果，这里重新写一个示例来补充。
非父子任务：
外层任务不会等待内嵌的任务完成，直接完成或返回结果。
static void main()
{
//两个任务没有从属关系，是独立的
task<int> task = new task<int>(() =>
{
// 非子任务
task task1 = new task(() =>
{
thread.sleep(timespan.fromseconds(1));
for (int i = 0; i < 5; i++)
{
console.writeline(" 内层任务1");
thread.sleep(timespan.fromseconds(0.5));
}
});
task1.start();
return 666;
});
task.start();
console.writeline($"任务运算结果是：{task.result}");
console.writeline("\n-------------------\n");
console.readkey();
}
父子任务：
父任务等待子任务完成后，才能算完成任务，然后返回结果。
static void main()
{
// 父子任务
task<int> task = new task<int>(() =>
{
// 子任务
task task1 = new task(() =>
{
thread.sleep(timespan.fromseconds(1));
for (int i = 0; i < 5; i++)
{
console.writeline(" 内层任务1");
thread.sleep(timespan.fromseconds(0.5));
}
}, taskcreationoptions.attachedtoparent);
task1.start();
console.writeline("最外层任务");
return 666;
});
task.start();
console.writeline($"任务运算结果是：{task.result}");
console.writeline("\n-------------------\n");
console.readkey();
}
task.continuewith() 方法创建一个在 任务(task)实例 完成时异步执行的延续任务。
task.continuewith() 的重载方法非常多，可以参考：
这里我们使用的构造函数定义如下：
public task continuewith(action<task> continuationaction);
一个简单的示例：
task task = new task(() =>
{
console.writeline(" 第一个任务");
thread.sleep(timespan.fromseconds(2));
});
// 接下来第二个任务
task.continuewith(t =>
{
console.writeline($" 第二个任务}");
thread.sleep(timespan.fromseconds(2));
});
task.start();
一个任务(task) 是可以设置多个延续任务的，这些任务是并行的，例如：
static void main()
{
task task = new task(() =>
{
console.writeline(" 第一个任务");
thread.sleep(timespan.fromseconds(1));
});
// 任务①
task.continuewith(t =>
{
for (int i = 0; i < 5; i++)
{
console.writeline($" 任务① ");
thread.sleep(timespan.fromseconds(1));
}
});
// 任务②
task.continuewith(t =>
{
for (int i = 0; i < 5; i++)
{
console.writeline($" 任务②");
thread.sleep(timespan.fromseconds(1));
}
});
// 任务① 和 任务② 属于同级并行任务
task.start();
}
通过多次实现延续/组合任务，会实现强有力的任务流程。
经过上一小节，我们学习了 continuewith() 来延续任务，现在我们来学习更多的重载方法，实现更加复杂的延续。
continuewith() 重载方法很多，它们的参数都含有下面几种参数之一或多个。
continuationaction
类型：action 或 func
一个要执行的任务。
state
类型：object
给延续任务传递的参数。
cancellationtoken
类型：cancellationtoken
取消标记。
continuationoptions
类型：taskcontinuationoptions
控制延续任务的创建和特性。
scheduler
类型：taskscheduler
要与延续任务关联并用于其执行过程的 taskscheduler。
前面四个参数(类型)，在以往的文章中已经出现过，这里就不再赘述；taskscheduler 类型，这里先讲解，后面再说。
注意 taskcreationoptions 和 taskcontinuationoptions 的区别，在前一篇我们学习过 taskcreationoptions。这里来学习 taskcontinuationoptions 。
taskcontinuationoptions 可以在以下重载上使用：
continuewith(action, cancellationtoken, taskcontinuationoptions, taskscheduler)
continuewith(action>, taskcontinuationoptions
在延续中，这样使用是无效的：
task task = new task(() =>
{
console.writeline(" 第一个任务");
thread.sleep(timespan.fromseconds(1));
});
task.continuewith(t =>
{
for (int i = 0; i < 5; i++)
{
console.writeline($" 任务① ");
thread.sleep(timespan.fromseconds(1));
}
},taskcontinuationoptions.attachedtoparent);
因为 taskcontinuationoptions 需要有嵌套关系的父子任务，才能生效。
正确使用方法：
static void main()
{
// 父子任务
task<int> task = new task<int>(() =>
{
// 子任务
task task1 = new task(() =>
{
thread.sleep(timespan.fromseconds(1));
console.writeline(" 内层任务1");
thread.sleep(timespan.fromseconds(0.5));
}, taskcreationoptions.attachedtoparent);
task1.continuewith(t =>
{
thread.sleep(timespan.fromseconds(1));
console.writeline("内层延续任务，也属于子任务");
thread.sleep(timespan.fromseconds(0.5));
}, taskcontinuationoptions.attachedtoparent);
task1.start();
console.writeline("最外层任务");
return 666;
});
task.start();
console.writeline($"任务运算结果是：{task.result}");
console.writeline("\n-------------------\n");
console.readkey();
}
这里我们来学习 task.whenall() 方法的使用。
task.whenall() ：等待提供的所有 task 对象完成执行过程
使用示例如下：
static void main()
{
list<task> tasks = new list<task>();
for (int i = 0; i < 5; i++)
tasks.add(task.run(() =>
{
console.writeline($"任务开始执行");
}));
// public static task whenall(ienumerable<task> tasks);
// 相当于多个任务，生成一个任务
task taskone = task.whenall(tasks);
// 不需要等待的话就去除
taskone.wait();
console.readkey();
}
task taskone = task.whenall(tasks); 可以写成 task.whenall(tasks);，返回的 task 对象可以用来判断任务执行情况。
要注意，下面这样是无效的：
你可以修改上面的代码进行测试。
tasks.add(new task(() =>
{
console.writeline($"任务开始执行");
}));
我也不知道为啥 new task() 不行。。。
如果任务有返回值，则可以使用下面这种方法
static void main()
{
list<task<int>> tasks = new list<task<int>>();
for (int i = 0; i < 5; i++)
tasks.add(task.run<int>(() =>
{
console.writeline($"任务开始执行");
return new random().next(0,10);
}));
task<int[]> taskone = task.whenall(tasks);
foreach (var item in taskone.result)
console.writeline(item);
console.readkey();
}
task.waitall()：等待提供的所有 task 对象完成执行过程。
我们来看看 task.waitall() 其中一个重载方法的定义：
public static bool waitall (task[] tasks, int millisecondstimeout, cancellationtoken cancellationtoken);
要执行的所有任务。
等待的毫秒数，-1 表示无限期等待。
等待任务完成期间要观察的 cancellationtoken。
task.waitall() 的示例如下：
static void main()
{
list<task> tasks = new list<task>();
for (int i = 0; i < 5; i++)
tasks.add(task.run(() =>
{
console.writeline($"任务开始执行");
}));
task.waitall(tasks.toarray());
console.readkey();
}
task.waitall() 会让当前线程等待所有任务执行完毕。并且 task.waitall() 是没有泛型的，也么没有返回结果。
task.whenany() 和 task.whenall() 使用上差不多，task.whenall() 当所有任务都完成时，才算完成，而 task.whenany() 只要其中一个任务完成，都算完成。
这一点可以参考上面的 父子任务。
参考使用示例如下：
static void main()
{
list<task> tasks = new list<task>();
for (int i = 0; i < 5; i++)
tasks.add(task.run(() =>
{
thread.sleep(timespan.fromseconds(new random().next(0, 5)));
console.writeline(" 正在执行任务");
}));
task taskone = task.whenany(tasks);
taskone.wait(); // 任意一个任务完成，就可以解除等待
console.writeline("有任务已经完成了");
console.readkey();
}
当然，task.whenany() 也有泛型方法，可以返回结果。
task.status 属性可以获取任务的状态。其属性类型是一个 taskstatus 枚举，其定义如下：
| 枚举 | 值 | 说明 |
|---|---|---|
| canceled | 6 | 已经通过 cancellationtoken 取消任务。 |
| created | 0 | 该任务已初始化，但尚未被计划。 |
| faulted | 7 | 由于未处理异常的原因而完成的任务。 |
| rantocompletion | 5 | 已成功完成执行的任务。 |
| running | 3 | 该任务正在运行，但尚未完成。 |
| waitingforactivation | 1 | 该任务正在等待 .net framework 基础结构在内部将其激活并进行计划。 |
| waitingforchildrentocomplete | 4 | 该任务已完成执行，正在隐式等待附加的子任务完成。 |
| waitingtorun | 2 | 该任务已被计划执行，但尚未开始执行。 |
在使用并行任务时，task.status 的值，有一定规律：
如果有其中一个任务出现未经处理的异常，那么返回taskstatus.faulted；
如果所有任务都出现未经处理的异常，会返回 taskstatus. rantocompletion ；
如果其中一个任务被取消(即使出现未经处理的异常)，会返回 taskstaus.canceled；
请运行测试下面两个示例：
static void main()
{
for (int i = 0; i < 5; i++)
new thread(() =>
{
console.writeline($"i = {i}");
}).start();
console.readkey();
}
static void main()
{
list<task> tasks = new list<task>();
for (int i = 0; i < 5; i++)
tasks.add(task.run(() =>
{
console.writeline($"i = {i}");
}));
task taskone = task.whenall(tasks);
taskone.wait();
console.readkey();
}
你会发现，两个示例的结果并不是 1,2,3,4,5，而是 5,5,5,5,5。
这个问题称为 race condition(竞争条件)，可以参考维基百科：
https://en.wikipedia.org/wiki/race_condition
微软文档里面也有关于此问题的说明，请参考：
由于 i 在整个生命周期，内存都是在同一个位置，每个线程或任务对其值得使用，都是指向相同位置的。
这样就行了：
static void main()
{
for (int i = 0; i < 5; i++)
{
int tmp = i;
new thread(() =>
{
console.writeline($"i = {tmp}");
}).start();
}
console.readkey();
}
这样是无效的：
for (int i = 0; i < 5; i++)
new thread(() =>
{
int tmp = i;
console.writeline($"i = {tmp}");
}).start();
taskscheduler 类：表示一个处理将任务排队到线程中的低级工作的对象。
网上大多数示例是 wpf 、winform的，微软文档也是很复杂的样子：
貌似 taskscheduler 主要对 synchronizationcontext 进行控制，也就是说是对 ui 起作用。
笔者不写 wpf 和 winform ，所以，这个东西，跳过。哈哈哈哈。
如对本文有疑问， 点击进行留言回复！！
使用Visual Studio2019创建C#项目(窗体应用程序、控制台应用程序、Web应用程序)
C#实现获取本地内网(局域网)和外网(公网)IP地址的方法分析
网友评论