• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

C#多线程总结异常处理线程取消锁(lock)

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

那么什么时候能用多线程? 任务能并发的时候

多线程能干嘛?提升速度/优化用户体验

网站首页:A数据库 B接口 C分布式服务 D搜索引擎,适合多线程并发,都完成后才能返回给用户,需要等待WaitAll
列表页:核心数据可能来自数据库/接口服务/分布式搜索引擎/缓存,多线程并发请求,哪个先完成就用哪个结果,其他的就不管了

现实实例

多人合作开发---多线程--提升效率/性能

 1               {
 2                 TaskFactory taskFactory = new TaskFactory();
 3                 List<Task> taskList = new List<Task>();
 4                 taskList.Add(taskFactory.StartNew(o=> Coding("A", " Portal"), "A"));
 5                 taskList.Add(taskFactory.StartNew(o=> Coding("B", "    DBA"), "B"));
 6                 taskList.Add(taskFactory.StartNew(o=> Coding("C", " Client"), "C"));
 7                 taskList.Add(taskFactory.StartNew(o=> Coding("D", "Service"), "D"));
 8                 taskList.Add(taskFactory.StartNew(o=> Coding("E", " Wechat"), "E"));
 9 
10                 //谁第一个完成,获取一个红包奖励
11                 taskFactory.ContinueWhenAny(taskList.ToArray(), t => Console.WriteLine($"{t.AsyncState}开发完成,获取个红包奖励{Thread.CurrentThread.ManagedThreadId.ToString("00")}"));
12                 //实战作业完成后,一起庆祝一下
13                 taskList.Add(taskFactory.ContinueWhenAll(taskList.ToArray(), rArray => Console.WriteLine($"开发都完成,一起庆祝一下{Thread.CurrentThread.ManagedThreadId.ToString("00")}")));
14                 //ContinueWhenAny  ContinueWhenAll 非阻塞式的回调;而且使用的线程可能是新线程,也可能是刚完成任务的线程,唯一不可能是主线程
15 
16 
17                 //阻塞当前线程,等着任意一个任务完成
18                 Task.WaitAny(taskList.ToArray());//也可以限时等待
19                 Console.WriteLine("准备环境开始部署");
20                 //需要能够等待全部线程完成任务再继续  阻塞当前线程,等着全部任务完成
21                 Task.WaitAll(taskList.ToArray());
22                 Console.WriteLine("5个模块全部完成后,集中调试");
23 
24                 //Task.WaitAny  WaitAll都是阻塞当前线程,等任务完成后执行操作
25                 //阻塞卡界面,是为了并发以及顺序控制
26             }
View Code
 1         /// <summary>
 2         /// 模拟Coding过程
 3         /// </summary>
 4         /// <param name="name"></param>
 5         /// <param name="projectName"></param>
 6         private static string Coding(string name, string projectName)
 7         {
 8             Console.WriteLine($"****************Coding Start  {name} {projectName}  {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
 9             long lResult = 0;
10             for (int i = 0; i < 1_000_000_000; i++)
11             {
12                 lResult += i;
13             }
14             Console.WriteLine($"****************Coding   End  {name} {projectName} {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} {lResult}***************");
15             return name;
16         }
View Code

多线程异常处理

 1             #region 多线程异常处理
 2             {
 3                 try
 4                 {
 5 
 6                     List<Task> taskList = new List<Task>();
 7                     for (int i = 0; i < 100; i++)
 8                     {
 9                         string name = $"btnThreadCore_Click_{i}";
10                         taskList.Add(Task.Run(() =>
11                         {
12                             if (name.Equals("btnThreadCore_Click_11"))
13                             {
14                                 throw new Exception("btnThreadCore_Click_11异常");
15                             }
16                             else if (name.Equals("btnThreadCore_Click_12"))
17                             {
18                                 throw new Exception("btnThreadCore_Click_12异常");
19                             }
20                             else if (name.Equals("btnThreadCore_Click_38"))
21                             {
22                                 throw new Exception("btnThreadCore_Click_38异常");
23                             }
24                             Console.WriteLine($"This is {name}成功 ThreadId={Thread.CurrentThread.ManagedThreadId.ToString("00")}");
25                         }));
26                     }
27                     //多线程里面抛出的异常,会终结当前线程;但是不会影响别的线程;
28                     //那线程异常哪里去了? 被吞了,
29                     //假如我想获取异常信息,还需要通知别的线程
30                     Task.WaitAll(taskList.ToArray());//1 可以捕获到线程的异常
31                 }
32                 catch (AggregateException aex)//2 需要try-catch-AggregateException
33                 {
34                     foreach (var exception in aex.InnerExceptions)
35                     {
36                         Console.WriteLine(exception.Message);
37                     }
38                 }
39                 catch (Exception ex)//可以多catch  先具体再全部
40                 {
41                     Console.WriteLine(ex);
42                 }
43                 //线程异常后经常是需要通知别的线程,而不是等到WaitAll,问题就是要线程取消
44                 //工作中常规建议:多线程的委托里面不允许异常,包一层try-catch,然后记录下来异常信息,完成需要的操作
45             }
46             #endregion
View Code

多线程里面抛出的异常,会终结当前线程;但是不会影响别的线程;线程异常哪里去了? 被吞了

多线程的委托里面不允许异常,包一层try-catch,然后记录下来异常信息 ,通知别的线程

线程取消

 1               {
 2                 CancellationTokenSource cts = new CancellationTokenSource();
 3                 var token = cts.Token; cts.Cancel();
 4                 CancellationTokenSource cts2 = new CancellationTokenSource();
 5                 var token2 = cts2.Token;
 6                 List<Task> taskList = new List<Task>();
 7                 for (int i = 0; i < 10; i++)
 8                 {
 9                     int k = i;
10                     switch (i%5)
11                     {
12                         case 0:
13                             taskList.Add(Task.Run(() => { Console.WriteLine($"i={i},k={k},i%5=0"); }));break;
14                         case 1: 
15                             taskList.Add(Task.Run(() => { Console.WriteLine($"i={i},k={k},i%5=1"); },token)); break;
16                         case 2: 
17                             taskList.Add(Task.Run(() => { Console.WriteLine($"i={i},k={k},i%5=2"); }, token2)); break;
18                         case 3:
19                             taskList.Add(Task.Run(() => { Console.WriteLine($"i={i},k={k},i%5=3"); })); break;
20                         case 4:
21                             taskList.Add(Task.Run(() => { Console.WriteLine($"i={i},k={k},i%5=4");
22                                 throw new Exception("throw new Exception");
23                             })); break;
24                     }
25                 }
26                 //Thread.Sleep(500);
27                 cts2.Cancel();
28                 try
29                 {
30                     Task.WaitAll(taskList.ToArray());
31                 }catch(AggregateException ae)
32                 {
33                     foreach (var item in ae.InnerExceptions)
34                     {
35                         Console.WriteLine($"{item.GetType().Name}:{item.Message}");
36                     }
37                 }
38                 Console.WriteLine("**********************************");
39                 foreach (var item in taskList)
40                 {
41                     Console.WriteLine($"Id:{item.Id},Status:{item.Status}");
42                     if (item.Exception != null)
43                     {
44                         foreach (var ex in item.Exception.InnerExceptions)
45                         {
46                             Console.WriteLine($"{ex.GetType().Name}:{ex.Message}");
47                         }
48                     }
49                 }
50             }
View Code

运行上面的代码,有四个任务被取消,取消注释,则有两个任务被取消

线程安全

如果你的代码在进程中有多个线程同时运行这一段,如果每次运行的结果都跟单线程运行时的结果一致,那么就是线程安全的
线程安全问题一般都是有全局变量/共享变量/静态变量/硬盘文件/数据库的值,只要多线程都能访问和修改

Lock

1、Lock解决多线程冲突

Lock是语法糖,Monitor.Enter,占据一个引用,别的线程就只能等着 

推荐锁是private static readonly object

A 不能是Null,可以编译不能运行;

B 不推荐lock(this),外面如果也要用实例,就冲突了

 1     public class LockHelper
 2     {
 3         public void Show()
 4         {
 5             LockTest test = new LockTest();
 6             Console.WriteLine(DateTime.Now);
 7             Task.Delay(10).ContinueWith(t =>
 8             {
 9                 lock (test)
10                 {
11                     Console.WriteLine($"*********Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}********");
12                     Thread.Sleep(5000);
13                     Console.WriteLine($"*********End   {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}********");
14                 }
15             });
16             test.LockThis();
17         }
18     }
19     public class LockTest
20     {
21         private int lockthis;
22         public void LockThis()
23         {
24             lock (this)
25             //递归调用,lock this  会不会死锁? 不会死锁!
26             //这里是同一个线程,这个引用就是被这个线程所占据
27             {
28                 Thread.Sleep(1000);
29                 this.lockthis++;
30                 if (this.lockthis < 10)
31                     this.LockThis();
32                 else
33                     Console.WriteLine($"This is  {nameof(LockThis)}:{this.lockthis} {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}");
34             }
35         }
36     }
View Code

这里LockThis自身递归调用不会死锁,这个引用被当前线程占用,但当另外的实例要使用时就冲突了,必须等待LockThis执行完成后,释放当前实例,外面的实例才能被调用

C 不应该是string; string在内存分配上是重用的,会冲突

 1             {
 2                 LockTest test = new LockTest();
 3                 Console.WriteLine(DateTime.Now);
 4                 string lockString = "lockString";
 5                 Task.Delay(1000).ContinueWith(t =>
 6                 {
 7                     lock (lockString)
 8                     {
 9                         Console.WriteLine($"****lockString Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}********");
10                         Thread.Sleep(5000);
11                         Console.WriteLine($"****lockString End   {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}********");
12                     }
13                 });
14                 test.LockString();
15             }
16     public class LockTest
17     {
18         private int lockthis;
19         public void LockThis()
20         {
21             lock (this)
22             //递归调用,lock this  会不会死锁? 不会死锁!
23             //这里是同一个线程,这个引用就是被这个线程所占据
24             {
25                 Thread.Sleep(1000);
26                 this.lockthis++;
27                 if (this.lockthis < 10)
28                     this.LockThis();
29                 else
30                     Console.WriteLine($"This is  {nameof(LockThis)}:{this.lockthis} {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}");
31             }
32         }
33 
34         private string lockString= "lockString";
35         public void LockString()
36         {
37             lock (lockString)
38             {
39                 Thread.Sleep(2000);
40                 Console.WriteLine($"This is  {nameof(LockString)}:{this.lockString} {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}");
41                 Thread.Sleep(2000);
42             }
43         }
44     }
View Code

String类型在内存分配上按享元模式设计的,某个字符串被占用,其他线程就必须等待字符串释放后才能使用

D Lock里面的代码不要太多,这里是单线程的

2、线程安全集合

System.Collections.Concurrent.ConcurrentQueue<T>

3、 数据分拆,避免多线程操作同一个数据;又安全又高效

 1         private int _sync = 0;
 2         private int _async = 0;
 3         private List<int> listInt = new List<int>();
 4         private static readonly object lockObject = new object();
 5         public void LockObject()
 6         {
 7             for (int i = 0; i < 1000; i++)
 8             {
 9                 this._sync++;
10             }
11             for (int i = 0; i < 1000; i++)
12             {
13                 Task.Run(() => this._async++);
14             }
15             for (int i = 0; i < 1000; i++)
16             {
17                 int k = i;
18                 Task.Run(() => this.listInt.Add(k));
19             }
20             Thread.Sleep(5 * 1000);
21             Console.WriteLine($"_sync={this._sync} _async={this._async} listInt={this.listInt.Count}");
22         }
View Code

运行上面的代码发现_sync=1000  _async与listInt集合个数都少于1000

 1         public void LockObject()
 2         {
 3             for (int i = 0; i < 1000; i++)
 4             {
 5                 this._sync++;
 6             }
 7             for (int i = 0; i < 1000; i++)
 8             {
 9                 Task.Run(() => {
10                     lock (lockObject)
11                     {
12                         this._async++;
13                     }
14                 });
15             }
16             for (int i = 0; i < 1000; i++)
17             {
18                 int k = i;
19                 Task.Run(() => {
20                     lock (lockObject)
21                     {
22                         this.listInt.Add(k);
23                     }
24                 });
25             }
26             Thread.Sleep(5 * 1000);
27             Console.WriteLine($"_sync={this._sync} _async={this._async} listInt={this.listInt.Count}");
28         }
View Code

使用lock包装后 _async与listInt集合个数都为1000, 使用lock后 只有一个线程才能进入lock方法块内,相当于把程序又变回了单线程

微软文档:

lock:https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/lock-statement

CancellationTokenSource:https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.cancellationtokensource?view=netframework-4.8

CancellationToken:https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.cancellationtoken?view=netframework-4.8


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
codesmith自动生成C#model实体模板发布时间:2022-07-14
下一篇:
C#调用Oracle带输出数据集的存储过程发布时间:2022-07-14
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap