1. 常用多线程比较
1.1 Thread
定义：Thread（线程）是操作系统中能够独立运行的代码段，是程序执行流的最小单元。它是CPU调度的基本单位，是进程中的一个实体，是CPU分配资源的基本单位，它是比进程更独立运行的单位，线程一般不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器、一组寄存器和栈），但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。优点：Thread方式提供直接控制线程生命周期的灵活性，包括创建、启动和终止。每个Thread独立并行执行，需开发者通过同步机制协调交互。适用于精确控制线程行为或复杂交互的场景，且具有良好的跨平台性。缺点：频繁创建和销毁线程会消耗较多系统资源。此外，由于线程管理是由操作系统进行的，对线程的操作（如启动、停止）不会立即得到响应，存在一定的延迟。1.2 ThreadPool
定义：ThreadPool（线程池）是并发编程中一种常用的技术，用于管理和重用线程。它由线程池管理器、工作队列和线程池线程组成，旨在提高系统性能和资源利用率优点：通过线程池管理线程，有效避免了频繁创建和销毁线程的开销，实现了线程的复用，提高了性能。缺点：虽然提供了基本的线程管理功能，但API相对简单，对于复杂的线程等待顺序控制场景支持较弱，可能不满足所有业务需求。1.3 Task
定义：Task是.NET Framework 4.0中引入的一个类，用于表示一个异步操作。它允许开发者以非阻塞的方式执行耗时的操作，从而提高应用程序的响应性和性能。线程池基础：Task是在ThreadPool（线程池）的基础上推出的。ThreadPool中有一定数量的线程，当有新任务需要处理时，会从线程池中获取一个空闲的线程来执行任务。任务执行完毕后，线程不会被销毁，而是被线程池回收以供后续任务使用。优点：Task继承了ThreadPool的优点，同时提供了更为丰富和灵活的线程控制API，提供了一种简洁的异步编程模型，使得开发者能够更容易地编写、理解和维护异步代码。。1.4 使用多线程场景
适用场景：当任务可以并发执行时，使用多线程可以显著提高程序的执行效率。例如，在大型项目中，可能需要同时从多个数据源（如数据库、缓存、第三方接口）获取数据，这时开启多个线程并行查询可以大幅减少等待时间。
用户界面(UI)响应性提升：
在图形用户界面(GUI)应用程序中，如果某个操作（如文件加载、数据计算或网络请求）需要较长时间才能完成，使用多线程可以避免阻塞UI线程，从而保持用户界面的响应性。用户可以继续与应用程序交互，而无需等待长时间运行的任务完成。
并行处理大量数据：
当需要处理大量数据时，可以将数据分割成小块，并使用多线程或线程池并行处理这些小块。这样可以显著减少处理时间，提高程序的效率。例如，在大数据处理、图像处理或科学计算等领域中，并行处理尤为重要。
网络通信：
在网络应用程序中，如服务器应用程序，可能需要同时处理多个客户端的请求。使用多线程可以使得服务器能够同时为多个客户端提供服务，提高了服务器的并发处理能力。
多任务并发执行：
在一些应用程序中，可能需要同时执行多个独立的任务。例如，一个游戏可能需要同时处理用户输入、图形渲染、音频播放和物理模拟等多个任务。通过将这些任务分配给不同的线程，可以实现更好的并发性和性能。
后台任务处理：
在需要执行一些不紧急但耗时的后台任务时（如日志记录、数据备份、定时任务等），可以使用多线程来执行这些任务，从而避免对主程序流程的影响。
资源密集型任务：
当程序需要执行一些CPU密集型或I/O密集型任务时，使用多线程可以更有效地利用多核CPU的资源，或同时处理多个I/O操作，提高整体性能。
模拟并发用户：
在测试阶段，为了模拟真实环境中的高并发场景，可以使用多线程来模拟多个用户同时访问系统，从而评估系统的并发处理能力和性能表现。
实时系统：
在一些对实时性要求较高的系统中（如实时监控系统、实时交易系统等），使用多线程可以确保系统能够及时处理各种事件和请求，保证系统的实时性。
2.Task创建任务方式
2.1先创建后执行
首先通过new Task关键字创建一个Task实例，并传入一个表示任务体的lambda表达式或委托。然后通过调用Start方法来启动该任务。
Task task = new Task(() => {
// 方法体
});
task.Start();
2.2创建并执行
使用Task.Run方法可以直接创建并启动一个任务。Task.Run方法内部会调用Task.Factory.StartNew，但它提供了更简洁的语法，并且默认使用线程池中的线程来执行任务。
Task task =Task.Run(() => {
// 方法体
});
2.3使用TaskFactory
TaskFactory 类是一个高级工厂，用于创建和启动 Task 和 Task 实例。使用 TaskFactory 可以更灵活地控制任务的创建和启动方式，包括设置任务的取消令牌、任务创建选项以及任务的父子关系等。
通过TaskFactory的StartNew方法可以创建并启动一个任务。TaskFactory提供了比Task.Run更多的配置选项，例如可以指定任务的创建选项、调度程序等。
TaskFactory taskFactory = Task.Factory;
Task task = taskFactory.StartNew(() => {
// 方法体
});
2.4延时执行
可以使用Task.Delay方法创建一个在指定时间后执行的Task，并通过ContinueWith来指定延时后的操作。
Task task = Task.Delay(2000).ContinueWith(t => {
// 方法体
});
3 Task常用的API
Task.Run(Action action): 在ThreadPool上排队一个任务以执行指定的操作。Task.WhenAll(Task[] tasks): 创建一个任务，该任务将在提供的所有任务完成后完成。Task.WhenAny(Task[] tasks): 创建一个任务，该任务将在提供的任务之一完成时完成。Task.Delay(int millisecondsDelay): 返回一个表示已完成的延迟的Task。Task.ContinueWith(Func
Task.Wait 是 Task 的一个实例方法，用于等待 Task 完成，如果 Task 未完成，会阻塞当前线程。非必要情况下，不建议使用 Task.Wait，而应该使用 await。
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();
}
输出结果：
主线程1开启
Task1 开启线程3处理业务 //（等待10秒）
Task2 开启线程3处理业务 //（等待5秒）
Task3 开启线程4处理业务 //（几乎立即，因为只等待了500毫秒）
Task4 开启线程3处理业务 //（等待2秒）
主线程1完成
3.1.1Task.Wait导致的问题
死锁：
在 UI 或 ASP.NET 上下文中，Task.Wait（或 Task
阻塞线程：Task.Wait 会阻塞调用它的线程，直到任务完成。如果任务需要很长时间才能完成，或者如果有很多这样的等待操作，那么这可能会导致性能问题，因为宝贵的线程资源被浪费了。
异常处理复杂：
当使用 Task.Wait 时，如果任务抛出异常，那么这些异常会在 Wait 方法返回后被封装在 AggregateException 中抛出。这增加了异常处理的复杂性，因为你需要检查 AggregateException 的内部异常。相比之下，使用 await 可以更直接地处理异常，因为 await 会将任务中的异常直接抛出，就像它们是同步代码中的异常一样。
不支持取消：
虽然 Task 支持取消（通过 CancellationToken），但 Task.Wait 方法本身并不直接支持取消等待操作。你可以通过传递一个 CancellationToken 给 Task.Run 或任务本身，并在任务内部检查取消请求，但 Wait 方法本身不会因为取消请求而提前返回。
难以调试：
由于 Task.Wait 可以导致死锁和阻塞线程，这可能会使调试异步代码变得更加困难。线程可能看似“挂起”而没有明显的原因，尤其是在复杂的并发场景中。
为了避免这些问题，建议使用 async 和 await 关键字来编写异步代码。这些关键字提供了一种更自然、更简洁的方式来处理异步操作，同时避免了 Task.Wait 带来的许多问题。async 方法会隐式地返回一个 Task 或 Task
3.2Task.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();
}
输出结果：
主线程1开启
主线程1完成
Task1 开启线程3处理业务 //task3是最快完成的,因为它只睡眠了500毫秒
Task4 开启线程6处理业务 //
Task2 开启线程4处理业务
Task3 开启线程5处理业务
Task3 后续执行9处理业务
3.3Task.WaitAll
同Task.WaitAll，等待任何一个任务完成就继续向下执行，将上面的代码WaitAll替换为WaitAny
即当task,task2,task3…N任意一个任务都执行完成之后就会往下执行代码，
task.WaitAny等到其中一个任务完成之后，才进行主线程的下一步操作，其中任务没有完成之前也阻塞主线程；
3.4Task.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.Factory.ContinueWhenAll(list1.ToArray (),tasks =>
{
Console.WriteLine($"任务执行结束");
});
Console.WriteLine($"主线程{Thread.CurrentThread.ManagedThreadId}完成");
Console.ReadLine();
}
输出结果：
主线程1开启
主线程1完成
Task1 开启线程3处理业务
Task3 开启线程8处理业务
Task2 开启线程4处理业务
Task4 开启线程9处理业务
3.5Task.Factory.ContinueWhenAny
当参数中的任务有一个完成之后就进行回调，执行下一个任务。
Task.Factory.ContinueWhenAny方法等其中的任务有一项完成之后就立即返回，调用后续业务，不阻塞主线程；实际开发中建议使用ContinueWhenAny、ContinueWhenAll不阻塞线程，尤其是在UI界面开发中
3.6Task.Delay与Thread.Sleep的区别
这两个函数，实际工程中也经常用到，都表示延期执行某个功能，但是 Thread.Sleep在延期时间内会阻塞主线程，例如：Thread.Sleep(5000)，在UI界面中会卡顿界面5秒，界面无法执行其他操作，原因是Thread属性IsBackground默认为前台线程，Task.Delay(5000)延时期间不会阻塞主线程
4.Task任务取消
在C#中，你可以使用CancellationToken来取消Task。你需要将CancellationToken作为参数传递给任务，并在任务内部定期检查是否已请求取消。
static async Task Main(string[] args)
{
var cts = new CancellationTokenSource();
// 启动一个长时间运行的任务
var task = LongRunningOperation(cts.Token);
// 假设在一段时间后取消任务
await Task.Delay(2000);
cts.Cancel();
try
{
await task;
}
catch (OperationCanceledException)
{
Console.WriteLine("任务已取消");
}
}
static async Task LongRunningOperation(CancellationToken cancellationToken)
{
for (int i = 0; i < 10; i++)
{
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
Console.WriteLine($"正在执行... {i}");
await Task.Delay(1000, cancellationToken); // 注意这里也传递了cancellationToken
}
}
输出结果：
正在执行...0
正在执行...1
正在执行...2 //之后退出程序
5.线程同步、异步
5.1线程同步
常见例子：我们吃饭用手机点菜的时候，多个人同时点菜，在最后结账的时候，如果大家都争着买单，那如果没有同步信息，就会造成多个人都买单成功。这就是线程同步的问题之一。
所谓的同步，即按照代码的顺序执行，也就是用同一个线程来执行所有的操作，或者多个线程按顺序执行，例如***4.1 实例方法.wait()***中的部分，多个线程按顺序执行。有序性：主要针对程序的执行顺序来说.比如单线程编程中，A();B(); ，必须等待A方法执行完了，B方法才可以执行.再比如,lock(sync){A();},无论多少个线程调用这段代码，A方法在同一个时刻只允许一个线程调用，其它线程必须等待一致性：主要针对数据来说.我们必须确保对临界区数据的变更不会影响其它线程.比如说，A线程和B线程在某一段时间都对data进行修改，线程之间共享变量可能会造成死锁的现象，为避免出现两个线程同时修改，后者的修改将前者的修改覆盖掉，我们对data的修改进行加锁,这样data一次只会允许一个线程进行修改.也就保证了数据的一致性.
线程安全：多线程执行结果与单线程一致，线程安全
线程不安全：多线程同时修改一个变量；或者一个线程修改，一个线程读取，则可能出现BUG
在多线程问题的处理上，我们是在异步中谋求同步的目的，以确保程序的安全
线程同步的方法常见的主要有锁 SpinLock 、Mutex、Monitor、lock。以下仅介绍最常用的Monitor、lock方法
5.1.1lock方法
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();
}
}
输出结果：
线程四------票数10
线程二------票数9
线程一------票数8
线程三------票数7
线程四------票数6
线程二------票数5
线程一------票数4
线程三------票数3
线程四------票数2
线程二------票数1
说明：4个线程调用的是同一个函数，同一时间，一次只允许一个线程进入，每次执行将票数减一，线程执行的顺序尽管是无序的，但是执行的“票数”都是在上一次的结果上减1。
倘若注释同步代码，即//lock (this) //锁定代码快，以便线程同步，执行结果如下图所示，同一时间，多个线程进入同一函数，线程顺序无序，执行结果也无序，“票数3”同时被“线程四”和“线程一”执行。
现实情况中，当不考虑退票时，票数应该是越卖越少，且不会出现多人购买同一张票都成功的现象。如果不使用线程同步的写法，得不到想要的功能。
线程一------票数10
线程二------票数9
线程四------票数8
线程三------票数7
线程一------票数6
线程二------票数5
线程四------票数4
线程三------票数3
线程一------票数2
线程二------票数1
5.1.2monitor类
Monitor类提供了与lock类似的功能,不过与lock不同的是,它能更好的控制同步块,当调用了Monitor的Enter(Object o)方法时,会获取o的独占权,直到调用Exit(Object o)方法时,才会释放对o的独占权。
可以使用 TryEnter() 方法可以给它传送一个超时值，决定等待获得对象锁的最长时间，该方法能在指定的毫秒数内结束线程，这样能避免线程之间的死锁现象。
5.2线程异步
异步与同步概念：当一个方法被调用时，调用者需要等待该方法执行完毕并返回才能继续执行，我们称这个方法是同步方法；当一个方法被调用时立即返回，并获取一个线程执行该方法内部的业务，调用者不用等待该方法执行完毕，我们称这个方法为异步方法
异步方法的优点：异步线程最大的好处在于非阻塞，即各线程之间执行任务时，互不干扰，当任务完成之后就可立即响应，不需等待其他任务是否执行完成。异步编程中最好用的便是 async和await 。
在C#5.0中出现的 async和await ，让异步编程变得更简单，用同步的写法写异步，同步代码的逻辑结构
线程异步与多任务执行关系：异步是同时执行多个任务，而Task则是允许多个任务可以在线程内同时进行，多任务的同时进行，则是由异步来进行，而异步方法，必须为Task
5.2.1控制台应用async和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);
}
});
}
}
输出结果有两种执行结果，未阻塞主线程，两次执行结果，S在上或者T在上，这是任务内部无序执行的结果：
开始
结束
T 0
T 1
T 2
T 3
T 4
T 5
T 6
T 7
T 8
T 9
S 0
S 1
S 2
S 3
S 4
S 5
S 6
S 7
S 8
S 9
或者：
开始
结束
S 0
S 1
S 2
S 3
S 4
S 5
S 6
S 7
S 8
S 9
T 0
T 1
T 2
T 3
T 4
T 5
T 6
T 7
T 8
T 9
加上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);
}
});
}
}
输出结果：
开始
结束
T 0
T 1
T 2
T 3
T 4
T 5
T 6
T 7
T 8
T 9
S 0
S 1
S 2
S 3
S 4
S 5
S 6
S 7
S 8
S 9
6.多线程异常处理
6.1单线程异常与多线程异常比对
单线程处理：try-catch，catch中进6行异常处理，捕捉异常----处理异常
try
{
{
//捕捉异常
}
}
catch
{
{
throw;
//处理异常
}
}
多线程处理：无法直接用try-catch包裹
在C#项目中处理多线程时的异常需要特别注意，因为每个线程都可能在执行过程中遇到错误，而这些错误如果不被适当处理，可能会导致程序的不稳定或数据损坏。以下是一些在C#项目中处理多线程异常的策略和技巧：
1. 使用try-catch块
最直接的方法是在每个线程的执行体（例如，在Thread的Start方法中指定的ThreadStart委托，或在Task的Run方法中）使用try-catch块来捕获并处理异常。
Thread thread = new Thread(() =>
{
try
{
// 线程执行的代码
throw new InvalidOperationException("这是一个异常");
}
catch (Exception ex)
{
// 处理异常
Console.WriteLine($"线程异常: {ex.Message}");
}
});
thread.Start();
对于使用Task的情况，异常处理稍微复杂一些，因为Task的异常不会直接传播到创建它的线程中，而是需要通过Task.Wait、Task.Result（这会阻塞调用线程并抛出异常）或Task.ContinueWith（无论任务成功完成还是抛出异常都会执行）来捕获。
2. 使用Task的异常处理
当使用Task时，通常推荐的方式是调用Task.ContinueWith来处理异常，或者使用async和await（这将自动传播异常）。
Task.Run(() =>
{
// 可能会抛出异常的代码
throw new InvalidOperationException("Task中的异常");
})
.ContinueWith(task =>
{
if (task.IsFaulted)
{
AggregateException ae = task.Exception;
foreach (var ex in ae.InnerExceptions)
{
Console.WriteLine($"Task异常: {ex.Message}");
}
}
}, TaskContinuationOptions.OnlyOnFaulted);
使用async和await时，异常会自动传播到await表达式之后的代码中。
async Task DoWorkAsync()
{
try
{
await Task.Run(() =>
{
// 可能会抛出异常的代码
throw new InvalidOperationException("Task中的异步异常");
});
}
catch (Exception ex)
{
Console.WriteLine($"捕获到异步异常: {ex.Message}");
}
}
6.2单线程与多线程的异常处理
单线程异常处理代码：
//单线程异常处理
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;
}
}
点击单线程异常处理按钮后：
多线程异常处理代码：
//多线程异常处理
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;
}
}
点击多线程异常处理按钮：
6.3多线程异常捕捉与处理
那么多线程内部发生的异常如何捕捉？需实现以下2大条件
1.需要做线程的等待,例如task.waitall，即阻塞主线程
2.try-catch包裹
将上述多线程的代码改写成如下形式：
private void button2_Click(object sender, EventArgs e)
{
try
{
List
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;
}
}
点击多线程异常处理按钮：
上述例子中多线程出现3个异常，只用了一个“try-catch”结构，集中显示异常情况，对于异常查看并不方便，解决上述问题，采用如下方式。1.一个try可以对应多个catch
2.AggregateException捕获异常，多线程特有异常捕获，AggregateException继承至Exception，Exception子类，AggregateException内部包含多线程集合