C#中多线程Task详解

这篇具有很好参考价值的文章主要介绍了C#中多线程Task详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

C#中多线程Task详解

参考文章:

添加链接描述
添加链接描述
添加链接描述
添加链接描述
添加链接描述
添加链接描述
添加链接描述
添加链接描述
添加链接描述
添加链接描述
添加链接描述
添加链接描述

1.常用多线程创建方式比较

1.1Thread方式

缺点:频繁的创建和消耗比较好资源;提供操作线程的API不是马上响应(线程是操作系统统一管理,收到指令之后,具体还得操作系统真实处理,而操作系统收到指令之后并非马上执行相关指令);

1.2ThreadPool方式

优点:池化线程进行管理,需要使用就从池中获取就行,避免频繁创建和销毁线程;从而可以达到线程的复用;
缺点:提供的API太少,线程等待顺序控制比较弱;从而在一些业务情况下操作不方便;

1.3 Task方式

在ThreadPool的思想进行了封装,继承了ThreadPool的优点;提供了丰富的线程控制API,从而方便了开发;

1.4 Task方式介绍

Task可以简单看作相当于Thead+TheadPool,其性能比直接使用Thread要更好,在工作中更多的是使用Task来处理多线程任务
net4.0在ThreadPool的基础上推出了Task类,微软极力推荐使用Task来执行异步任务,现在C#类库中的异步方法基本都用到了Task;net5.0推出了async/await,让异步编程更为方便。

1.5 什么时候使用多线程

1.可以并发执行
例子:查询数据—可能查询接口、可能查询数据、可能查询缓存,开启3个线程,同时执行。大型项目中需要经常打开关闭数据库,且可能有多个界面同时调用数据库,会耗费大量时间。

例子:查询数据—查询一个结果后,需要使用这个结果作为条件,再进行下一次查询,还需要查询结果继续查询------不能使用多线程

例子:列表数据----可能来自数据库—可能来自缓存—可能来自第三方接口
传统方法:一个一个查询再去判断
多线程:同时启用3个线程查询,等待其中一个线程结束,判断是否找到结果,有一个找到结果,另外2个线程可以不用再管 //task.waitany //continuewhenany

2.Task创建任务的几种方式

