La continuazione dell'attività non era pianificata sul thread del pool di thread

Question

Stavo leggendo su SynchronizationContext e il suo utilizzo con i metodi async/await (link). Da quanto ho capito, in un'applicazione Console in cui SynchronizationContext è nullo, la continuazione di un metodo atteso (Task) verrà pianificata con lo scheduler predefinito che sarebbe il ThreadPool.

Ma se corro questo console app, vedrete dall'output che la continuazione viene eseguito sul thread di lavoro che ho creato:

class Program 
{ 
    static void Main(string[] args) 
    { 
     Console.WriteLine("MainThreadId=" + Thread.CurrentThread.ManagedThreadId); 
     Method1().ContinueWith(t => 
     { 
      Console.WriteLine("After Method1. ThreadId=" + Thread.CurrentThread.ManagedThreadId); 
     }); 

     Console.ReadKey(); 
    } 

    public static async Task Method1() 
    { 
     Console.WriteLine("Method1 => Entered. ThreadId=" + Thread.CurrentThread.ManagedThreadId); 

     TaskCompletionSource<bool> completionSource = new TaskCompletionSource<bool>(); 
     Thread thread = new Thread(() => 
     { 
      Console.WriteLine("Method1 => Started new thread. ThreadId=" + Thread.CurrentThread.ManagedThreadId); 
      Thread.Sleep(2000); 
      completionSource.SetResult(true); 
     }); 

     thread.Start(); 

     await completionSource.Task; 

     Console.WriteLine("Method1 => After WorkerThread. ThreadId=" + Thread.CurrentThread.ManagedThreadId); 
    } 
} 

Ed ecco l'output:

MainThreadId=10 
Method1 => Entered. ThreadId=10 
Method1 => Started new thread. ThreadId=11 
Method1 => After WorkerThread. ThreadId=11 
After Method1. ThreadId=12 

Come si può vedere, "Dopo WorkerThread" è stato emesso sullo stesso thread del mio workerthread, ma non sul threadpool.

Ho trovato un simile question ma il ragazzo stava usando Mono e stavano dicendo che questo era un bug. Da parte mia, ho creato questo codice con Visual Studio e l'ho eseguito su Windows 7 e .Net 4.5.2 installato sulla mia macchina.

Qualcuno potrebbe spiegare questo comportamento?

Answer 1

È a causa di un implementation detail that I documented on my blog: la continuazione creata da await è pianificata utilizzando il flag ExecuteSynchronously. In tal caso, quando è il momento di attivare la continuazione (ad esempio, nella chiamata TaskCompletionSource<T>.SetResult sul thread di lavoro), lo scheduler predefinito tenta innanzitutto di determinare se può essere eseguito sul thread corrente.

Since the worker thread has no TaskScheduler that will reject executing the task synchronously, il flag ExecuteSynchronously sarà cause the thread pool task scheduler to just execute the task synchronously (vale a dire sul thread chiamante).