1、简介
为什么MS要推出Task,而不推Thread和ThreadPool,以下是我的见解:
(1)、Thread的Api并不靠谱,甚至MS自己都不推荐,原因,它将整个Thread类都不开放给Windows Sotre程序,且它的Api过于强大,如果在程序中过度使用,维护的成本太高,想想代码中充斥着挂起线程,阻塞线程、后期的应用程序很难维护.
(2)、ThreadPool最大的问题是,所有的辅助线程都是异步的,没有向Thread的Join方法那样去等待一个线程执行完,然后执行回调函数的机制,也就是你无法判断线程什么时候执行完,也没有机制获得线程的返回值,所有MS推出了Task来解决Thread和ThreadPool的问题
当然最主要的是,Thread和Thread好用.因为Task是它们的升级版,升级版当然比较好.
2、Task的缺点
虽然Task以其强大的Api,以及封装,让我们在CLR环境下,能完成高效率的编程,但是它并不是没有缺点的,高效率的背后,肯定带来的性能的损失,这一点很多类似的框架都能说明,比如EF,强大的背后,大量的使用了反射等操作,所以虽然开发效率提升了,但是性能却下降了,这里不想说太多,所以简单的api可能不会产生过多的性能损耗,所以这也是为什么大型互联网项目,更愿意使用原生Ado或者Dapper去做.所以这些在我们的实际开发中,这些都需要我们去权衡.有得必有失.下面来简单的说下Task具体在哪里会产生性能损失:
很直观,直接分析ThreadPool类和Task类的构造:
ThreadPool类
很简洁,没有任何的字段和属性!
Task类，1700行代码,里面有大量的字段和属性,大致如下:
还包括对父任务的引用、任务调度器(TaskScheduler)的引用、对回调方法的引用、对执行上下文(ExecutionContext)的引用、对ManualResetEventSlim信号量的引用、还有CancellationToken取消信号量(我把它理解为信号量)的引用、一个ContinueWithTask的任务集合的引用、还有未抛出异常的Task对象集合的引用等等,这些后面的文章都会介绍.
所以,不分析具体的性能损耗点,但是单单两个类的构造,你就能清楚使用那个类创建线程所产生的性能消耗大.
3、实战
(1)、不带返回值,实现和ThreadPool线程池线程一样的效果
static void Main(string[] args)
{
var result=Task.Run(() => Calculate("这个参数很六啊"));
Console.WriteLine("主线程有没有在继续执行,look look");
Console.ReadKey();
} static void Calculate(string param)
{
Console.WriteLine("子线程开始执行,带着主线程给它传递的参数呢!参数是:{0}",param);
Thread.Sleep();
Console.WriteLine("子线程执行完了");
}
根据输出,发现主线程并没有等带子线程执行完毕,通过开启一个新线程之后,立刻返回去执行它自己的任务.
(2)、带返回值
static void Main(string[] args)
{
var result=Task.Run(() => Calculate());
Console.WriteLine(result.Result);
Console.WriteLine("主线程有没有在继续执行,look look");
Console.ReadKey();
} /// <summary>
/// 简单递归计算n+(n-1)+.....+1
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
static int Calculate(int param)
{
if (param == )
return ;
return param + Calculate(param - );
}
无论给Calculate方法传递的参数多小,主线程都等待子线程返回结果后,在继续执行它的任务.所以可以得出结论.调用子线程返回值的Result属性
相等于调用了Wait方法,当然Task确实提供了这个实例方法,但是使用Result属性一样有这个效果.主线程会等待子线程执行完毕在执行它的任务.
(3)、关于Task的小要点
当主线程通过Task开启了一个子线程之后,返回做自己的事情,当它执行到Wait方法,这个时候主线程会阻塞,CPU的执行速度很快,所以它会去判断子线程有没有开始执行,如果没有执行,那么它会自己去做子线程的任务,而不是开启一个新的线程去做.这样就节约了系统资源.这样就不会存在线程阻塞的情况.所有事情都由主线程干完.
(4)、关于简单的死锁问题
一般死锁的产生,都是多线程争用相同的资源导致的.下面就来重现一下.
private static object lockObj = new object();
static void Main(string[] args)
{
var result=Task.Run(() => Calculate());
lock (lockObj)
{
Console.WriteLine("主线程这个时候争用了lockObj锁,并执行子线程");
Console.WriteLine(result.Result);
}
Console.WriteLine("主线程有没有在继续执行,look look");
Console.ReadKey();
} /// <summary>
/// 简单递归计算n+(n-1)+.....+1
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
static int Calculate(int param)
{
lock (lockObj)
{
Console.WriteLine("子线程这个时候也去争用lockObj锁,发现主线程已经争用了这个锁,那么它等待主线程释放这个锁,但是主线程正等待它执行完!");
Console.WriteLine("好了,这个时候就发生了死锁现象.主线程等子线程执行完,子线程等主线程释放lockObj锁,两个线程在相互等待,死锁了");
}
if (param == )
return ;
return param + Calculate(param - );
}
光标一直在那闪啊闪,好吧,那就都等着吧.谁都执行不下去了.
解决办法很简单.在创建一个新的锁,这个就不代码演示了.
(5)、取消Task创建的子线程
取消Task创建的线程和取消ThreadPool创建的子线程一样,通过CancellationTokenSource类实现,代码如下:
var cancellationSource = new CancellationTokenSource();
cancellationSource.Cancel();
try {
Task.Run(() => ChildThread(cancellationSource.Token));
}
catch(AggregateException ex)
{
//处理子线程抛出的异常
ex.Handle((x) => x is OperationCanceledException);
}
Console.WriteLine("主线程继续做它的事情");
Console.ReadKey();
} /// <summary>
/// 子线程
/// </summary>
static void ChildThread(CancellationToken token)
{
token.ThrowIfCancellationRequested();
Console.WriteLine("子线程做完了它的事情");
}
(6)、任务完成时启动新的任务 ContinueWith
当使用Task进行多线程任务开发时,不建议使用Wait方法或者Result属性,去阻塞主线程,原因如下:
i、会卡界面
ii、伸缩性好的软件,不会这么做,除非迫不得已
iii、很有可能创建新的线程,浪费资源(如果主线程执行的足够快,它可能自己去完成子线程的任务,而不是创建新的线程)
代码如下:
static void Main(string[] args)
{
//开启一个子线程进行计算操作
var watch = Stopwatch.StartNew();
Task<int> task=Task.Run(() => ChildThreadOne());
//当子线程一计算完毕之后,开启一个新的线程去执行输出子线程一的结果,这里新的线程不会阻塞
//只有当子线程完成计算输出后,它才会开启,并输出子线程的值
//所以该程序并不会发生线程阻塞的情况
task.ContinueWith(x =>
{
watch.Stop();
Console.WriteLine("输出子线程一的返回值:{0},耗时:{1}", task.Result, watch.ElapsedMilliseconds / );
}); Console.WriteLine("主线程继续做它的事情");
Console.ReadKey();
} /// <summary>
/// 子线程一
/// </summary>
/// <returns></returns>
static int ChildThreadOne()
{
Thread.Sleep();//模拟长时间运算
return ;
}
这里注意两点:
(1)、这里ContinueWith会检测到子线程完成之后,立即启动一个新的线程去显示结果.不会存在子线程还没有完成计算的情况下,输出一个空值,或者发生异常,这一点,CLR能保证.
(2)、这里ContinueWith会返回一个Task对象示例,所以可以调用Wait方法,或者Result属性,单一般不建议这么做,还是那句话会阻塞线程.一般都忽略这个Task实例,所以需要谨慎使用.
static void Main(string[] args)
{
Task<int> task = Task.Run(() => ChildThreadOne());
var t1=task.ContinueWith((x) => ChildOneContinueOne(task.Result));
var t2=task.ContinueWith((x) => ChildOneContinueTwo(task.Result));
t1.ContinueWith(x => { Console.WriteLine("输出子线程一的计算结果加10后的结果值:{0}", t1.Result); });
t2.ContinueWith(x => { Console.WriteLine("输出子线程一的计算结果乘10后的结果值:{0}", t2.Result); });
Console.WriteLine("主线程继续做它的事情");
Console.ReadKey();
} /// <summary>
/// 子线程一
/// </summary>
/// <returns></returns>
static int ChildThreadOne()
{
Thread.Sleep();//模拟长时间运算
return ;
} /// <summary>
/// 在子线程一完成计算后,开启一个新的线程对子线程一的结果进行+66操作
/// </summary>
/// <param name="childOneResult"></param>
/// <returns></returns>
static int ChildOneContinueOne(int childOneResult)
{
Console.WriteLine("ChildOneContinueOne线程拿到的子线程一的结果值为{0}", childOneResult);
Thread.Sleep();//模拟长时间计算任务
return + childOneResult;
} /// <summary>
/// 在子线程一完成计算后,开启一个新的线程对子线程一的结果进行乘66操作
/// </summary>
/// <param name="childOneResult"></param>
/// <returns></returns>
static int ChildOneContinueTwo(int childOneResult)
{
Console.WriteLine("ChildOneContinueTwo线程拿到的子线程一的结果值为{0}", childOneResult);
Thread.Sleep();//模拟长时间计算任务
return * childOneResult;
}
用ContinueWith做了一件有趣的事情,大致思路是我们在开发过程中会遇到,到我们拿到一个线程的返回值后,立即开启两个新的线程去做两个方向的任务,如下图:
这在开发中经常使用,整个过程没有任务阻塞线程.暂时没有发现多线程争用问题.
原理浅析:
Task对象实例包含一个ContinueWith任务的一个集合,所以可以使用Task对象多次调用ContinueWith方法(就像上面的代码一样),所有的线程都会进入线程池的队列中,当Task任务执行完毕,线程池回依次调用它们.
(2)、使用ContinueWith中产生的特殊情况
当子线程发生异常、取消、或者超时时,这个时候就要告诉线程池如何处理唤起线程,而不是无视,子线程的异常,所以MS给ContinueWith提供了一个TaskContinuationOptions枚举,来处理这个问题.下面介绍几个常用的.
TaskContinuationOptions.OnlyOnRanToCompletion 主要当前面的任务,完美的完成任务,才能执行延续任务.
class Program
{
static void Main(string[] args)
{
Task<int> task = Task.Run(() => ChildThreadOne());
task.ContinueWith(t => Console.WriteLine("子线程一的延续任务,只有在子线程一完美的完成的任务的情况下,才会执行"), TaskContinuationOptions.OnlyOnRanToCompletion);
Console.WriteLine("主线程继续执行它的操作");
Console.ReadKey();//必须加这行代码,因为Task时线程池线程,属于后台线程
} /// <summary>
/// 子线程一
/// </summary>
static int ChildThreadOne()
{
Thread.Sleep();//模拟执行长时间计算任务
Console.WriteLine("子线程一完成了计算任务,返回值6");
return ;
}
}
这里,看着,让子线程一抛出异常,看看延续任务会不会继续执行.
static void Main(string[] args)
{
Task<int> task = Task.Run(() => ChildThreadOne());
task.ContinueWith(t => Console.WriteLine("子线程一的延续任务,只有在子线程一完美的完成的任务的情况下,才会执行"), TaskContinuationOptions.OnlyOnRanToCompletion);
Console.WriteLine("主线程继续执行它的操作");
Console.ReadKey();//必须加这行代码,因为Task时线程池线程,属于后台线程
} /// <summary>
/// 子线程一
/// </summary>
static int ChildThreadOne()
{
Thread.Sleep();//模拟执行长时间计算任务
Console.WriteLine("子线程一完成了计算任务,返回值6");
throw new Exception("模拟抛出异常");
}
因为子线程一抛出了异常,所以延续任务没有执行.这里取消线程,也不会执行延续任务,因为MS为了区分Task的任务完成和任务取消,选择让取消的任务抛出OperationCanceledException异常,所以和抛出简单一样,延续任务并不会执行.超时同理.
TaskContinuationOptions.OnlyOnFaulted 当前面的任务抛出未处理的异常是,执行延续任务.
static void Main(string[] args)
{
CancellationTokenSource source = new CancellationTokenSource();
Task<int> task = Task.Run(() => ChildThreadOne(source.Token));
task.ContinueWith(t =>
{
Console.WriteLine("子线程一的延续任务,只有在子线程一抛出了未处理的异常,才会执行,这里尝试处理抛出的异常");
//一般记日志,Logger.Error("");
task.Exception.Handle(x =>
{
Console.WriteLine("最好在这里就处理掉异常,以免让外部try canth捕获到,并处理产生的性能损失");
if (x is OperationCanceledException)
{
Console.WriteLine("子线程一抛出了取消异常,异常信息为{0}", x.Message);
}
else {
Console.WriteLine("子线程一抛出了一般异常,异常信息为{0}", x.Message);
} return true;//返回true,告诉CLR异常已被处理,这样外部try catch就捕获不到了.
});
}, TaskContinuationOptions.OnlyOnFaulted);
Console.WriteLine("主线程继续执行它的操作");
source.Cancel();
Console.ReadKey();//必须加这行代码,因为Task时线程池线程,属于后台线程
} /// <summary>
/// 子线程一
/// </summary>
static int ChildThreadOne(CancellationToken cancellation)
{
Thread.Sleep();//模拟执行长时间计算任务
Console.WriteLine("子线程一完成了计算任务,返回值6");
cancellation.ThrowIfCancellationRequested();//抛出取消异常
return ;
}
这里建议对TaskContinueWith做一个封装,让它能处理不同的异常,并且这样异常,能在内部就被全部处理掉,而不需要在外部进行try catch处理,并且有一个友好的异常记录和输出.这里我就不做了,有需要的可以联系我.
ok,这里就介绍TaskContinuationOptions常用的两个值,其余的用法都差不多,可以看Ms的提供的备注,或者参看MSDN,这里就不全介绍了.