服务器之家：专注于VPS、云服务器配置技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - C# - C#多线程系列之任务基础(二)

C#多线程系列之任务基础(二)

2022-12-29 13:52痴者工良 C#

本文详细讲解了C#多线程的任务基础，文中通过示例代码介绍的非常详细。对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下

判断任务状态

属性 说明
IsCanceled 获取此 Task 实例是否由于被取消的原因而已完成执行。
IsCompleted 获取一个值，它表示是否已完成任务。
IsCompletedSuccessfully 了解任务是否运行到完成。
IsFaulted 获取 Task是否由于未经处理异常的原因而完成。
Status 获取此任务的 TaskStatus。

要检测一个任务是否出错(指任务因未经处理的异常而导致工作终止)，要使用 IsCanceled 和 IsFaulted 两个属性，只要任务抛出异常，IsFaulted 为 true。但是取消任务本质是抛出 OperationCancelExcetion 异常，不代表任务出错。

即使任务抛出了未经处理的异常，也算是完成了任务，因此 IsCompleted 属性，会为 true。

示例如下：

代码有点多，不易观察，请复制到程序中运行。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
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)：任务基础①》，我们学习了父子任务，父任务需要等待子任务完成后才算完成任务。

上一章只是给出示例，没有明确说明场景和实验结果，这里重新写一个示例来补充。

非父子任务：

外层任务不会等待内嵌的任务完成，直接完成或返回结果。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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();
    }

父子任务：

父任务等待子任务完成后，才能算完成任务，然后返回结果。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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() 的重载方法非常多，可以参考：https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.continuewith?view=netcore-3.1#--

这里我们使用的构造函数定义如下：

?
1
public Task ContinueWith(Action<Task> continuationAction);

一个简单的示例：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
Task task = new Task(() =>
{
    Console.WriteLine("     第一个任务");
    Thread.Sleep(TimeSpan.FromSeconds(2));
});
 
// 接下来第二个任务
task.ContinueWith(t =>
{
    Console.WriteLine($"     第二个任务}");
    Thread.Sleep(TimeSpan.FromSeconds(2));
});
task.Start();

C#多线程系列之任务基础(二)

一个任务(Task) 是可以设置多个延续任务的，这些任务是并行的，例如：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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();
    }

C#多线程系列之任务基础(二)

通过多次实现延续/组合任务，会实现强有力的任务流程。

复杂的延续任务

经过上一小节，我们学习了 ContinueWith() 来延续任务，现在我们来学习更多的重载方法，实现更加复杂的延续。

ContinueWith() 重载方法很多，它们的参数都含有下面几种参数之一或多个。

  • continuationAction

    类型：Action 或 Func

一个要执行的任务。

  • state

    类型：Object

给延续任务传递的参数。

  • cancellationToken

    类型：CancellationToken

取消标记。

  • continuationOptions

    类型：TaskContinuationOptions

控制延续任务的创建和特性。

  • scheduler

    类型：TaskScheduler

要与延续任务关联并用于其执行过程的 TaskScheduler。

前面四个参数(类型)，在以往的文章中已经出现过，这里就不再赘述；TaskScheduler 类型，这里先讲解，后面再说。

注意 TaskCreationOptions 和 TaskContinuationOptions 的区别，在前一篇我们学习过 TaskCreationOptions。这里来学习 TaskContinuationOptions 。

TaskContinuationOptions 可以在以下重载上使用：

