《侠盗飞车5》（GTA 5）主线任务攻略第六篇
来源：Xbox Life编辑：
& =垃圾车=
& 完美达成条件：
& ‧时间－在5分钟内完成。
& ‧毫发无伤－将垃圾大王毫发无伤的送到。
& ‧随风而去－驾驶垃圾大王达到极速。
& 前往指定的地点时会看到清洁员正在清运垃圾，一样先用潜行把清洁员击昏，以免抢了车之后触发通缉状态，接着开着抢来的垃圾车直接停到FIB 的停车场内。
& 完美达成条件：
& ‧变脸时间－在20秒内购买所有面具。
& ‧陈腔滥调－为每个角色购买一顶白色曲棍球面具。
& 到海滩附近的服饰店买三顶用来隐藏身分的面具，直接在白色曲棍球面具的选项上连点三次就是了。
& 上述的四个准备任务都完成之后，最后还得偷一辆适合用来逃亡的汽车，并将它停放在隐密的地点，抢劫任务的地点在干船坞街附近，可以寻找就近的地点藏匿。向你的伙伴们确认过藏车的位置之后，就能够开始进行抢劫任务了。
友情提示：支持键盘左右键← →翻页
游戏类别：
游戏平台：/PC/PS3/Xbox360/PS4/XboxOne/
开发商：Rockstar Games
发行商：Rockstar Games
发行时间：日
游戏介绍：《侠盗飞车5（GTA5）》是知名动作冒险游戏侠盗飞车系列第五部，侠盗飞车系列历来都是以黑帮生活为背景，是一款犯罪类游戏，侠盗飞车5主人公自然与黑道脱不了干系，游戏舞台是以洛杉矶为蓝本制作的。游戏采用新版雷霆引擎（RAGE引擎），该引擎需要DirectX 11的支持。侠盗飞车5不支持Windows XP系统，并且游戏对64位操作系统下的运行进行了优化。在GTA5中游戏元素将会得到增强，加入了更加开放自由的世界，以故事驱动，以任务为准的游戏玩法和多人模式。故事主题聚焦金钱永不眠的南加利福尼亚。
开发商自然不希望他们的游戏被盗版，然而最近发售的几款采用D加密的大作都被秒破，曾经号称最强加密技术的Denuvo显然已形同虚设，让开发商蒙受了不小的损失。而随着《仁王》PC版宣布放弃使用D加密，Denuvo如果没有后手，以后的日子会越来越难过。好了回归正题，下面是最新一期爆笑内涵?图，一起来欣赏下吧。
话说还有十几天的时间双十一就要到了，这个节日本来是给单身狗过的，但是现在却变成了电商打折活动。单身狗倒是没受什么影响，但有女票的小伙子就遭了殃！也不知道是单身狗的错，还是这些败家娘们脑子不好使。唉！不闲扯了，来看新一期的爆笑动图吧！
死亡宣告的事情告诉我们，电竞职业选手技术虽然重要，但人品显然才是最要紧的！好了，不多说了！一起来看一下今天的爆笑动图吧！
昨天LOL选手死亡宣告直播时心态爆炸，竟然在镜头前毒打老婆，小编觉得“电竞拳皇”药丸，不知道大家怎么看？好了回归正题，下面是今天的爆笑内涵?图，一起来欣赏下吧。
话说今天听到了一个消息，百年老字号“麦当劳”要改名了，以后直接叫“金拱门”就可以了，形象贴切又好记！嗯！另外我们的动图现在也改版了，以后我们每天都会更新，给大家带来最新最有趣的搞笑图片！
最近国产沙盒游戏《幻》发布官方公告，在文中直言不讳地痛斥喷子、黑粉毁了《幻》（传送门），不知道大家怎么看？好了回归正题，下面是最新一期爆笑内涵?图，一起来欣赏。
英雄联盟2017全球总决赛半决赛将于今天下午3点半在上海打响，全华班RNG迎战三冠王SKT，哪支队伍能获得前往鸟巢的机会？队长当然希望RNG赢，但是这里就不奶了，下面是最新一期爆笑内涵?图，一起来欣赏下吧。
今天下午的LOL S7半决赛，全村人的希望WE将对战韩国三星战队，在这里队长预祝他们一路向北，在鸟巢决战烧烤摊SKT。下面是最新一期?图，一起来看看吧。
在昨晚的LOL-S7半决赛中，RNG以2比3憾负于强敌SKT，止步四强！虽然有点可惜，不过RNG表现的还是很不错的！好了，不多说了！下面一起来看看今天的爆笑动图吧！
最近的LOL电竞圈儿相当不平静，先是黄牛哄抬S7门票票价闹得沸沸扬扬，紧接着就是笑笑与五五开决裂、死亡宣告打女友接连上热搜，可谓是风波四起。但无论他们怎么闹，大家最关心的还是这两天的S7比赛，让我们一起认真开比赛，为LPL队伍加油助威吧！
48小时热点资讯
热门手游推荐　　在上篇最后一个例子之后，我们发现了怎么去使用线程池，调用ThreadPool的QueueUserWorkItem方法来发起一次异步的、计算限制的操作，例子很简单，不是吗？
　　然而，在今天这篇博客中，我们要知道的是，QueueUserWorkItem这个技术存在许多限制。其中最大的问题是没有一个内建的机制让你知道操作在什么时候完成，也没有一个机制在操作完成是获得一个返回值，这些问题使得我们都不敢启用这个技术。
　　Microsoft为了克服这些限制（同时解决其他一些问题），引入了任务（tasks）的概念。顺带说一下我们得通过System.Threading.Tasks命名空间来使用它们。
　　现在我要说的是，用线程池不是调用ThreadPool的QueueUserWorkItem方法，而是用任务来做相同的事：
static void Main(string[] args)
Console.WriteLine("主线程启动");
//ThreadPool.QueueUserWorkItem(StartCode,5);
new Task(StartCode, 5).Start();
Console.WriteLine("主线程运行到此！");
Thread.Sleep(1000);
private static void StartCode(object i)
Console.WriteLine("开始执行子线程...{0}",i);
Thread.Sleep(1000);//模拟代码操作
嘿，你会发现结果是一样的。再来看看这个是什么：
TaskCreationOptions这个类型是一个枚举类型，传递一些标志来控制Task的执行方式。TaskCreationOptions定义如下：
慢点，注释很详细，看看这些有好处，TaskScheduler（任务调度器）不懂没关系，请继续往下看，我会介绍的，但请注意，这些标识都只是一些提议而已，在调度一个Task时，可能会、也可能不会采纳这些提议，不过有一条要注意：AttachedToParent标志，它总会得到Task采纳，因为它和TaskScheduler本身无关。
　　来看下这段代码:
static void Main(string[] args)
//这个数字会抛出System.AggregateException
Task&Int32& t = new Task&Int32&(n =& Sum((Int32)n), );
//可以现在开始，也可以以后开始
t.Start();
//Wait显式的等待一个线程完成
Console.WriteLine("The Sum is:"+t.Result);
private static Int32 Sum(Int32 i)
Int32 sum = 0;
for (; i & 0; i--)
checked { sum += }
　　这段代码大家应该猜得出是什么意思吧，人人都会写。　　但是，我的结果为什么是t.Result而不直接是返回的Sum呢？& 有没有多此一举的感觉？
下面我来说说这段代码我想表达的意思：
　　在一个线程调用Wait方法时，系统会检查线程要等待的Task是否已经开始执行，如果任务正在执行，那么这个Wait方法会使线程阻塞，知道Task运行结束为止。
　　就说上面的程序执行，因为累加数字太大，它抛出算术运算溢出错误，在一个计算限制任务抛出一个未处理的异常时，这个异常会被&包含&不并存储到一个集合中，而线程池线程是允许返回到线程池中的，在调用Wait方法或者Result属性时，这个成员会抛出一个System.AggregateException对象。
　　现在你会问，为什么要调用Wait或者Result？或者一直不查询Task的Exception属性？你的代码就永远注意不到这个异常的发生，如果不能捕捉到这个异常，垃圾回收时，抛出AggregateException，进程就会立即终止，这就是&牵一发动全身&，莫名其妙程序就自己关掉了，谁也不知道这是什么情况。所以，必须调用前面提到的某个成员，确保代码注意到异常，并从异常中恢复。悄悄告诉你，其实在用Result的时候，内部会调用Wait。
　　怎么恢复？
　　为了帮助你检测没有注意到的异常，可以向TaskScheduler的静态UnobservedTaskException时间等级一个回调方法，当Task被垃圾回收时，如果出现一个没有被注意到的异常，CLR终结器会引发这个事件。一旦引发，就会向你的时间处理器方法传递一个UnobservedTaskExceptionEvenArgs对象，其中包含了你没有注意的AggregateException。然后再调用UnobservedTasExceptionEvenArgs的SetObserved方法来指出你的异常已经处理好了，从而阻止CLR终止进程。这是个图省事的做法，要少做这些，宁愿终止进程，也不要呆着已经损坏的状态而继续运行。做人也一样，病了宁肯休息，也不要带病坚持上班，你没那么伟大，公司也不需要你的这一点伟大,命是自己的。(─.─|||扯远了。
　　除了单个等待任务，Task 还提供了两个静态方法：WaitAny和WaitAll，他们允许线程等待一个Task对象数组。
　　WaitAny方法会阻塞调用线程，知道数组中的任何一个Task对象完成，这个方法会返回一个索引值，指明完成的是哪一个Task对象。如果发生超时，方法将返回-1。它可以通过一个CancellationToken取消，会抛出一个OperationCanceledException。
　　WaitAll方法也会阻塞调用线程，知道数组中的所有Task对象都完成，如果全部完成就返回true，如果超时就返回false。当然它也能取消，同样会抛出OperationCanceledException。
　　说了这么两个取消任务的方法，现在来试试这个方法，加深下印象，修改先前例子代码，完整代码如下：
static void Main(string[] args)
CancellationTokenSource cts = new CancellationTokenSource();
Task&Int32& t = new Task&Int32&(() =& Sum(cts.Token,10000), cts.Token);
//可以现在开始，也可以以后开始
t.Start();
//在之后的某个时间，取消CancellationTokenSource 以取消Task
cts.Cancel();//这是个异步请求，Task可能已经完成了。我是双核机器，Task没有完成过
//注释这个为了测试抛出的异常
//Console.WriteLine("This sum is:" + t.Result);
//如果任务已经取消了，Result会抛出AggregateException
Console.WriteLine("This sum is:" + t.Result);
catch (AggregateException x)
//将任何OperationCanceledException对象都视为已处理。
//其他任何异常都造成抛出一个AggregateException，其中
//只包含未处理的异常
x.Handle(e =& e is OperationCanceledException);
Console.WriteLine("Sum was Canceled");
private static Int32 Sum(CancellationToken ct ,Int32 i)
Int32 sum = 0;
for (; i & 0; i--)
//在取消标志引用的CancellationTokenSource上如果调用
//Cancel，下面这一行就会抛出OperationCanceledException
ct.ThrowIfCancellationRequested();
checked { sum += }
　　这个例子展示了一个任务在进行的时候中途取消的操作，我觉得它很有趣，你试试也会发现。　　Lamada表达式写这个，是个亮点，得学学，将CancellationToken闭包变量&传递&。
　　如果不用Lamada表达式，这问题还真不好解决：
　　Task&Int32& t = new Task&Int32&(() =& Sum(cts.Token,10000), cts.Token);
　　Sum(cts.Token,10000) 内的Token需要和cts.Token关联起来，你还能想出怎么关联起来么？
　　好，任务取消也讲玩了，来看个更好用的技术：
static void Main(string[] args)
Task&Int32& t = new Task&Int32&(i =& Sum((Int32)i),10000);
//可以现在开始，也可以以后开始
t.Start();
Task cwt =
t.ContinueWith(task=&Console.WriteLine("The sum is:{0}",task.Result));
cwt.Wait();
private static Int32 Sum(Int32 i)
Int32 sum = 0;
for (; i & 0; i--)
checked { sum += }
ContinueWith？& 啥东西~~？？
　　要写可伸缩的软件，一定不能使你的线程阻塞。这意味着如果调用Wait或者在任务未完成时查询Result属性，极有可能造成线程池创建一个新线程，这增大了资源的消耗，并损害了伸缩性。
　　ContinueWith便是一个更好的方式，一个任务完成时它可以启动另一个任务。上面的例子不会阻塞任何线程。
　　当Sum的任务完成时，这个任务会启动另一个任务以显示结果。ContinueWith会返回对新的Task对象的一个引用，所以为了看到结果，我需要调用一下Wait方法，当然你也可以查询下Result，或者继续ContinueWith，返回的这个对象可以忽略，它仅仅是一个变量。
　　还要指出的是，Task对象内部包含了ContinueWith任务的一个集合。所以，实际上可以用一个Task对象来多次调用ContinueWith。任务完成时，所有ContinueWith任务都会进入线程池队列中，在构造ContinueWith的时候我们可以看到一个TaskContinuationOptions枚举值，不能忽视，看看它的定义：
PrefereFairness是尽量公平的意思，就是较早调度的任务可能较早的运行，先来后到，将线程放到全局队列，便可以实现这个效果。
ExecuteSynchronously指同步执行，强制两个任务用同一个线程一前一后运行，然后就同步运行了。
看得是不是晕乎乎 ？有这么多枚举例子，怎么掌握啊？多看几次，知道任务的使用情况，以后用起来得心应手~想学新技术，就要能耐住，才能基础牢固。来看个例子，用用这些枚举。
static void Main(string[] args)
Task&Int32& t = new Task&Int32&(i =& Sum((Int32)i),10000);
t.Start();
t.ContinueWith(task=&Console.WriteLine("The sum is:{0}",task.Result),
TaskContinuationOptions.OnlyOnRanToCompletion);
t.ContinueWith(task=&Console.WriteLine("Sum throw:"+task.Exception),
TaskContinuationOptions.OnlyOnFaulted);
t.ContinueWith(task=&Console.WriteLine("Sum was cancel:"+task.IsCanceled),
TaskContinuationOptions.OnlyOnCanceled);
catch (AggregateException)
Console.WriteLine("出错");
private static Int32 Sum(Int32 i)
Int32 sum = 0;
for (; i & 0; i--)
checked { sum += }
　　ContinueWith讲完了。可是还没有结束哦。
　　AttachedToParnt枚举类型（父任务）也不能放过！看看怎么用，写法有点新奇，看看：
static void Main(string[] args)
Task&Int32[]& parent = new Task&Int32[]&(() =& {
var results = new Int32[3];
new Task(() =& results[0] = Sum(10000), TaskCreationOptions.AttachedToParent).Start();
new Task(() =& results[1] = Sum(20000), TaskCreationOptions.AttachedToParent).Start();
new Task(() =& results[2] = Sum(30000), TaskCreationOptions.AttachedToParent).Start();
var cwt = parent.ContinueWith( parentTask=&Array.ForEach(parentTask.Result,Console.WriteLine));
parent.Start();
cwt.Wait();
private static Int32 Sum(Int32 i)
Int32 sum = 0;
for (; i & 0; i--)
checked { sum += }
Oh，我都写晕了。。。(+_+)~例子中，父任务创建兵启动3个Task对象。默认情况下，一个任务创建的Task对象是顶级任务，这些任务跟创建它们的那个任务没有关系。
TaskCreationOptions.AttachedToParent标志将一个Task和创建它的那个Task关联起来，除非所有子任务（子任务的子任务）结束运行，否则创建任务（父任务）不会认为已经结束。调用ContinueWith方法创建一个Task时，可以指定TaskContinuationOptions.AttachedToParent标志将延续任务置顶为一个子任务。
　　看了这么多任务的方法操作示例了，现在来挖挖任务内部构造：
　　每个Task对象都有一组构成任务状态的字段。
　　一个Int32 ID（只读属性）
代表Task执行状态的一个Int32
对父任务的一个引用
对Task创建时置顶TaskSchedule的一个引用
对回调方法的一个引用
对要传给回调方法的对象的一个引用（通过Task只读AsyncState属性查询）
对一个ExceptionContext的引用
对一个ManualResetEventSlim对象的引用
还有没个Task对象都有对根据需要创建的一些补充状态的一个引用，补充状态包含这些：
一个CancellationToken
一个ContinueWithTask对象集合
为抛出未处理异常的子任务，所准备的一个Task对象集合
说了这么多，只想要大家知道：
　　虽然任务提供了大量功能，但并不是没有代价的。因为必须为所有的这些状态分配内存。
如果不需要任务提供的附加功能，使用ThreadPool.QueueUserWorkItem，资源的使用效率会更高一些。
Task类还实现了IDispose接口，允许你在用完Task对象后调用Dispose，不过大多数不管，让垃圾回收器回收就好。
创建一个Task对象时，代表Task唯一的一个Int32字段初始化为零，TaskID从1开始，每分配一个ID都递增1。顺带说一下，在你调试中查看一个Task对象的时候，会造成调试器显示Task的ID，从而造成为Task分配一个ID。
　　这个ID的意义在于，每个Task都可以用一个唯一的值来标识。Visual Studio会在它的&并行任务&和并行堆栈&窗口中显示这些任务ID。要知道的是，这是Visual Studio自己分配的ID，不是在自己代码中分配的ID，几乎不可能将Visual Studio分配的ID和代码正在做的事情联系起来。要查看自己正在运行的任务，可以在调试的时候查看Task的静态CurrentId属性，如果没有任务在执行，CurrentId返回null。
　　再看看TaskStatus的值，这个可以查询Task对象的生存期：
这些在任务运行的时候都是可以一一查到的，还有~判断要像这样：
1 if(task.Status==TaskStatus.RantoCompletion)...
为了简化编码,Task只提供几个只读Boolean属性：IsCanceled，IsFaulted，IsCompleted，它们能返回最终状态true/false。如果Task是通过调用某个函数来创建的，这个Task对象就会出于WaitingForActivation状态，它会自动运行。
最后我们要来了解一下TaskFactory（任务工厂）：
　　1.需要创建一组Task对象来共享相同的状态
　　2.为了避免机械的将相同的参数传给每一个Task的构造器。
满足这些条件就可以创建一个任务工厂来封装通用的状态。TaskFactory类型和TaskFactory&TResult&类型，它们都派生System.Object。
你会学到不一样的编码方式：
static void Main(string[] args)
Task parent = new Task(() =&
var cts = new CancellationTokenSource();
var tf = new TaskFactory&Int32&(cts.Token, TaskCreationOptions.AttachedToParent, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
//创建并启动3个子任务
var childTasks = new[] {
tf.StartNew(() =& Sum(cts.Token, 10000)),
tf.StartNew(() =& Sum(cts.Token, 20000)),
tf.StartNew(() =& Sum(cts.Token, Int32.MaxValue))
// 这个会抛异常
// 任何子任务抛出异常就取消其余子任务
for (Int32 task = 0; task & childTasks.L task++)
childTasks[task].ContinueWith(t =& cts.Cancel(), TaskContinuationOptions.OnlyOnFaulted);
// 所有子任务完成后，从未出错/未取消的任务获取返回的最大值
// 然后将最大值传给另一个任务来显示最大结果
tf.ContinueWhenAll(childTasks,
completedTasks =& completedTasks.Where(t =& !t.IsFaulted && !t.IsCanceled).Max(t =& t.Result),
CancellationToken.None)
.ContinueWith(t =& Console.WriteLine("The maxinum is: " + t.Result),
TaskContinuationOptions.ExecuteSynchronously).Wait(); // Wait用于测试
// 子任务完成后，也显示任何未处理的异常
parent.ContinueWith(p =&
// 用StringBuilder输出所有
StringBuilder sb = new StringBuilder("The following exception(s) occurred:" + Environment.NewLine);
foreach (var e in p.Exception.Flatten().InnerExceptions)
sb.AppendLine("
" + e.GetType().ToString());
Console.WriteLine(sb.ToString());
}, TaskContinuationOptions.OnlyOnFaulted);
// 启动父任务
parent.Start();
parent.Wait(); //显示结果
catch (AggregateException)
private static Int32 Sum(CancellationToken ct, Int32 n)
Int32 sum = 0;
for (; n & 0; n--)
ct.ThrowIfCancellationRequested();
checked { sum += }
任务工厂就这么用，就是一个任务的集合。
现在看看TaskScheduler（任务调度）&
　　任务基础结构是很灵活的，TaskScheduler对象功不可没。
　　TaskScheduler对象负责执行调度的任务，同时向Visual Studio调试器公开任务信息，就像一座桥梁，让我们能够掌控自己的任务线程。
　　TaskScheduler有两个派生类：thread pool task scheduler(线程池任务调度)，和synchronization context task scheduler（同步上下文任务调度器）。默认情况下，所以应用程序使用的都是线程池任务调度器，这个任务调度器将任务调度给线程池的工作者线程。可以查询TaskScheduler的静态Default属性来获得对默认任务调度器的一个引用。
　　同步上下文任务调度器通常用于桌面应用程序，Winfrom，WPF及Silverlight。这个任务调度器将多有任务都调度给应用程序的GUI线程，使所有任务代码都能成功更新UI组建，比如按钮、菜单项等。同步上下文任务调度器根本不使用线程池。同样，可以查询TaskScheduler的静态FromCurrentSynchronizationContext方法来获得对一个同步上下文任务调度器的引用。
就像这样创建类型：
1 //同步上下文任务调度
2 TaskScheduler m_syncContextTaskScheduler =
TaskScheduler.FromCurrentSynchronizationContext();
任务调度有很多的，下面列举一部分，供参考，更多的请参看& 它包括了大量的示例代码。
　　它内容实在有点多。写了我很久了。好不容易把任务这块一次写完，希望大家有更多的收获。
　--------------------下篇预告，线程池如何管理线程。把基础介绍完结，也算是一个新的起点了。^_^
阅读(...) 评论()