2.1 Task task = new Task

		Task task = new Task(() =>
            {
                Console.WriteLine($"Task 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(2000);
            });
            //开启任务
            task.Start();

new方式实例化一个Task,需要通过Start方法启动

2.2 Task task1 = Task.Run最常用

Task task1 = Task.Run(() =>
   {
       Console.WriteLine($"Task 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
       Thread.Sleep(2000);
   });

Task.Run(Action action)将任务放在线程池队列,返回并启动一个Task

2.3 Task task2 = Task.Factory.StartNew 实例化工厂

//task静态属性获取Factory
Task task2 = Task.Factory.StartNew(() =>
    {
        Console.WriteLine($"Task 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
        Thread.Sleep(2000);
    }); 
//TaskFactory 工厂实例化,二者概念不一样
TaskFactory taskFactory1=new TaskFactory();
            taskFactory1.StartNew(() =>
            {
                Console.WriteLine($"Task 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(2000);
            });

Task.Factory.StartNew(Action action)创建和启动一个Task

2.4 Task有返回值的创建方式

有返回值的创建方式用法与上面3种常见的方式一样,代码示例如下:

static void Main(string[] args)
        {
            1.new方式实例化一个Task,需要通过Start方法启动
            Task<string> task = new Task<string>(() =>
            {
                return $"hello, task1的ID为{Thread.CurrentThread.ManagedThreadId}";
            });
            task.Start();

            2.Task.Factory.StartNew(Func func)创建和启动一个Task
            Task<string> task2 = Task.Factory.StartNew<string>(() =>
            {
                return $"hello, task2的ID为{Thread.CurrentThread.ManagedThreadId}";
            });

            3.Task.Run(Func func)将任务放在线程池队列,返回并启动一个Task
            Task<string> task3 = Task.Run<string>(() =>
            {
                return $"hello, task3的ID为{Thread.CurrentThread.ManagedThreadId}";
            });

            Console.WriteLine("执行主线程!");
            Console.WriteLine(task.Result);
            Console.WriteLine(task2.Result);
            Console.WriteLine(task3.Result);
            Console.ReadKey();
        }

task.Resut获取结果时会阻塞线程,即如果task没有执行完成,会等待task执行完成获取到Result,然后再执行后边的代码,程序运行结果如下:
c# task,服务器,运维

3.委托方式与lambda方式

线程创建好之后,需要用线程执行方法实现想要的功能,可通过委托的方式或labmda方式执行,上述task任务3种创建方式均为lambda,lambda方式与函数方式是一致的,以下多一个简单的对比。
lambda方式代码例子:

private static void ContinueWithTest()
        {
            Console.WriteLine("start");
            Task<string> task1 = new Task<string>(() =>
            {
                Console.WriteLine("task0");
                return "task1";
            });
            Task<string> task2 = task1.ContinueWith(t =>
            {
                //task1执行完后执行task2里面的逻辑,所以
                //一定能在该语句里面拿到task1的返回值即t.Result,且与主线程异步
                Console.WriteLine(t.Result);
                return "task2";
            });
            task1.Start();
            Console.WriteLine("end");
        }

委托方式调用函数代码例子:

private static void ContinueWithTest1()
        {
            Console.WriteLine("start");
              // Func<string> func = new Func<string>(DoTask1);

             //或Func<string> func=DoTask1
            // Task<string> task1 = new Task<string>(func);写成这样也是与下面要实现的功能一样

            Task<string> task1 = new Task<string>(DoTask1);
            Task<string> task2 = task1.ContinueWith(DoTask2);
            task1.Start();
            Console.WriteLine("end");
        }

        private static string DoTask1()
        {
            Console.WriteLine("task0");
            return "task1";
        }

        private static string DoTask2(Task<string> t)
        {
            Console.WriteLine(t.Result);
            return "task2";
        }

上述两种方式执行的结果是一致的

4.Task常用的API

当一个进程中出现多个线程时,线程执行的先后顺序常常是不规律的,例如执行完线程1,会紧接着执行线程6,而不是按顺序执行线程2,即整个执行过程会跳来跳去,这也导致当线程过多时,程序执行变得不可控,产生莫名其妙的BUG,加大了调试代码的难度,同时执行的最终结果可能会偏离预期。因此需要对线程加一些约束。
常用的API函数主要包括:实例方法.Wait()、实例方法.ContinueWith()、Task.WaitAll、Task.WaitAny、Task.Factory.ContinueWhenAll、Task.Factory.ContinueWhenAny等,以下分别对每种API函数详解。

Wait/WaitAny/WaitAll方法返回值为void,这些方法单纯的实现阻塞线程。现在想让所有task执行完毕(或者任一task执行完毕)后,开始执行后续操作,怎么实现呢?这时就可以用到WhenAny/WhenAll方法了,这些方法执行完成返回一个task实例。 task.WhenAll(Task[] tasks) 表示所有的task都执行完毕后再去执行后续的操作, task.WhenAny(Task[] tasks) 表示任一task执行完毕后就开始执行后续操作

先不采用约束,看一下线程执行的常规流程;

static void Main(string[] args)
        {
            Console.WriteLine($"主线程{Thread.CurrentThread.ManagedThreadId}开启");

            var task1 = Task.Run(() =>
            {
                Console.WriteLine($"Task1 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(10000);
            });

            var task2 = Task.Run(() =>
            {
                Console.WriteLine($"Task2 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(5000);
            });
            var task3 = Task.Run(() =>
            {
                Console.WriteLine($"Task3 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(500);
            });

            var task4 = Task.Run(() =>
            {
                Console.WriteLine($"Task4 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(2000);
            });

            Console.WriteLine($"主线程{Thread.CurrentThread.ManagedThreadId}完成");
            Console.ReadKey();
        }

第一次执行结果如下图1所示:
c# task,服务器,运维

第二次执行结果如下图2所示:
c# task,服务器,运维
“主线程1开启”、“主线程1完成”是并行执行的,task1、task2、task3、task4任务没有规律,如上图1、图2所示,两次执行的程序代码相同,但线程执行的先后顺序不一致,为了约束线程执行过程,采用API。

4.1 实例方法.wait()

.Wait() 等待执行调用任务完成,然后执行下一步; 即阻塞了主线程;
在常规流程中加入wait方法,如下:

static void Main(string[] args)
        {
            Console.WriteLine($"主线程{Thread.CurrentThread.ManagedThreadId}开启");

            var task1 = Task.Run(() =>
            {
                Console.WriteLine($"Task1 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(10000);
            });

            task1.Wait();

            var task2 = Task.Run(() =>
            {
                Console.WriteLine($"Task2 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(5000);
            });
            task2.Wait();

            var task3 = Task.Run(() =>
            {
                Console.WriteLine($"Task3 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(500);
            });

            task3.Wait();
            var task4 = Task.Run(() =>
            {
                Console.WriteLine($"Task4 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(2000);
            });

            task4.Wait();
            Console.WriteLine($"主线程{Thread.CurrentThread.ManagedThreadId}完成");
            Console.ReadLine();
        }

执行结果如下图3所示,此时线程按代码顺序执行,同时阻塞线程,任务1完成之后,执行任务2、任务3、任务4,异步线程变为同步线程,整个线程执行时间t=10000+5000+500+2000
c# task,服务器,运维

4.2 实例方法.ContinueWith()

ContinueWith() 等调用者结束之后才进行调用里面的相关业务,由线程池分配线程进行处理接下来的业务,不阻塞主线程,但却能控制业务之间的先后顺序;
常规流程中加入代码,如下所示:

static void Main(string[] args)
        {
            Console.WriteLine($"主线程{Thread.CurrentThread.ManagedThreadId}开启");

            var task1 = Task.Run(() =>
            {
                Console.WriteLine($"Task1 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(10000);
            });

            var task2 = Task.Run(() =>
            {
                Console.WriteLine($"Task2 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(5000);
            });
           
            var task3 = Task.Run(() =>
            {
                Console.WriteLine($"Task3 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(500);
            });

            task3.ContinueWith(t =>
            {
                Console.WriteLine($"Task3 后续执行{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(500);
            });

            var task4 = Task.Run(() =>
            {
                Console.WriteLine($"Task4 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(2);
            });
         
            Console.WriteLine($"主线程{Thread.CurrentThread.ManagedThreadId}完成");
            Console.ReadLine();
        }

执行结果如下所示,不论执行多少次,“Task3 后续执行”永远在“Task3 开启线程”之后,即等待“Task3 开启线程”完成之后,才会处理“Task3 后续执行”,并不会阻塞其他线程。
c# task,服务器,运维

4.3 静态方法,Task.WaitAll

Task.WaitAll等到所有任务都完成之后,才进行主线程的下一步操作,即阻塞主线程;
代码如下:

static void Main(string[] args)
        {
            Console.WriteLine($"主线程{Thread.CurrentThread.ManagedThreadId}开启");

            var task1 = Task.Run(() =>
            {
                Console.WriteLine($"Task1 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(10000);
            });

            var task2 = Task.Run(() =>
            {
                Console.WriteLine($"Task2 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(5000);
            });
           
            var task3 = Task.Run(() =>
            {
                Console.WriteLine($"Task3 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(500);
            });

            var task4 = Task.Run(() =>
            {
                Console.WriteLine($"Task4 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(2);
            });

            List<Task> list1 = new List<Task> { task1,task2,task3,task4};
            Task.WaitAll(list1.ToArray());
         
            Console.WriteLine($"主线程{Thread.CurrentThread.ManagedThreadId}完成");
            Console.ReadLine();
        }

执行结果如下图所示,主线程之前的task1、task2、、task3、、task4执行多次顺序会不同,即线程之间是无序的,但是等4个线程即所有任务都完成之后,才会执行“主线程1完成”。
c# task,服务器,运维

4.4 静态方法Task.WaitAny

同Task.WaitAll,等待任何一个任务完成就继续向下执行,将上面的代码WaitAll替换为WaitAny
即当task,task2,task3…N任意一个任务都执行完成之后就会往下执行代码,
task.WaitAny等到其中一个任务完成之后,才进行主线程的下一步操作,其中任务没有完成之前也阻塞主线程;

4.4 任务工厂Task.Factory.ContinueWhenAll

当ContinueWhenAll中所有任务都完成时执行回调方法,不阻塞主线程
代码如下:

static void Main(string[] args)
        {
            Console.WriteLine($"主线程{Thread.CurrentThread.ManagedThreadId}开启");

            var task1 = Task.Run(() =>
            {
                Console.WriteLine($"Task1 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(10000);
            });

            var task2 = Task.Run(() =>
            {
                Console.WriteLine($"Task2 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(5000);
            });
           
            var task3 = Task.Run(() =>
            {
                Console.WriteLine($"Task3 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(500);
            });

            var task4 = Task.Run(() =>
            {
                Console.WriteLine($"Task4 开启线程{Thread.CurrentThread.ManagedThreadId}处理业务");
                Thread.Sleep(2);
            });

            List<Task> list1 = new List<Task> {task1,task2,task3,task4};
            Task.Factory.ContinueWhenAll(list1.ToArray (),tasks =>
            {
                Console.WriteLine($"任务执行结束");
            });
         
            Console.WriteLine($"主线程{Thread.CurrentThread.ManagedThreadId}完成");
            Console.ReadLine();
        }

执行结果如下:
c# task,服务器,运维
不阻塞主线程, 当封装在所有list中的任务全部执行完成之后,再进行后续的处理,其中后续处理的业务的参数是上一完成任务的列表!!!

4.4 任务工厂Task.Factory.ContinueWhenAny

当参数中的任务有一个完成之后就进行回调,执行下一个任务。
Task.Factory.ContinueWhenAny方法等其中的任务有一项完成之后就立即返回,调用后续业务,不阻塞主线程
实际开发中建议使用ContinueWhenAny、ContinueWhenAll 不阻塞线程,尤其是在UI界面开发中

4.5 Thread.Sleep与Task.Delay的区别

这两个函数,实际工程中也经常用到,都表示延期执行某个功能,但是 Thread.Sleep在延期时间内会阻塞主线程,例如: Thread.Sleep(5000),在UI界面中会卡顿界面5秒,界面无法执行其他操作,原因是Thread属性IsBackground默认为前台线程,Task.Delay(5000)延时期间不会阻塞主线程

5.Task任务取消

线程在执行过程中难免会出错,或者执行相当长一段时间仍未执行完成,这就需要取消线程。
如下例子:首页包含很多信息,数据来自不同渠道,多块信息展示
传统方法:主线程一个一个查询,然后返回
多线程:开启多个线程同时查询,等待所有结果返回 //task.waitall //continuewhenall
如果一个模块的信息获取失败,必须重新获取,数据不能使用,另外获取数据的几个线程还在执行,则另外几个线程是否还有必要执行?需要做线程的取消

1.线程不能从外部取消,只能自己取消自己(对外抛出异常)
2.定义信号量,如果有线程执行出错,通知信号量,如果信号量被改变,则直接取消自己
3.定义布尔变量做信号量,不推荐
4.标准实现:CancellationTokenSource

C# 使用 CancellationTokenSource 终止线程,取消线程不是影响线程内部的执行(线程内部的执行根据系统内存资源自动分配),而是外部对Task的控制,如取消、定时取消。

5.1 任务取消常见方式

如下代码:

class Program
     { 

        static CancellationTokenSource cancelTokenSource = new CancellationTokenSource();

        static void Main(string[] args)
        {
            Task.Factory.StartNew(MyTask, cancelTokenSource.Token);

            Console.WriteLine("请按回车键(Enter)停止");
            Console.ReadLine();

            cancelTokenSource.Cancel();

            Console.WriteLine("已停止");
            Console.ReadLine();
        }

        static void MyTask()
        {
            //判断是否取消任务
            while (!cancelTokenSource.IsCancellationRequested)
            {
                Console.WriteLine(DateTime.Now);
                Thread.Sleep(1000);
            }
        }
    }

执行结果如下图所示,当线程未取消,即未按下“ENTER”键,线程执行委托方法MyTask,代码cancelTokenSource.Cancel();及后面的代码是不会执行的,当按下“enter”键,才会执行后面的代码。
c# task,服务器,运维

5.2 延时取消

也可以使用定时取消的方式,当任务超过了我们设定的时间,取消任务

var cancelTokenSource = new CancellationTokenSource(3000);

或者采用如下代码方式:source.CancelAfter(5000);

static void Main(string[] args)
        {
            CancellationTokenSource source = new CancellationTokenSource();
            //注册任务取消的事件
            source.Token.Register(() =>
            {
                Console.WriteLine("任务被取消后执行xx操作!");
            });

            int index = 0;
            //开启一个task执行任务
            Task task1 = new Task(() =>
              {
                  while (!source.IsCancellationRequested)
                  {
                      Thread.Sleep(1000);
                      Console.WriteLine($"第{++index}次执行,线程运行中...");
                  }
              });
            task1.Start();
            //延时取消,效果等同于Thread.Sleep(5000);source.Cancel();
            source.CancelAfter(5000);
            Console.ReadKey();
        }

5.3 任务取消触发回调函数

如前所述在Task的API函数中,当线程执行完毕后,可以调用Continuewith等做某一线程执行完成的后续处理工作,任务取消也可触发此类回调函数。对应方法:source.Token.Register(Action action)注册取消任务触发的回调函数,即当某一任务被取消时,通过Register执行任务取消的后续操作。代码例子如5.2延时取消。

5.4 多个任务共同取消

多个任务共同取消,在有多个CancellationTokenSource需要一起并行管理的时候,比如任意一个任务取消 则取消所有任务。我们不必去一个一个的去关闭,只需要将需要一起并行关闭的CancellationTokenSource组合起来就行了
代码如下:

class Program
    {
        //声明CancellationTokenSource对象
        static CancellationTokenSource c1 = new CancellationTokenSource();
        static CancellationTokenSource c2 = new CancellationTokenSource();
        static CancellationTokenSource c3 = new CancellationTokenSource();

        //使用多个CancellationTokenSource进行复合管理
        static CancellationTokenSource compositeCancel = CancellationTokenSource.CreateLinkedTokenSource(c1.Token, c2.Token, c3.Token);

        //程序入口
        static void Main(string[] args)
        {
            Task.Factory.StartNew(MyTask, compositeCancel.Token);

            Console.WriteLine("请按回车键(Enter)停止");
            Console.ReadLine();

            //任意一个 CancellationTokenSource 取消任务,那么所有任务都会被取消。
            c1.Cancel();

            Console.WriteLine("已停止");
            Console.ReadLine();
        }

        //测试方法
        static void MyTask()
        {
            //判断是否取消任务
            while (!compositeCancel.IsCancellationRequested)
            {
                Console.WriteLine(DateTime.Now);
                Thread.Sleep(1000);
            }
        }
    }

6.线程同步、异步

6.1 线程同步

常见例子:我们吃饭用手机点菜的时候,多个人同时点菜,在最后结账的时候,如果大家都争着买单,那如果没有同步信息,就会造成多个人都买单成功。这就是线程同步的问题之一。

所谓的同步,即按照代码的顺序执行,也就是用同一个线程来执行所有的操作,或者多个线程按顺序执行,例如***4.1 实例方法.wait()***中的部分,多个线程按顺序执行。
有序性:主要针对程序的执行顺序来说.比如单线程编程中,A();B(); ,必须等待A方法执行完了,B方法才可以执行.再比如,lock(sync){A();},无论多少个线程调用这段代码,A方法在同一个时刻只允许一个线程调用,其它线程必须等待
一致性:主要针对数据来说.我们必须确保对临界区数据的变更不会影响其它线程.比如说,A线程和B线程在某一段时间都对data进行修改,线程之间共享变量可能会造成死锁的现象,为避免出现两个线程同时修改,后者的修改将前者的修改覆盖掉,我们对data的修改进行加锁,这样data一次只会允许一个线程进行修改.也就保证了数据的一致性.

线程安全:多线程执行结果与单线程一致,线程安全
线程不安全:多线程同时修改一个变量;或者一个线程修改,一个线程读取,则可能出现BUG

在多线程问题的处理上,我们是在异步中谋求同步的目的,以确保程序的安全

线程同步的方法常见的主要有锁 SpinLock 、Mutex、Monitor、lock。以下仅介绍最常用的Monitor、lock方法

6.1.1 lock方法

1、lock锁定的是一个引用类型,值类型不能被lock
2、避免lock一个string,因为程序中任何跟锁定的string的字符串是一样的都会被锁定。
模拟售票系统代码如下:

 internal class Program
    {
        int num = 10;
        void ticket()
        {
            while (true)        //无线循环
            {
                lock (this)     //锁定代码快,以便线程同步
                {
                    if (num > 0)
                    {
                        Thread.Sleep(1000);
                        Console.WriteLine(Thread.CurrentThread.Name + "------票数" + num--);
                    }
                }
            }
        }

        static void Main(string[] args)
        {
            Program p=new Program();
            Thread ta = new Thread(p.ticket);
            ta.Name = "线程一";
            Thread tb = new Thread(p.ticket);
            tb.Name = "线程二";
            Thread tc = new Thread(p.ticket);
            tc.Name = "线程三";
            Thread td = new Thread(p.ticket);
            td.Name = "线程四";
            ta.Start();
            tb.Start();
            tc.Start();
            td.Start();
            Console.ReadLine();

        }
    }

执行结果如下图所示:
c# task,服务器,运维

说明:4个线程调用的是同一个函数,同一时间,一次只允许一个线程进入,每次执行将票数减一,线程执行的顺序尽管是无序的,但是执行的“票数”都是在上一次的结果上减1。
倘若注释同步代码,即//lock (this) //锁定代码快,以便线程同步,执行结果如下图所示,同一时间,多个线程进入同一函数,线程顺序无序,执行结果也无序,“票数3”同时被“线程四”和“线程一”执行。
现实情况中,当不考虑退票时,票数应该是越卖越少,且不会出现多人购买同一张票都成功的现象。如果不使用线程同步的写法,得不到想要的功能。
c# task,服务器,运维

6.1.2 monitor类

Monitor类提供了与lock类似的功能,不过与lock不同的是,它能更好的控制同步块,当调用了Monitor的Enter(Object o)方法时,会获取o的独占权,直到调用Exit(Object o)方法时,才会释放对o的独占权
可以使用 TryEnter() 方法可以给它传送一个超时值,决定等待获得对象锁的最长时间,该方法能在指定的毫秒数内结束线程,这样能避免线程之间的死锁现象。

bool lockTaken=false;
            Monitor.TryEnter(obj, 500, ref lockTaken);
            if(lockTaken){
                try
                {
                    //Synchronized part
                }
                finally
                {
                    Monitor.Exit(obj);
                }
            }else{
                //don't aquire the lock, excute other parts
            }

6.2 线程异步

异步与同步概念:当一个方法被调用时,调用者需要等待该方法执行完毕并返回才能继续执行,我们称这个方法是同步方法;当一个方法被调用时立即返回,并获取一个线程执行该方法内部的业务,调用者不用等待该方法执行完毕,我们称这个方法为异步方法
异步方法的优点:异步线程最大的好处在于非阻塞,即各线程之间执行任务时,互不干扰,当任务完成之后就可立即响应,不需等待其他任务是否执行完成。异步编程中最好用的便是 async和await 。
在C#5.0中出现的 async和await ,让异步编程变得更简单,用同步的写法写异步同步代码的逻辑结构

线程异步与多任务执行关系:异步是同时执行多个任务,而Task则是允许多个任务可以在线程内同时进行,多任务的同时进行,则是由异步来进行,而异步方法,必须为Task

6.2.1 控制台应用async和await

不加await修饰代码如下,即为多线程常规流程执行方式

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("开始");
            WriteAsync();
            Console.WriteLine("结束");
            Console.ReadKey();
        }

        static void WriteAsync()
        {
            Task.Run(() =>
            {
                for (int i = 0; i < 10; i++)
                {
                    Console.WriteLine("T " + i);
                }
            });
            Task.Run(() =>
            {
                for (int i = 0; i < 10; i++)
                {
                    Console.WriteLine("S " + i);
                }
            });
        }

执行结果如下:
c# task,服务器,运维
或者c# task,服务器,运维
如上的执行结果,未阻塞主线程,两次执行结果,S在上或者T在上,这是任务内部无序执行的结果,具体情况与***## 4.Task常用的API***常规流程方式一致

加await修饰代码如下:

 class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("开始");
            WriteAsync();
            Console.WriteLine("结束");
            Console.ReadKey();
        }

        static async void WriteAsync()
        {
            await Task.Run(() =>
            {
                for (int i = 0; i < 10; i++)
                {
                    Console.WriteLine("T " + i);
                }
            });
            await Task.Run(() =>
            {
                for (int i = 0; i < 10; i++)
                {
                    Console.WriteLine("S " + i);
                }
            });

        }
    }

执行结果如下图所示:
c# task,服务器,运维
如上图所示,未阻塞主线程执行,而在task内部,函数执行变得有序起来,不论执行多少次,T永远在S上面,通过异步之间的await进程等待,避免不必要的资源占用和浪费。有点类似于上述API函数中介绍的方法,但是API函数中的方法会阻塞主线程。

6.2.2 Winfrom界面async和await

例子实现功能:当点击button1启动按钮时,运行一个任务,任务结束时要报告是否成功,如果成功button2就显示绿色图标、如果失败就显示红色图标,1秒后图标颜色恢复为白色;任务运行期间启动按钮要不可用,
界面布局如图所示:
c# task,服务器,运维

常规代码实现方式:

public partial class Form1 : Form
    {
        private void btnStart_Click(object sender, EventArgs e)
        {
            this.btnStart.Enabled = false;

            if(DoSomething())
            {
                this.picShow.BackColor = Color.Green;
            }
            else
            {
                this.picShow.BackColor = Color.Red;
            }

            Thread.Sleep(1000);
           
            this.picShow.BackColor = Color.White;
            this.btnStart.Enabled = true;
        }

        private bool DoSomething()
        {
            Thread.Sleep(5000);
            return true;
        }
    }

运行情况:启动程序,此时程序界面是可以拖动的,点击按钮1,程序界面被阻塞,无法拖动,此时开始执行DoSomething方法,返回结果为true,进入判断执行this.picShow.BackColor = Color.Green,立即执行this.picShow.BackColor = Color.White;,此时无法看到界面按钮2变为绿色,想要功能无法实现。
问题分析:
1、运行期间UI线程阻塞了,用户界面没有响应;
2、根本不能实现需求,点击启动后,程序卡死6秒种,也没有看到颜色变化,因为UI线程已经阻塞,当重新获得句柄时图标已经是白色了。
以下采用多任务实现具体需求,代码如下:

public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnStart_Click(object sender, EventArgs e)
        {
            this.btnStart.Enabled = false;

            Task.Run(() => 
            {  
                if (DoSomething())
                {
                    this.Invoke(new Action(() =>
                    {
                        this.picShow.BackColor = Color.Green;
                    }));                   
                }
                else
                {
                    this.Invoke(new Action(() =>
                    {
                        this.picShow.BackColor = Color.Red;
                    }));                   
                }

                Thread.Sleep(1000);

                this.Invoke(new Action(() =>
                {
                    this.btnStart.Enabled = true;
                    this.picShow.BackColor = Color.White;
                }));               
            });           
        }

        private bool DoSomething()
        {
            Thread.Sleep(5000);
            return true;
        }
    }

代码特点:将颜色变化功能统一放置task中执行,同一个任务中,代码按顺序执行,执行顺序this.picShow.BackColor = Color.Green;Thread.Sleep(1000);this.picShow.BackColor = Color.White;因此可看到颜色变化。
功能基本可以实现,但存在以下问题:
1、主线程的btnStart_Click方法除了启动一个任务以外,啥事也没干,线程是在后台执行的。
2、由于非UI线程不能访问UI控件,代码里有很多Invoke,比较丑陋;
3、界面逻辑和业务逻辑掺和在一起,使得代码难以理解。

以下采用async和await 异步编程的方式解决上述问题,代码如下:

public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private async void btnStart_ClickAsync(object sender, EventArgs e)
        {
            this.btnStart.Enabled = false;

            var result = await DoSomethingAsync();
            if(result)
            {
                this.picShow.BackColor = Color.Green;
            }
            else
            {
                this.picShow.BackColor = Color.Red;
            }

            await Task.Delay(1000);
            
            this.picShow.BackColor = Color.White;
            this.btnStart.Enabled = true;
        }

        private async Task<bool> DoSomethingAsync()
        {
            await Task.Run(() =>
            {
                Thread.Sleep(5000);                
            });
            return true;
        }
    }

代码特点:DoSomethingAsync函数带有返回值,此函数中添加async和await ,代码执行顺序DoSomethingAsyncthis.picShow.BackColor = Color.Greenawait Task.Delay(1000)this.picShow.BackColor = Color.White,和上述功能正常程序一致,但是添加async和await,让程序按照一定顺序执行,即执行完DoSomethingAsync之后,才会执行后续任务。思维模式:以编写同步代码的方式编写异步
为加深理解,将上述代码去掉async和await,改写成如下形式:

public partial class Form1 : Form
    {
        bool a = false;
        public Form1()
        {
            InitializeComponent();
        }

        private  void  btnStart_ClickAsync(object sender, EventArgs e)
        {
            this.btnStart.Enabled = false;
            this.btnStart.Visible = false;

             DoSomethingAsync();
            if (a)
            {
                this.picShow.BackColor = Color.Green;
            }
            else
            {
                this.picShow.BackColor = Color.Red;
            }

             Task.Delay(1000);

            this.picShow.BackColor = Color.White;
            this.btnStart.Enabled = true;
            this.btnStart.Visible = true;
        }

        private  void  DoSomethingAsync()
        {
             Task.Run(() =>
            {
                Thread.Sleep(5000);
                a = true;
            });            
        }
    }

执行结果:按钮1一直处于可见状态,DoSomethingAsync函数相当于没有执行,按钮2变为红色的瞬间变为白色,是看不到颜色变化的,Task.Delay是在后台运行,整个程序相当于什么也没有执行。
这里如果还不是很清除加与不加async和await的区别,请参考添加链接描述

6.3 异步并发

并行:两队人,进入一个门,每队每次轮流进一个,这称之为并发
并发:两队人,分别进入两个门,各进各的,这称之为并行.

7.线程调试方法

线程是系统后台分配内存空间执行相应任务,当线程创建的越多,后台执行越容易出现莫名其妙的BUG,达不到想要的功能。例如后台执行100个线程,传入共同参数X,所有线程执行完,得到结果Y,而实际想要得到的结果为Z,100个线程在后台执行的先后是无序的,即线程执行会跳来跳去
常用的调试方法打断点是行不通的,因为断点的焦点会在线程之间“反复横跳”,根本无法集中跟踪某一个线程的操作链路,打断点也不是按顺序执行,不可能100个线程每个入口都打上断点,如何确认是在哪一个线程或多个线程执行环节出现问题?除了上述***## 4.task中常用API***函数外,以下简介其他方式调试多线程。
添加链接描述

7.1 多线程界面调试方法

1.以***## 4.Task常用的API***常规流程为例,断点处右击选择条件,如下图所示,条件文本框中可编写调试条件。
c# task,服务器,运维
2.debug模式下启动程序,点击“调试-窗体-线程”,如下图所示。
c# task,服务器,运维
3.运行后,执行到断点处,如下图所示,进程处会显示当前线程ID。
c# task,服务器,运维

7.2 多线程界面调试实操

如上所述,多线程运行时,线程之间无序,常规断点方式也无法进行,最主要的原因在于无法锁定某一个线程,因此我们需要想办法锁定某一个线程,让这个线程一直运行下去,查看锁定的线程是否有问题
简单案例代码如下,for (int i = 0; i < 100; i++)处打断点,

internal class Program
    {
        static void Main(string[] args)
        {
            Task[] task = new Task[6];
            for (int i = 0; i < task.Length; i++)
            {
                task[i] = Task.Run(Do);
            }
            Task.WaitAll(task);
            Console.WriteLine();
            Console.ReadLine();
        }
        private static void Do()
        {
            int x = Thread.CurrentThread.ManagedThreadId;
            //循环调试
            for (int i = 0; i < 100; i++)
            {
                Console.WriteLine(i);
            }
        }
    }

具体操作见如下视频:
添加链接描述

8.多线程异常处理

8.1 单线程异常与多线程异常比对

单线程处理:try-catch,catch中进行异常处理,捕捉异常----处理异常

			try
            {
                {
                    //捕捉异常
                }
            }
            catch
            {
                {
                    throw;
                    //处理异常
                }
            }

多线程处理:无法直接用try-catch包裹

8.2 单线程与多线程案列

界面布局如下图:
c# task,服务器,运维
单线程异常处理代码:

private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                for (int i = 0; i < 20; i++) 
                {
                    string k = $"button2_Click{i}";

                    if (k.Equals("button2_Click8"))
                    {
                        throw new Exception("k==button2_Click8异常");
                    }
                    else if (k.Equals("button2_Click10"))
                    {
                        throw new Exception("k==button2_Click10异常");
                    }
                    else if (k.Equals("button2_Click15"))
                    {
                        throw new Exception("k==button2_Click15异常");
                    }
                }
            }
            catch 
            {
                throw;
            }
        }

将程序断点打在catch 处,运行时,会进入点内的内容,如下图所示
c# task,服务器,运维
多线程异常处理先仿照单线程方式,代码如下:

private void button2_Click(object sender, EventArgs e)
        {
            try
            {
                for (int i = 0; i < 20; i++)
                {
                    string k = $"button2_Click{i}";
                    Task.Run(() =>
                    {
                        if (k.Equals("button2_Click2"))
                        {
                            throw new Exception("k==button2_Click8异常");
                        }
                        else if (k.Equals("button2_Click10"))
                        {
                            throw new Exception("k==button2_Click10异常");
                        }
                        else if (k.Equals("button2_Click15"))
                        {
                            throw new Exception("k==button2_Click15异常");
                        }
                    });
                }
            }
            catch
            {
                throw;
            }
        }

断点分别打在3个异常处及catch处,运行程序如下图所示
c# task,服务器,运维
断点可以进入异常处,无法进入catch处,即程序确实有异常发生,被捕捉到了,但是无法处理异常,异常被吞掉了
综上所述,常规单线程处理异常的方式无法在多线程使用,即无法直接用try-catch包裹代码,捕获异常、处理异常

8.3 多线程异常捕捉与处理

那么多线程内部发生的异常如何捕捉?需实现以下2大条件
1.需要做线程的等待,例如task.waitall,即阻塞主线程
2.try-catch包裹
将上述多线程的代码改写成如下形式:

private void button2_Click(object sender, EventArgs e)
        {
            try
            {
                List<Task> list1 = new List<Task>();
                for (int i = 0; i < 20; i++)
                {
                    string k = $"button2_Click{i}";
                    //线程列表
                    list1.Add(Task.Run(() =>
                    {
                        if (k.Equals("button2_Click2"))
                        {
                            throw new Exception("k==button2_Click8异常");
                        }
                        else if (k.Equals("button2_Click10"))
                        {
                            throw new Exception("k==button2_Click10异常");
                        }
                        else if (k.Equals("button2_Click15"))
                        {
                            throw new Exception("k==button2_Click15异常");
                        }
                    }));
                }
                Task.WaitAll(list1.ToArray());		//等待线程完成
            }
            catch(Exception ex)
            {
                throw;
            }
        }

主要增加代码内容为:将所有线程放在线程列表中,添加Task.WaitAll(list1.ToArray());阻塞线程
断点分别打在3个异常处及catch处,异常可进去,也可以捕获。
捕获异常详细情况如下图所示:
c# task,服务器,运维
捕获的3个异常恰为发生异常,点击“快速监视”,查看“ex”的类型,如下图所示:
c# task,服务器,运维

8.4 多线程中多个异常捕获

上述例子中多线程出现3个异常,只用了一个“try-catch”结构,集中显示异常情况,对于异常查看并不方便,解决上述问题,采用如下方式。
1.一个try可以对应多个catch
2.AggregateException捕获异常,多线程特有异常捕获,AggregateException继承至Exception,Exception子类,AggregateException内部包含多线程集合

上述多线程例子中try-catch部分换成如下情况,
c# task,服务器,运维
会弹出3此提示框,告知出现的异常情况,3个异常不仅能够捕获,也可显示。

8.总结

C#多线程最常用的方式就是Task,本文主要针对task做了详细的描述,较全面的总结了多线程使用的方式,文中资料与代码实例参考引用文献较多。文章目的不为赚米,只为学习C#中多线程做笔记,加深对线程理解与使用。文章来源地址https://www.toymoban.com/news/detail-766405.html

到了这里,关于C#中多线程Task详解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • C# Task Parallel Library (TPL) 访问线程池

    //在C#中,可以使用Task Parallel Library (TPL)来访问线程池。 //TPL是一个用于并行编程的框架,它提供了一种简单的方式来创建并行任务, //并 自动利用线程池 来执行这些任务。 //下面是一个使用TPL访问线程池的示例: //csharp using System; using System.Threading.Tasks; class Program {     st

    2024年02月08日
    浏览(79)
  • C#学习相关系列之多线程(七)---Task的相关属性用法

    任务是 架构在线程之上 的,任务最终的执行还是要给到线程去执行的。 任务和线程之间不是一对一的关系,任务更像线程池,任务相比线程池有很小的开销和精确的控制。 (总的来说Task的用法更为先进,在多线程的时候应该优先考虑Task) 1. status 当前状态类属性(较多)  C

    2024年02月06日
    浏览(34)
  • c# Task异步使用

    描述 Task出现之前,微软的多线程处理方式有:Thread→ThreadPool→委托的异步调用,虽然可以满足基本业务场景,但它们在多个线程的等待处理方面、资源占用方面、延续和阻塞方面都显得比较笨拙,在面对复杂的业务场景下,显得有点捉襟见肘 Task是微软在.Net 4.0时代推出来的

    2024年02月11日
    浏览(39)
  • Linux中 socket编程中多进程/多线程TCP并发服务器模型

    一次只能处理一个客户端的请求,等这个客户端退出后,才能处理下一个客户端。 缺点:循环服务器所处理的客户端不能有耗时操作。 模型 源码 可以同时处理多个客户端请求 父进程 / 主线程专门用于负责连接,创建子进程 / 分支线程用来与客户端交互。 模型 源码 模型 源

    2024年02月12日
    浏览(42)
  • C#知识点-13(进程、多线程、使用Socket实现服务器与客户端通信)

    进程 定义:每一个正在运行的应用程序,都是一个进程  进程不等于正在运行的应用程序。而是为应用程序的运行构建一个运行环境 多线程 这段代码在执行完成之前,程序会被卡死(不能操作程序,包括关闭窗口)。因为我们程序在做一些耗时操作的时候,如果主线程去执

    2024年02月22日
    浏览(93)
  • Unity C# 之 Task、async和 await 、Thread 基础使用的Task的简单整理

    目录 Unity C# 之 Task、async和 await 、Thread 基础使用的Task的简单整理 一、Task、async和 await 、Thread 基础概念 1、线程,多线程 2、Task  3、async (await ) 二、Task 的基础使用,Task 的创建 和 启动 1、创建并运行一个Task 2、创建有返回值的 Task 3、Task提供了 task.RunSynchronously()用于同步

    2024年02月12日
    浏览(47)
  • C# 中多线程锁的使用经验

    C# 中多线程锁的使用经验:全局锁,实例锁         private static object _exeLock = new object();        static 静态的是全应用程序的资源。如果在一个类里定义了这样一个锁,你在调用使用这个类的时候,是NEW了一个对象,并把这个对象给了一个静态全局变量中保存。这时这个锁

    2024年03月14日
    浏览(55)
  • C# Task 使用 WhenAll 请求远程分页接口

    -所有提供的任务已完成时,创建将完成的任务- -Creates a task that will complete when all of the supplied tasks have completed- Task.WhenAll() 方法是 C# 中用于等待多个任务( Task )完成的一种方式。它不会控制并发数量,而是等待所有传递给它的任务都完成后才会继续执行下一步操作。这意味

    2024年02月13日
    浏览(31)
  • c# 使用了 await、asnync task.run 三者结合使用

    在 C# 异步编程中,`await` 和 `async` 结合使用可以让你更方便地编写异步代码,而无需直接使用 `Task.Run`。然而,有时候你可能仍然需要使用 `Task.Run` 来在后台线程上执行某些工作,这取决于你的代码逻辑和需求。 `await` 和 `async` 通常用于异步等待 IO 操作,如网络

    2024年02月11日
    浏览(39)
  • Unity C# 之 Task、async和 await 结合使用的一些情况处理

    目录 Unity C# 之 Task、async和 await  结合使用的一些情况处理 一、简单介绍 二、把 async 函数,通过变化转为一般的函数 三、在 async 函数中,切换到主线程,并等待主线程执行完毕,继续 async 中的代码 Unity 在使用 Task 结合 async (await) 的时候,偶尔会遇到一些特殊情况,需要

    2024年01月22日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包