关于Task的API太多了，网上的实例也很多，现在我们来说说Task究竟是个什么东西【task一般用于多线程，它一定与线程有关】，还有它的返回值有事怎么搞的。
首先我们以一个最简单的API开始，TaskFactory的StartNew<TResult>方法，TaskFactory.cs
public Task<TResult> StartNew<TResult>(Func<Object, TResult> function, Object state) { StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; Task currTask = Task.InternalCurrent; return Task<TResult>.StartNew(currTask, function, state, m_defaultCancellationToken, m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark); } private TaskScheduler GetDefaultScheduler(Task currTask) { if (m_defaultScheduler != null) return m_defaultScheduler; else if ((currTask != null)&& ((currTask.CreationOptions & TaskCreationOptions.HideScheduler) == 0)) return currTask.ExecutingTaskScheduler; else return TaskScheduler.Default; }
可见最终和调用Task<TResult>.StartNew等效的，这里的GetDefaultScheduler返回的是TaskScheduler.Default。TaskScheduler.cs实现如下：
public abstract class TaskScheduler { private static readonly TaskScheduler s_defaultTaskScheduler = new ThreadPoolTaskScheduler(); public static TaskScheduler Default { get { return s_defaultTaskScheduler; } } internal void InternalQueueTask(Task task) { Contract.Requires(task != null); task.FireTaskScheduledIfNeeded(this); this.QueueTask(task); } }
默认的TaskScheduler.Default是ThreadPoolTaskScheduler实例。现在我们看看Task<TResult>的实现 Future.cs
public class Task<TResult> : Task { internal static Task<TResult> StartNew(Task parent, Func<object, TResult> function, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler, ref StackCrawlMark stackMark) { if (function == null) { throw new ArgumentNullException("function"); } if (scheduler == null) { throw new ArgumentNullException("scheduler"); } if ((internalOptions & InternalTaskOptions.SelfReplicating) != 0) { throw new ArgumentOutOfRangeException("creationOptions", Environment.GetResourceString("TaskT_ctor_SelfReplicating")); } // Create and schedule the future. Task<TResult> f = new Task<TResult>(function, state, parent, cancellationToken, creationOptions, internalOptions | InternalTaskOptions.QueuedByRuntime, scheduler, ref stackMark); f.ScheduleAndStart(false); return f; } internal void ScheduleAndStart(bool needsProtection) { Contract.Assert(m_taskScheduler != null, "expected a task scheduler to have been selected"); Contract.Assert((m_stateFlags & TASK_STATE_STARTED) == 0, "task has already started"); // Set the TASK_STATE_STARTED bit if (needsProtection) { if (!MarkStarted()) { // A cancel has snuck in before we could get started. Quietly exit. return; } } else { m_stateFlags |= TASK_STATE_STARTED; } if (s_asyncDebuggingEnabled) { AddToActiveTasks(this); } if (AsyncCausalityTracer.LoggingOn && (Options & (TaskCreationOptions)InternalTaskOptions.ContinuationTask) == 0) { //For all other task than TaskContinuations we want to log. TaskContinuations log in their constructor AsyncCausalityTracer.TraceOperationCreation(CausalityTraceLevel.Required, this.Id, "Task: "+((Delegate)m_action).Method.Name, 0); } try { m_taskScheduler.InternalQueueTask(this); } catch (ThreadAbortException tae) { AddException(tae); FinishThreadAbortedTask(true, false); } catch (Exception e) { TaskSchedulerException tse = new TaskSchedulerException(e); AddException(tse); Finish(false); if ((Options & (TaskCreationOptions)InternalTaskOptions.ContinuationTask) == 0) { // m_contingentProperties.m_exceptionsHolder *should* already exist after AddException() Contract.Assert( (m_contingentProperties != null) && (m_contingentProperties.m_exceptionsHolder != null) && (m_contingentProperties.m_exceptionsHolder.ContainsFaultList), "Task.ScheduleAndStart(): Expected m_contingentProperties.m_exceptionsHolder to exist " + "and to have faults recorded."); m_contingentProperties.m_exceptionsHolder.MarkAsHandled(false); } // re-throw the exception wrapped as a TaskSchedulerException. throw tse; } } internal Task( Func<object, TResult> valueSelector, object state, Task parent, CancellationToken cancellationToken, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler, ref StackCrawlMark stackMark) : this(valueSelector, state, parent, cancellationToken, creationOptions, internalOptions, scheduler) { PossiblyCaptureContext(ref stackMark); } internal void PossiblyCaptureContext(ref StackCrawlMark stackMark) { Contract.Assert(m_contingentProperties == null || m_contingentProperties.m_capturedContext == null, "Captured an ExecutionContext when one was already captured."); CapturedContext = ExecutionContext.Capture(ref stackMark, ExecutionContext.CaptureOptions.IgnoreSyncCtx | ExecutionContext.CaptureOptions.OptimizeDefaultCase); } internal override void InnerInvoke() { // Invoke the delegate Contract.Assert(m_action != null); var func = m_action as Func<TResult>; if (func != null) { m_result = func(); return; } var funcWithState = m_action as Func<object, TResult>; if (funcWithState != null) { m_result = funcWithState(m_stateObject); return; } Contract.Assert(false, "Invalid m_action in Task<TResult>"); } public TResult Result { get { return IsWaitNotificationEnabledOrNotRanToCompletion ? GetResultCore(waitCompletionNotification: true) : m_result; } } }
Task<TResult>的StartNew方法首先调用构造函数，在构造函数里面调用PossiblyCaptureContext方法，PossiblyCaptureContext方法调用ExecutionContext.Capture捕获线程上下文，然后回到StartNew方法，调用Task<TResult>。ScheduleAndStart，ScheduleAndStart方法主要是调用TaskScheduler的InternalQueueTask方法；TaskScheduler的InternalQueueTask方法主要是调用QueueTask，QueueTask方法在子类被覆盖，这里调用ThreadPoolTaskScheduler的QueueTask方法，ThreadPoolTaskScheduler.cs
internal sealed class ThreadPoolTaskScheduler: TaskScheduler { private static readonly ParameterizedThreadStart s_longRunningThreadWork = new ParameterizedThreadStart(LongRunningThreadWork); private static void LongRunningThreadWork(object obj) { Contract.Requires(obj != null, "TaskScheduler.LongRunningThreadWork: obj is null"); Task t = obj as Task; Contract.Assert(t != null, "TaskScheduler.LongRunningThreadWork: t is null"); t.ExecuteEntry(false); } protected internal override void QueueTask(Task task) { if ((task.Options & TaskCreationOptions.LongRunning) != 0) { // Run LongRunning tasks on their own dedicated thread. Thread thread = new Thread(s_longRunningThreadWork); thread.IsBackground = true; // Keep this thread from blocking process shutdown thread.Start(task); } else { // Normal handling for non-LongRunning tasks. bool forceToGlobalQueue = ((task.Options & TaskCreationOptions.PreferFairness) != 0); ThreadPool.UnsafeQueueCustomWorkItem(task, forceToGlobalQueue); } } }
如果Task是TaskCreationOptions.LongRunning，那么我们新建一个逻辑线程来运行当前的Task，否者放到线程池里面运行。
单独的逻辑线程调用s_longRunningThreadWork回调方法【该方法调用task的ExecuteEntry】；如果是线程池那么我们调用Task的ExecuteWorkItem方法【其实还是调用Task的ExecuteEntry】，Task.cs
public class Task : IThreadPoolWorkItem, IAsyncResult, IDisposable { [ThreadStatic] internal static Task t_currentTask; internal static Task InternalCurrent { get { return t_currentTask; } } void IThreadPoolWorkItem.ExecuteWorkItem() { ExecuteEntry(false); } internal bool ExecuteEntry(bool bPreventDoubleExecution) { if (bPreventDoubleExecution || ((Options & (TaskCreationOptions)InternalTaskOptions.SelfReplicating) != 0)) { int previousState = 0; // Do atomic state transition from queued to invoked. If we observe a task that's already invoked, // we will return false so that TaskScheduler.ExecuteTask can throw an exception back to the custom scheduler. // However we don't want this exception to be throw if the task was already canceled, because it's a // legitimate scenario for custom schedulers to dequeue a task and mark it as canceled (example: throttling scheduler) if (!AtomicStateUpdate(TASK_STATE_DELEGATE_INVOKED, TASK_STATE_DELEGATE_INVOKED | TASK_STATE_COMPLETED_MASK, ref previousState) && (previousState & TASK_STATE_CANCELED) == 0) { // This task has already been invoked. Don't invoke it again. return false; } } else { // Remember that we started running the task delegate. m_stateFlags |= TASK_STATE_DELEGATE_INVOKED; } if (!IsCancellationRequested && !IsCanceled) { ExecuteWithThreadLocal(ref t_currentTask); } else if (!IsCanceled) { int prevState = Interlocked.Exchange(ref m_stateFlags, m_stateFlags | TASK_STATE_CANCELED); if ((prevState & TASK_STATE_CANCELED) == 0) { CancellationCleanupLogic(); } } return true; } private void ExecuteWithThreadLocal(ref Task currentTaskSlot) { // Remember the current task so we can restore it after running, and then Task previousTask = currentTaskSlot; // ETW event for Task Started var etwLog = TplEtwProvider.Log; Guid savedActivityID = new Guid(); bool etwIsEnabled = etwLog.IsEnabled(); if (etwIsEnabled) { if (etwLog.TasksSetActivityIds) EventSource.SetCurrentThreadActivityId(TplEtwProvider.CreateGuidForTaskID(this.Id), out savedActivityID); // previousTask holds the actual "current task" we want to report in the event if (previousTask != null) etwLog.TaskStarted(previousTask.m_taskScheduler.Id, previousTask.Id, this.Id); else etwLog.TaskStarted(TaskScheduler.Current.Id, 0, this.Id); } if (AsyncCausalityTracer.LoggingOn) AsyncCausalityTracer.TraceSynchronousWorkStart(CausalityTraceLevel.Required, this.Id, CausalitySynchronousWork.Execution); try { // place the current task into TLS. currentTaskSlot = this; ExecutionContext ec = CapturedContext; if (ec == null) { // No context, just run the task directly. Execute(); } else { if (IsSelfReplicatingRoot || IsChildReplica) { CapturedContext = CopyExecutionContext(ec); } // Run the task. We need a simple shim that converts the // object back into a Task object, so that we can Execute it. // Lazily initialize the callback delegate; benign ---- var callback = s_ecCallback; if (callback == null) s_ecCallback = callback = new ContextCallback(ExecutionContextCallback); #if PFX_LEGACY_3_5 ExecutionContext.Run(ec, callback, this); #else ExecutionContext.Run(ec, callback, this, true); #endif } if (AsyncCausalityTracer.LoggingOn) AsyncCausalityTracer.TraceSynchronousWorkCompletion(CausalityTraceLevel.Required, CausalitySynchronousWork.Execution); Finish(true); } finally { currentTaskSlot = previousTask; // ETW event for Task Completed if (etwIsEnabled) { // previousTask holds the actual "current task" we want to report in the event if (previousTask != null) etwLog.TaskCompleted(previousTask.m_taskScheduler.Id, previousTask.Id, this.Id, IsFaulted); else etwLog.TaskCompleted(TaskScheduler.Current.Id, 0, this.Id, IsFaulted); if (etwLog.TasksSetActivityIds) EventSource.SetCurrentThreadActivityId(savedActivityID); } } } private static void ExecutionContextCallback(object obj) { Task task = obj as Task; Contract.Assert(task != null, "expected a task object"); task.Execute(); } private void Execute() { if (IsSelfReplicatingRoot) { ExecuteSelfReplicating(this); } else { try { InnerInvoke(); } catch (ThreadAbortException tae) { // Don't record the TAE or call FinishThreadAbortedTask for a child replica task -- // it's already been done downstream. if (!IsChildReplica) { // Record this exception in the task's exception list HandleException(tae); // This is a ThreadAbortException and it will be rethrown from this catch clause, causing us to // skip the regular Finish codepath. In order not to leave the task unfinished, we now call // FinishThreadAbortedTask here. FinishThreadAbortedTask(true, true); } } catch (Exception exn) { // Record this exception in the task's exception list HandleException(exn); } } } }
到这里Task是什么 就明白了，继续往下看，Task的ExecuteEntry方法主要是调用ExecutionContext.Run(ec, callback, this, true)方法，注意这里的callback是一个ContextCallback实例，里面主要是调用Task的Execute方法，Task的Execute主要是代用InnerInvoke方法，该方法在子类Task<TResult>被重写，InnerInvoke方法里面有2局比较重要【m_result = func() 或者m_result = funcWithState(m_stateObject) 这里才是正真调用我们自己的方法，给返回值赋值】，到这里返回值也就明白了。那么在我们方法结束后需要调用Finish方法来标记方法结束
/// <summary> /// Signals completion of this particular task. /// The bUserDelegateExecuted parameter indicates whether this Finish() call comes following the /// full execution of the user delegate. /// If bUserDelegateExecuted is false, it mean user delegate wasn't invoked at all (either due to /// a cancellation request, or because this task is a promise style Task). In this case, the steps /// involving child tasks (i.e. WaitForChildren) will be skipped. /// /// </summary> internal void Finish(bool bUserDelegateExecuted) { if (!bUserDelegateExecuted) { // delegate didn't execute => no children. We can safely call the remaining finish stages FinishStageTwo(); } else { var props = m_contingentProperties; if (props == null || // no contingent properties means no children, so it's safe to complete ourselves (props.m_completionCountdown == 1 && !IsSelfReplicatingRoot) || // Count of 1 => either all children finished, or there were none. Safe to complete ourselves // without paying the price of an Interlocked.Decrement. // However we need to exclude self replicating root tasks from this optimization, because // they can have children joining in, or finishing even after the root task delegate is done. Interlocked.Decrement(ref props.m_completionCountdown) == 0) // Reaching this sub clause means there may be remaining active children, // and we could be racing with one of them to call FinishStageTwo(). // So whoever does the final Interlocked.Dec is responsible to finish. { FinishStageTwo(); } else { // Apparently some children still remain. It will be up to the last one to process the completion of this task on their own thread. // We will now yield the thread back to ThreadPool. Mark our state appropriately before getting out. // We have to use an atomic update for this and make sure not to overwrite a final state, // because at this very moment the last child's thread may be concurrently completing us. // Otherwise we risk overwriting the TASK_STATE_RAN_TO_COMPLETION, _CANCELED or _FAULTED bit which may have been set by that child task. // Note that the concurrent update by the last child happening in FinishStageTwo could still wipe out the TASK_STATE_WAITING_ON_CHILDREN flag, // but it is not critical to maintain, therefore we dont' need to intruduce a full atomic update into FinishStageTwo AtomicStateUpdate(TASK_STATE_WAITING_ON_CHILDREN, TASK_STATE_FAULTED | TASK_STATE_CANCELED | TASK_STATE_RAN_TO_COMPLETION); } // Now is the time to prune exceptional children. We'll walk the list and removes the ones whose exceptions we might have observed after they threw. // we use a local variable for exceptional children here because some other thread may be nulling out m_contingentProperties.m_exceptionalChildren List<Task> exceptionalChildren = props != null ? props.m_exceptionalChildren : null; if (exceptionalChildren != null) { lock (exceptionalChildren) { exceptionalChildren.RemoveAll(s_IsExceptionObservedByParentPredicate); // RemoveAll has better performance than doing it ourselves } } } } internal void FinishStageTwo() { AddExceptionsFromChildren(); // At this point, the task is done executing and waiting for its children, // we can transition our task to a completion state. int completionState; if (ExceptionRecorded) { completionState = TASK_STATE_FAULTED; if (AsyncCausalityTracer.LoggingOn) AsyncCausalityTracer.TraceOperationCompletion(CausalityTraceLevel.Required, this.Id, AsyncCausalityStatus.Error); if (Task.s_asyncDebuggingEnabled) { RemoveFromActiveTasks(this.Id); } } else if (IsCancellationRequested && IsCancellationAcknowledged) { // We transition into the TASK_STATE_CANCELED final state if the task's CT was signalled for cancellation, // and the user delegate acknowledged the cancellation request by throwing an OCE, // and the task hasn't otherwise transitioned into faulted state. (TASK_STATE_FAULTED trumps TASK_STATE_CANCELED) // // If the task threw an OCE without cancellation being requestsed (while the CT not being in signaled state), // then we regard it as a regular exception completionState = TASK_STATE_CANCELED; if (AsyncCausalityTracer.LoggingOn) AsyncCausalityTracer.TraceOperationCompletion(CausalityTraceLevel.Required, this.Id, AsyncCausalityStatus.Canceled); if (Task.s_asyncDebuggingEnabled) { RemoveFromActiveTasks(this.Id); } } else { completionState = TASK_STATE_RAN_TO_COMPLETION; if (AsyncCausalityTracer.LoggingOn) AsyncCausalityTracer.TraceOperationCompletion(CausalityTraceLevel.Required, this.Id, AsyncCausalityStatus.Completed); if (Task.s_asyncDebuggingEnabled) { RemoveFromActiveTasks(this.Id); } } // Use Interlocked.Exchange() to effect a memory fence, preventing // any SetCompleted() (or later) instructions from sneak back before it. Interlocked.Exchange(ref m_stateFlags, m_stateFlags | completionState); // Set the completion event if it's been lazy allocated. // And if we made a cancellation registration, it's now unnecessary. var cp = m_contingentProperties; if (cp != null) { cp.SetCompleted(); cp.DeregisterCancellationCallback(); } // ready to run continuations and notify parent. FinishStageThree(); } internal bool AtomicStateUpdate(int newBits, int illegalBits) { // This could be implemented in terms of: // internal bool AtomicStateUpdate(int newBits, int illegalBits, ref int oldFlags); // but for high-throughput perf, that delegation's cost is noticeable. SpinWait sw = new SpinWait(); do { int oldFlags = m_stateFlags; if ((oldFlags & illegalBits) != 0) return false; if (Interlocked.CompareExchange(ref m_stateFlags, oldFlags | newBits, oldFlags) == oldFlags) { return true; } sw.SpinOnce(); } while (true); }
在FinishStageTwo方法后面还会调用FinishStageThree方法，FinishStageThree方法调用FinishContinuations，在FinishContinuations方法里面会获取object continuationObject = Interlocked.Exchange(ref m_continuationObject, s_taskCompletionSentinel);然后再用对应的方法.
internal void FinishStageThree() { // Release the action so that holding this task object alive doesn't also // hold alive the body of the task. We do this before notifying a parent, // so that if notifying the parent completes the parent and causes // its synchronous continuations to run, the GC can collect the state // in the interim. And we do it before finishing continuations, because // continuations hold onto the task, and therefore are keeping it alive. m_action = null; // Notify parent if this was an attached task if (m_parent != null && ((m_parent.CreationOptions & TaskCreationOptions.DenyChildAttach) == 0) && (((TaskCreationOptions)(m_stateFlags & OptionsMask)) & TaskCreationOptions.AttachedToParent) != 0) { m_parent.ProcessChildCompletion(this); } // Activate continuations (if any). FinishContinuations(); } internal void FinishContinuations() { // Atomically store the fact that this task is completing. From this point on, the adding of continuations will // result in the continuations being run/launched directly rather than being added to the continuation list. object continuationObject = Interlocked.Exchange(ref m_continuationObject, s_taskCompletionSentinel); TplEtwProvider.Log.RunningContinuation(Id, continuationObject); // If continuationObject == null, then we don't have any continuations to process if (continuationObject != null) { if (AsyncCausalityTracer.LoggingOn) AsyncCausalityTracer.TraceSynchronousWorkStart(CausalityTraceLevel.Required, this.Id, CausalitySynchronousWork.CompletionNotification); // Skip synchronous execution of continuations if this task's thread was aborted bool bCanInlineContinuations = !(((m_stateFlags & TASK_STATE_THREAD_WAS_ABORTED) != 0) || (Thread.CurrentThread.ThreadState == ThreadState.AbortRequested) || ((m_stateFlags & (int)TaskCreationOptions.RunContinuationsAsynchronously) != 0)); // Handle the single-Action case Action singleAction = continuationObject as Action; if (singleAction != null) { AwaitTaskContinuation.RunOrScheduleAction(singleAction, bCanInlineContinuations, ref t_currentTask); LogFinishCompletionNotification(); return; } // Handle the single-ITaskCompletionAction case ITaskCompletionAction singleTaskCompletionAction = continuationObject as ITaskCompletionAction; if (singleTaskCompletionAction != null) { if (bCanInlineContinuations) { singleTaskCompletionAction.Invoke(this); } else { ThreadPool.UnsafeQueueCustomWorkItem(new CompletionActionInvoker(singleTaskCompletionAction, this), forceGlobal: false); } LogFinishCompletionNotification(); return; } // Handle the single-TaskContinuation case TaskContinuation singleTaskContinuation = continuationObject as TaskContinuation; if (singleTaskContinuation != null) { singleTaskContinuation.Run(this, bCanInlineContinuations); LogFinishCompletionNotification(); return; } // Not a single; attempt to cast as list List<object> continuations = continuationObject as List<object>; if (continuations == null) { LogFinishCompletionNotification(); return; // Not a single or a list; just return } // // Begin processing of continuation list // // Wait for any concurrent adds or removes to be retired lock (continuations) { } int continuationCount = continuations.Count; // Fire the asynchronous continuations first ... for (int i = 0; i < continuationCount; i++) { // Synchronous continuation tasks will have the ExecuteSynchronously option, // and we're looking for asynchronous tasks... var tc = continuations[i] as StandardTaskContinuation; if (tc != null && (tc.m_options & TaskContinuationOptions.ExecuteSynchronously) == 0) { TplEtwProvider.Log.RunningContinuationList(Id, i, tc); continuations[i] = null; // so that we can skip this later tc.Run(this, bCanInlineContinuations); } } // ... and then fire the synchronous continuations (if there are any). // This includes ITaskCompletionAction, AwaitTaskContinuations, and // Action delegates, which are all by default implicitly synchronous. for (int i = 0; i < continuationCount; i++) { object currentContinuation = continuations[i]; if (currentContinuation == null) continue; continuations[i] = null; // to enable free'ing up memory earlier TplEtwProvider.Log.RunningContinuationList(Id, i, currentContinuation); // If the continuation is an Action delegate, it came from an await continuation, // and we should use AwaitTaskContinuation to run it. Action ad = currentContinuation as Action; if (ad != null) { AwaitTaskContinuation.RunOrScheduleAction(ad, bCanInlineContinuations, ref t_currentTask); } else { // If it's a TaskContinuation object of some kind, invoke it. TaskContinuation tc = currentContinuation as TaskContinuation; if (tc != null) { // We know that this is a synchronous continuation because the // asynchronous ones have been weeded out tc.Run(this, bCanInlineContinuations); } // Otherwise, it must be an ITaskCompletionAction, so invoke it. else { Contract.Assert(currentContinuation is ITaskCompletionAction, "Expected continuation element to be Action, TaskContinuation, or ITaskContinuationAction"); var action = (ITaskCompletionAction)currentContinuation; if (bCanInlineContinuations) { action.Invoke(this); } else { ThreadPool.UnsafeQueueCustomWorkItem(new CompletionActionInvoker(action, this), forceGlobal: false); } } } } LogFinishCompletionNotification(); } }
当我们访问TTask<TResult> 的Result的时候，如果Task还没有执行完毕，那么我们必须等待TASK，调用Task<TResult>的GetResultCore(waitCompletionNotification: true)方法,该方法最终调用Task的InternalWait方法。
/// The core wait function, which is only accesible internally. It's meant to be used in places in TPL code where /// the current context is known or cached. internal bool InternalWait(int millisecondsTimeout, CancellationToken cancellationToken) { // ETW event for Task Wait Begin var etwLog = TplEtwProvider.Log; bool etwIsEnabled = etwLog.IsEnabled(); if (etwIsEnabled) { Task currentTask = Task.InternalCurrent; etwLog.TaskWaitBegin( (currentTask != null ? currentTask.m_taskScheduler.Id : TaskScheduler.Default.Id), (currentTask != null ? currentTask.Id : 0), this.Id, TplEtwProvider.TaskWaitBehavior.Synchronous, 0, System.Threading.Thread.GetDomainID()); } bool returnValue = IsCompleted; // If the event hasn't already been set, we will wait. if (!returnValue) { // Alert a listening debugger that we can't make forward progress unless it slips threads. // We call NOCTD for two reasons: // 1. If the task runs on another thread, then we'll be blocked here indefinitely. // 2. If the task runs inline but takes some time to complete, it will suffer ThreadAbort with possible state corruption, // and it is best to prevent this unless the user explicitly asks to view the value with thread-slipping enabled. Debugger.NotifyOfCrossThreadDependency(); // We will attempt inline execution only if an infinite wait was requested // Inline execution doesn't make sense for finite timeouts and if a cancellation token was specified // because we don't know how long the task delegate will take. if (millisecondsTimeout == Timeout.Infinite && !cancellationToken.CanBeCanceled && WrappedTryRunInline() && IsCompleted) // TryRunInline doesn't guarantee completion, as there may be unfinished children. { returnValue = true; } else { returnValue = SpinThenBlockingWait(millisecondsTimeout, cancellationToken); } } Contract.Assert(IsCompleted || millisecondsTimeout != Timeout.Infinite); // ETW event for Task Wait End if (etwIsEnabled) { Task currentTask = Task.InternalCurrent; if (currentTask != null) { etwLog.TaskWaitEnd(currentTask.m_taskScheduler.Id, currentTask.Id, this.Id); } else { etwLog.TaskWaitEnd(TaskScheduler.Default.Id, 0, this.Id); } // logically the continuation is empty so we immediately fire etwLog.TaskWaitContinuationComplete(this.Id); } return returnValue; } /// Waits for the task to complete, for a timeout to occur, or for cancellation to be requested. /// The method first spins and then falls back to blocking on a new event. private bool SpinThenBlockingWait(int millisecondsTimeout, CancellationToken cancellationToken) { bool infiniteWait = millisecondsTimeout == Timeout.Infinite; uint startTimeTicks = infiniteWait ? 0 : (uint)Environment.TickCount; bool returnValue = SpinWait(millisecondsTimeout); if (!returnValue) { var mres = new SetOnInvokeMres(); try { AddCompletionAction(mres, addBeforeOthers: true); if (infiniteWait) { returnValue = mres.Wait(Timeout.Infinite, cancellationToken); } else { uint elapsedTimeTicks = ((uint)Environment.TickCount) - startTimeTicks; if (elapsedTimeTicks < millisecondsTimeout) { returnValue = mres.Wait((int)(millisecondsTimeout - elapsedTimeTicks), cancellationToken); } } } finally { if (!IsCompleted) RemoveContinuation(mres); // Don't Dispose of the MRES, because the continuation off of this task may // still be running. This is ok, however, as we never access the MRES' WaitHandle, // and thus no finalizable resources are actually allocated. } } return returnValue; } private void AddCompletionAction(ITaskCompletionAction action, bool addBeforeOthers) { if (!AddTaskContinuation(action, addBeforeOthers)) action.Invoke(this); // run the action directly if we failed to queue the continuation (i.e., the task completed) } // Record a continuation task or action. // Return true if and only if we successfully queued a continuation. private bool AddTaskContinuation(object tc, bool addBeforeOthers) { Contract.Requires(tc != null); // Make sure that, if someone calls ContinueWith() right after waiting for the predecessor to complete, // we don't queue up a continuation. if (IsCompleted) return false; // Try to just jam tc into m_continuationObject if ((m_continuationObject != null) || (Interlocked.CompareExchange(ref m_continuationObject, tc, null) != null)) { // If we get here, it means that we failed to CAS tc into m_continuationObject. // Therefore, we must go the more complicated route. return AddTaskContinuationComplex(tc, addBeforeOthers); } else return true; } private sealed class SetOnInvokeMres : ManualResetEventSlim, ITaskCompletionAction { internal SetOnInvokeMres() : base(false, 0) { } public void Invoke(Task completingTask) { Set(); } }
SpinThenBlockingWait方法先自旋检查是否完成，如果没有调用SetOnInvokeMres实例来完成Wait【SetOnInvokeMres是ManualResetEventSlim的子类，这里调用 mres.Wait(Timeout.Infinite, cancellationToken) 或者 mres.Wait((int)(millisecondsTimeout - elapsedTimeTicks), cancellationToken)来实现阻塞】，但是这里有一个AddCompletionAction方法，然后调用AddTaskContinuation方法，在AddTaskContinuation方法中有一句很重要【if ((m_continuationObject != null) || (Interlocked.CompareExchange(ref m_continuationObject, tc, null) != null))】说白了就是把SetOnInvokeMres实例赋给m_continuationObject对象。所以AddCompletionAction方法里面的action.Invoke(this);放法在这里没有调用。而是等待task执行完毕后FinishContinuations方法中的singleTaskCompletionAction.Invoke(this);设置信号量,如果m_continuationObject是真正的TaskContinuation实例，我们就调用【 singleTaskContinuation.Run(this, bCanInlineContinuations)】
我们简单总结一下一下调用次序：
TaskFactory.StartNew
->Task<TResult>.StartNew【该方法首先调用构造函数，构造函数里面调用PossiblyCaptureContext来捕获线程上下文，然后调用自己的ScheduleAndStart方法】
->TaskScheduler.InternalQueueTask
->ThreadPoolTaskScheduler.QueueTask【到这里Task就转换为线程了】
->Task.ExecuteEntry【如果是线程池是通过调用IThreadPoolWorkItem的ExecuteWorkItem方法进入的】
->Task.ExecuteWithThreadLocal【该方法首先拷贝捕获到的线程上下文，再调用ExecutionContext.Run，传入上传下文和回调方法】
->Task.ExecutionContextCallback
->Task.Execute
->Task<TResult>.InnerInvoke【该方法会真正调用我们自己的方法，并且给返回值赋值】
->Task.Finish 【标记该Task已经结束】
->Task.FinishStageTwo
->Task.FinishStageThree
->Task.FinishContinuations【会触发SET】
-------------------------
Task<TResult>的Result属性，就是Task的返回值，如果Task执行完毕直接返回，否者调用Task<TResult>.GetResultCore
->Task.InternalWait
->Task.SpinThenBlockingWait【调用SetOnInvokeMres的Wait方法】