欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

C#多线程(14):任务基础②

程序员文章站 2022-05-18 18:29:28
[TOC] 上一篇,我们学习了任务的基础,学会多种方式场景任务和执行,异步获取返回结果等。上一篇讲述的知识比较多,这一篇只要是代码实践和示例操作。 判断任务状态 | 属性 | 说明 | | | | | IsCanceled | 获取此 Task 实例是否由于被取消的原因而已完成执行。 | | IsC ......

上一篇,我们学习了任务的基础,学会多种方式场景任务和执行,异步获取返回结果等。上一篇讲述的知识比较多,这一篇只要是代码实践和示例操作。

判断任务状态

属性 说明
iscanceled 获取此 task 实例是否由于被取消的原因而已完成执行。
iscompleted 获取一个值,它表示是否已完成任务。
iscompletedsuccessfully 了解任务是否运行到完成。
isfaulted 获取 task是否由于未经处理异常的原因而完成。
status 获取此任务的 taskstatus。

要检测一个任务是否出错(指任务因未经处理的异常而导致工作终止),要使用 iscanceledisfaulted 两个属性,只要任务抛出异常,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();

C#多线程(14):任务基础②

一个任务(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();
            }

C#多线程(14):任务基础②

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

复杂的延续任务

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

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

  • continuationaction

    类型:action 或 func

一个要执行的任务。

  • state

    类型:object

给延续任务传递的参数。

  • cancellationtoken

    类型:cancellationtoken

取消标记。

  • continuationoptions

    类型:taskcontinuationoptions

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

  • scheduler

    类型:taskscheduler

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

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

注意 taskcreationoptionstaskcontinuationoptions 的区别,在前一篇我们学习过 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();
        }

C#多线程(14):任务基础②

并行(异步)处理任务

这里我们来学习 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);
  • tasks 类型:task[]

要执行的所有任务。

  • millisecondstimeout 任务:int32

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

  • cancellationtoken 类型:cancellationtoken

等待任务完成期间要观察的 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.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 类

taskscheduler 类:表示一个处理将任务排队到线程中的低级工作的对象。

网上大多数示例是 wpf 、winform的,微软文档也是很复杂的样子:

貌似 taskscheduler 主要对 synchronizationcontext 进行控制,也就是说是对 ui 起作用。

笔者不写 wpf 和 winform ,所以,这个东西,跳过。哈哈哈哈。