您的位置 首页 教育

C# Task类? 多线程学习2

上一篇文章(C# Thread类 – 多线程学习1)说过多线程之Thread 类,下面继续学习多线程的另一个更…

上一篇文章(C# Thread类 – 多线程学习1)说过多线程之Thread 类,下面继续学习多线程的另一个更重要的知识点:Task 类,如果有时间也建议看下上面的这篇文章,或许有用呐。

Thread线程是用来创建并发的一种低级别工具,它具有一些限制,尤其是:

  • 虽然开始线程的时候可以方便的传入数据,但是当join的时候很难从线程获得返回值。
  • 可能需要设置一些共享字段。
  • 如果操作抛出异常,铺货和传播该异常都很麻烦
  • 无法告诉线程在结束时开始另外的工作,你必须进行join操作(在进程中阻塞当前的线程)
  • 很难使用较小的并发(concurrent)来组件大型的并发

Task类可以很好的解决上述问题,它是一个高级抽象:它代表了一个并发操作(concurrent),该操作可能有Thread支持,或不由Thread支持。

  • Task是可组合的(可使用continuation把他们穿成链)。
  • Tasks可以使用线程池来减少启动延迟。
  • 使用TaskCompletionSource,Tasks可以利用回调的方式,在等待I/O绑定操作时完全避免使用线程。

Task建立多线程有多种方法,下面通过代码进行说明。代码可能有点长,但是把它分块就比较好理解的,因为是多种方法合并在一起进行介绍的,所以整个代码与输出结果比较长。

直接上代码,后面有对代码的解析:

using System;
using System.Threading; 
using System.Threading.Tasks;

namespace ch_Task
{
    class Program
    {
        static void CallTask2(string name)
        {
            Console.WriteLine($"taskID:{Task.CurrentId} beginning! ---name:" + name);
            for (int i = 1; i <= 5; i++)
            {
                Thread.Sleep(500);
                Console.WriteLine($"{i.ToString()} ---name:task2");
            }
            Console.WriteLine($"taskID:{Task.CurrentId} finished! ---name:" + name);
        }
        public static void CallTask3()
        {
            Console.WriteLine($"taskID:{Task.CurrentId} beginning! ---name:task3");
            for (int i = 1; i <= 5; i++)
            {
                Thread.Sleep(500);
                Console.WriteLine($"{i.ToString()} ---name:task3");
            }
            Console.WriteLine($"taskID:{Task.CurrentId} finished! ---name:task3");
        }
        public static void CallTask3Continue(Task t)
        {
            Console.WriteLine($"taskID:{Task.CurrentId} beginning! ---name:task3.continue");
            for (int i = 1; i <= 5; i++)
            {
                Thread.Sleep(500);
                Console.WriteLine($"{i.ToString()} ---name:task3.continue");
            }
            Console.WriteLine($"taskID:{Task.CurrentId} finished! ---name:task3.continue");
        }

        async static void task4()
        {
            Console.WriteLine($"taskID:{Task.CurrentId} beginning! ---name:task4");
            for (int i = 1; i<= 5; i++)
           {
              Console.WriteLine($"{i.ToString()} ---name:task4");
              await Task.Delay(500);
            }
            Console.WriteLine($"taskID:{Task.CurrentId} finished! ---name:task4");
        }

        static void Main(string[] args)
        {
            //-----------方式1-----------------
            Task task1 = new Task(() =>
            {
                Console.WriteLine($"taskID:{Task.CurrentId} beginning! ------name:task1");
                
                for(int i=1;i<=5;i++)
                {   
                    Thread.Sleep(500);
                    Console.WriteLine($"{i.ToString()} ---name:task1");
                }
                Console.WriteLine($"taskID:{Task.CurrentId} finished! ------name:task1");
            });
            task1.Start();

            // program execution after task1 finish
            task1.ContinueWith((task) =>
            {
                Console.WriteLine($"taskID:{task.Id}.continue begin and this task id is {Task.CurrentId}");
               
                for (int i = 1; i <= 5; i++)
                { 
                    Thread.Sleep(500);
                    Console.WriteLine($"{i.ToString()} ---name:task1.continue");
                }
                Console.WriteLine($"taskID:{Task.CurrentId} finished! ------name:task{task.Id}.continue");
            });

            //-------------方式2----------------
            var task2 = new Task(() => CallTask2("Task2"));
            task2.Start();

            //------------方式3------------
            Task task3 = new Task(CallTask3);
            task3.Start();
            Task task3Continue = task3.ContinueWith(CallTask3Continue);

            task3Continue.Wait(); // 阻塞主线程,直到task3Continue 线程执行结束
            //-------------方式4-------------
            task4();

            Console.ReadKey();
        }
    }
 }

输出结果为:

taskID:1 beginning! ------name:task1
taskID:3 beginning! ---name:Task2
taskID:4 beginning! ---name:task3
1 ---name:task1
1 ---name:task2
1 ---name:task3
2 ---name:task1
2 ---name:task2
2 ---name:task3
3 ---name:task1
3 ---name:task2
3 ---name:task3
4 ---name:task1
4 ---name:task3
4 ---name:task2
5 ---name:task1
taskID:1 finished! ------name:task1
taskID:1.continue begin and this task id is 2
5 ---name:task3
5 ---name:task2
taskID:4 finished! ---name:task3
taskID:3 finished! ---name:Task2
taskID:5 beginning! ---name:task3.continue
1 ---name:task1.continue
1 ---name:task3.continue
2 ---name:task1.continue
2 ---name:task3.continue
3 ---name:task3.continue
3 ---name:task1.continue
4 ---name:task3.continue
4 ---name:task1.continue
5 ---name:task3.continue
5 ---name:task1.continue
taskID:5 finished! ---name:task3.continue
taskID:2 finished! ------name:task1.continue
taskID: beginning! ---name:task4
1 ---name:task4
2 ---name:task4
3 ---name:task4
4 ---name:task4
5 ---name:task4
taskID: finished! ---name:task4

下面对输出结果进行分析:
直接看主函数部分,可以看到共有task1、task1.continue、task2、task3、task3.continue、task4六个子线程、分别用了四种方法:

task1 使用 : Task task1 = new Task(() =>{ } );直接去创建子线程。其实,这个运行的话可以简化即:
将下面代码:

Task task1 = new Task(() =>{ } );
task1.start()

换成 : Task.Run(() =>{ } ); 即可
task2 使用: var task2 = new Task(() => CallTask2("Task2")) 创建子线程。
task3 使用: Task task3 = new Task(CallTask3);直接创建子线程
task4 使用异步方法去创建子线程,关键词:async, 可以看到在task4之前,使用了task3Continue.Wait();  
这个语句可以用来阻塞主线程,直到task3Continue 线程执行结束后才会 task4线程的定义与运行。

另外,可以看到,在别的task使用延时用的都是 Thread.Sleep(500); 而使用异步方法创建的子线程在使用延时
的时候使用的是 await Task.Delay(500);这一点需要留意。
task1.continue 线程 即 task1.ContinueWith((task) => {})在task1 完全执行结束后才执行,
同理
task3.continue在task3 完全结束之后才执行。

Task.ContinueWith((task) => {})可以将子线程串联起来

本文来自网络,不代表0514资讯网立场,转载请注明出处:https://www.0514zx.com/info/6329.html
0514zx.com

作者: 0514zx.com

优质职场领域创作者
联系我们

联系我们

工作时间:周一至周五,9:00-17:30,节假日休息

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

关注微博
返回顶部