?
1
ContinueWith(Action, CancellationToken, TaskContinuationOptions, TaskScheduler)
?
1
ContinueWith(Action>, TaskContinuationOptions

在延续中，这样使用是无效的：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
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 需要有嵌套关系的父子任务，才能生效。

正确使用方法：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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 对象完成执行过程

使用示例如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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 对象可以用来判断任务执行情况。

要注意，下面这样是无效的：

你可以修改上面的代码进行测试。

?
1
2
3
4
tasks.Add(new Task(() =>
{
    Console.WriteLine($"任务开始执行");
}));

我也不知道为啥 new Task() 不行。。。

如果任务有返回值，则可以使用下面这种方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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() 其中一个重载方法的定义：

?
1
public static bool WaitAll (Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken);
  • tasks 类型：Task[]

要执行的所有任务。

  • millisecondsTimeout 任务：Int32

等待的毫秒数，-1 表示无限期等待。

  • cancellationToken 类型：CancellationToken

等待任务完成期间要观察的 CancellationToken。

Task.WaitAll() 的示例如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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.WhenAny() 和 Task.WhenAll() 使用上差不多，Task.WhenAll() 当所有任务都完成时，才算完成，而 Task.WhenAny() 只要其中一个任务完成，都算完成。

这一点可以参考上面的 父子任务。

参考使用示例如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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；

循环中值变化问题

请运行测试下面两个示例：

?
1
2
3
4
5
6
7
8
9
10
static void Main()
{
    for (int i = 0; i < 5; i++)
        new Thread(() =>
        {
            Console.WriteLine($"i = {i}");
        }).Start();
 
    Console.ReadKey();
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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

微软文档里面也有关于此问题的说明，请参考：

https://docs.microsoft.com/zh-cn/archive/blogs/ericlippert/closing-over-the-loop-variable-considered-harmful

由于 i 在整个生命周期，内存都是在同一个位置，每个线程或任务对其值得使用，都是指向相同位置的。

这样就行了：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
static void Main()
{
    for (int i = 0; i < 5; i++)
    {
        int tmp = i;
        new Thread(() =>
        {
            Console.WriteLine($"i = {tmp}");
        }).Start();
    }
 
    Console.ReadKey();
}

这样是无效的：

?
1
2
3
4
5
6
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 起作用。

到此这篇关于C#多线程系列之任务基础(二)的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持服务器之家。

原文链接：https://www.cnblogs.com/whuanle/p/12797269.html

  • C#
  • 多线程
  • 任务

    • 延伸 · 阅读

    精彩推荐
    • C#C#通过重写Panel改变边框颜色与宽度的方法

      C#通过重写Panel改变边框颜色与宽度的方法

      这篇文章主要介绍了C#通过重写Panel改变边框颜色与宽度的方法,涉及C#针对Panel控件的重写与属性设置技巧,具有一定参考借鉴价值,需要的朋友可以参考下...

      我心依旧4482021-10-20
    • C#C#语言主要语言区域

      C#语言主要语言区域

      这篇文章主要介绍了C#语言主要语言区域，C#语言区域主要包括数组、集合和 LINQ、数组等，下面文化在哪个内容围绕这些区域得相关资料了展开详情，需要...

      Microsoft3312022-12-14
    • C#C#自定义基于控制台的Timer实例

      C#自定义基于控制台的Timer实例

      这篇文章主要介绍了C#自定义基于控制台的Timer实现方法,可以简单模拟timer控件的相关功能,具有一定参考借鉴价值,需要的朋友可以参考下...

      北风其凉9832021-10-19
    • C#区分c# 前台和后台线程

      区分c# 前台和后台线程

      这篇文章主要介绍了c# 前台线程和后台线程的区别与联系，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下...

      团队buff工具人7462022-09-23
    • C#C# 8.0中的范围类型(Range Type)示例详解

      C# 8.0中的范围类型(Range Type)示例详解

      这篇文章主要给大家介绍了关于C# 8.0中范围类型(Range Type)的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值...

      LamondLu4262022-03-06
    • C#C# Windows API应用之基于FlashWindowEx实现窗口闪烁的方法

      C# Windows API应用之基于FlashWindowEx实现窗口闪烁的方法

      这篇文章主要介绍了C# Windows API应用之基于FlashWindowEx实现窗口闪烁的方法,结合实例形式分析了Windows API函数FlashWindowEx的功能、定义及实现窗口闪烁的相关技...

      微wx笑11242021-12-03
    • C#C#实现简易计算器功能(1)(窗体应用)

      C#实现简易计算器功能(1)(窗体应用)

      这篇文章主要为大家详细介绍了C#实现简易计算器，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下...

      迎迎一笑9642022-12-24
    • C#unity实现场景跳转

      unity实现场景跳转

      这篇文章主要为大家详细介绍了unity实现场景跳转，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下...

      谁是你的宋冬野8052022-11-15
    最近更新
    编辑推荐
    阅读排行
    热门标签
    连续任务 　 osg 　 刷新桌面 　 nancy 　 TaskManager 　 网站授权 　 下拉式 　 DirectoryEntry 　 C#编程 　 网站功能 　 通知窗口 　 相互关系 　 语句顺序 　 编程错误 　 悬浮框 　 Dispose 　 滚动新闻 　 HttpPost 　 静态构造函数 　 焦点 　 类型派生 　 深度拷贝 　 小写转大写金额 　 任务并行库 　 众数 　 更新数据库 　 统计字数 　 二乘法 　 IComparer 　 DataBinding 　
    © 2019-2022 服务器之家(www.tuohang.net) 版权所有关于我们联系我们版权申明网站地图