- 判断任务状态
- 再说父子任务
- 组合任务/延续任务
- 复杂的延续任务
- 并行(异步)处理任务
- 并行(同步)处理任务
- 并行任务的 Task.WhenAny
- 并行任务状态
- 循环中值变化问题
- 定时任务 TaskScheduler 类
上一篇,我们学习了任务的基础,学会多种方式场景任务和执行,异步获取返回结果等。上一篇讲述的知识比较多,这一篇只要是代码实践和示例操作。
判断任务状态
属性 | 说明 |
---|---|
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 task = new Task(() =>
{
// 非子任务
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 task = new Task(() =>
{
// 子任务
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()
的重载方法非常多,可以参考:https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.continuewith?view=netcore-3.1#--
这里我们使用的构造函数定义如下:
public Task ContinueWith(Action 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 task = new Task(() =>
{
// 子任务
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 tasks = new List();
for (int i = 0; i < 5; i++)
tasks.Add(Task.Run(() =>
{
Console.WriteLine($"任务开始执行");
}));
// public static Task WhenAll(IEnumerable 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> tasks = new List>();
for (int i = 0; i < 5; i++)
tasks.Add(Task.Run(() =>
{
Console.WriteLine($"任务开始执行");
return new Random().Next(0,10);
}));
Task 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);
- tasks 类型:Task[]
要执行的所有任务。
- millisecondsTimeout 任务:Int32
等待的毫秒数,-1 表示无限期等待。
- cancellationToken 类型:CancellationToken
等待任务完成期间要观察的 CancellationToken。
Task.WaitAll()
的示例如下:
static void Main()
{
List tasks = new List();
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.WhenAny()
和 Task.WhenAll()
使用上差不多,Task.WhenAll()
当所有任务都完成时,才算完成,而 Task.WhenAny()
只要其中一个任务完成,都算完成。
这一点可以参考上面的 父子任务。
参考使用示例如下:
static void Main()
{
List tasks = new List();
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 tasks = new List();
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
微软文档里面也有关于此问题的说明,请参考:
https://docs.microsoft.com/zh-cn/archive/blogs/ericlippert/closing-over-the-loop-variable-considered-harmful
由于 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 类
TaskScheduler 类:表示一个处理将任务排队到线程中的低级工作的对象。
网上大多数示例是 Wpf 、WinForm
的,微软文档也是很复杂的样子: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskscheduler?view=netcore-3.1#properties
貌似 TaskScheduler 主要对 SynchronizationContext
进行控制,也就是说是对 UI 起作用。
笔者不写 WPF 和 WinForm ,所以,这个东西,跳过。哈哈哈哈。