一. 线程的异常处理:
try
{
TaskFactory taskFactory = new TaskFactory();
List<Task> taskList = new List<Task>();
//线程里面的异常是被吞掉了，因为已经脱离try catch的范围了 如果真想让线程之外的Catch抓到异常, 那么只有使用 WaitAll 抓到多线程里面全部的异常
//实际开发: 线程里面的action不允许出现异常，自己使用try catch处理好
for (int i = 0; i < 20; i++)
{
string name = string.Format($"btnThreadCore_Click_{i}");
Action<object> act = t =>
{
try
{
Thread.Sleep(2000);
if (t.ToString().Equals("btnThreadCore_Click_11"))
{
throw new Exception(string.Format($"{t} 执行失败"));
}
if (t.ToString().Equals("btnThreadCore_Click_12"))
{
throw new Exception(string.Format($"{t} 执行失败"));
}
Console.WriteLine("{0} 执行成功", t);
}
catch (Exception ex)
{
Console.WriteLine($"Exception:{ex.Message}"); //
}
};
taskList.Add(taskFactory.StartNew(act, name));
}
// Task.WaitAll(taskList.ToArray());使用 WaitAll 捕获多线程里面全部的异常; 但是也不能总是WaitAll, 并且很多业务也不能使用WaitAll来处理
}
catch (AggregateException aex) //专门处理多线程的异常, 里面的异常有多项
{
foreach (var item in aex.InnerExceptions)
{
Console.WriteLine(item.Message);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
二. 线程的取消,
a) 场景: 多个线程并发，某个失败后，希望通知别的线程，都停下来, 尽量使用CancellationTokenSource, 不要自己创建bool变量
try
{
TaskFactory taskFactory = new TaskFactory();
List<Task> taskList = new List<Task>();
//多个线程并发，某个失败后，希望通知别的线程，都停下来
//task是外部无法中止(中间停止)，Thread.Abort不靠谱，因为线程是OS的资源，无法掌控啥时候取消
//线程的停止: 线程自己停止自己--公共的访问变量--修改它---线程不断的检测它(延迟少不了)
//CancellationTokenSource去标志任务是否取消 Cancel取消 IsCancellationRequested 是否已经取消了
//Token 启动Task的时候传入，那么如果Cancel了，这个任务会放弃启动，抛出一个异常
// 当一个线程不执行, 后面的线程全部都不能再执行了
CancellationTokenSource cts = new CancellationTokenSource();//bool值 //bool flag = true; 线程安全的
for (int i = 0; i < 40; i++)
{
string name = string.Format("btnThreadCore_Click{0}", i);
Action<object> act = t =>
{
try
{
//if (cts.IsCancellationRequested)
//{
// Console.WriteLine("{0} 取消一个任务的执行", t);
//}
Thread.Sleep(2000);
if (t.ToString().Equals("btnThreadCore_Click11"))
{
throw new Exception(string.Format("{0} 执行失败", t));
}
if (t.ToString().Equals("btnThreadCore_Click12"))
{
throw new Exception(string.Format("{0} 执行失败", t));
}
if (cts.IsCancellationRequested)//启动40个线程, 每一个线程都检查这个信号量, 是否改任务已经被取消
{
Console.WriteLine("{0} 放弃执行", t);
return;
}
else
{
Console.WriteLine("{0} 执行成功", t);
}
}
catch (Exception ex)
{
cts.Cancel(); //当执行抛出异常后, (t.ToString().Equals("btnThreadCore_Click11")); 将信号量设置为false, 表示取消任务
Console.WriteLine(ex.Message);
}
};
taskList.Add(taskFactory.StartNew(act, name, cts.Token));
//如果一个线程在启动的时候标识了cts.Token, 当cts.Cancel()时, 如果这个线程还没有启动, 则会被标识为取消一个任务执行; 如果这个线程已经启动, 但是还没有执行, 那么会被放弃执行
}
Task.WaitAll(taskList.ToArray());
}
catch (AggregateException aex) //专门处理多线程的异常
{
foreach (var item in aex.InnerExceptions)
{
Console.WriteLine(item.Message);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
三. 多线程临时变量
for (int i = 0; i < 5; i++)
{
Task.Run(() =>
{
Thread.Sleep(100);
Console.WriteLine(i); //打印结果 5个5
});
}
for (int i = 0; i < 5; i++)
{
int k = i;
Task.Run(() =>
{
Thread.Sleep(100);
Console.WriteLine(k); //打印结果 4,3,1,2,0
});
}
//i最后是5 全程就只有一个i 等着打印的时候，i==5
//k 全程有5个k 分别是0 1 2 3 4
//k在外面声明 全程就只有一个k 等着打印的时候，k==4
int k = 0;
for (int i = 0; i < 5; i++)
{
// int k = i;
k = i;
new Action(() =>
{
Thread.Sleep(100);
Console.WriteLine($"k={k} i={i}");
}).BeginInvoke(null, null);
}
四. 线程安全:
try
{
TaskFactory taskFactory = new TaskFactory();
List<Task> taskList = new List<Task>();
//如何判断何时加锁: 线程内部声明的变量, 由于不共享的是线程安全的; 但是在线程外部操作的资源由于共享, 则就会造成线程不安全. 比如全局变量/数据库的某个值/磁盘文件
int TotalCountIn = 0;//TotalCountIn属于线程外部变量, 会有线程安全有问题
for (int i = 0; i < 10000; i++)//i属于线程外部变量, 会有线程安全有问题
{
int newI = i;//newI 属于线程内部变量, 不会有线程安全有问题
taskList.Add(taskFactory.StartNew(() =>
{
//值类型不能lock
lock (btnThreadCore_Click_Lock)//lock后的方法块，任意时刻只有一个线程可以进入
//只能锁引用类型,占用这个引用链接 不要用string 因为享元 , 可能导致锁的是同一块内存区域
{ //这里就是单线程
this.TotalCount += 1;
TotalCountIn += 1;
this.IntList.Add(newI);
}
}));
}
Task.WaitAll(taskList.ToArray());
Console.WriteLine(this.TotalCount);
Console.WriteLine(TotalCountIn);
Console.WriteLine(this.IntList.Count());
#endregion
}
catch (AggregateException aex) //专门处理多线程的异常
{
foreach (var item in aex.InnerExceptions)
{
Console.WriteLine(item.Message);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
五. 关于Lock变量的写法解释:
//为什么锁的变量要这样写private static readonly object btnThreadCore_Click_Lock = new object(); //private 防止外面也去锁 //static 全场唯一 //readonly不准修改, 如果不是readonly有可能会在锁的代码里面修改它 //object表示引用, 因为lock不能锁值类型
六. 为什么不推荐锁this
//lock (this)
//{
// //this form1的实例 每次实例化是不同的锁，同一个实例是相同的锁
// //但是这个实例别人也能访问到，别人也能锁定
// //最好不要锁this
//}
七. Lock到底是个什么?
//Monitor.Enter(btnThreadCore_Click_Lock);
//lock 就是一个语法糖, 类似于monitor的写法, 也就是说可以将lock{ }块中的语句, 放到Monitor的Enter和exit中间
//Monitor.Exit(btnThreadCore_Click_Lock);
Monitor.Enter(btnThreadCore_Click_Lock);
//lock 就是一个语法糖, 类似于monitor的写法, 也就是说可以将lock{ }块中的语句, 放到Monitor的Enter和exit中间
{ //这里就是单线程
this.TotalCount += 1;
TotalCountIn += 1;
this.IntList.Add(newI);
}
Monitor.Exit(btnThreadCore_Click_Lock);
八. 不使用lock解决,线程安全问题:
//使用lock 解决的时候，因为只有一个线程可以操作数据, 没有并发, 所以解决了问题 但是牺牲了性能，所以要尽量缩小lock的范围 //解决办法:1. 开发中最好不要有冲突, 能拆分就优先拆分, 比如在1亿条数据中进行操作, 那么可以先将数据拆分成不同的小块, 然后再合并成1亿条数据 //2. 不使用locak, 可以使用安全队列 System.Collections.Concurrent.ConcurrentQueue来解决, 一个线程去完成操作