Ist es in Ordnung, die gleiche Aufgabe von mehreren Threads zu erwarten - ist Thread sicher?

Question

Ist Thread sicher? Es scheint, dass die Task-Klasse threadsicher ist, also denke ich, dass es auch Thread-sicher ist, aber ich habe nirgends eine Bestätigung gefunden. Auch Thread-Sicherheit ist eine Voraussetzung für benutzerdefinierte Warter - ich meine für die IsCompleted, GetAwaiter, etc. Methoden? I.e. Wenn diese Methoden nicht threadsicher sind, wird es threadsicher sein? Ich erwarte jedoch nicht, dass ich bald einen benutzerdefinierten Warter brauche.

Ein Beispiel für Benutzerszenario: Lassen Sie uns sagen, dass ich eine Hintergrundaufgabe haben, die asynchron ein Ergebnis zurückgibt, die dann von mehreren Threads verwendet wird:

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 

namespace scratch1 
{ 
    class Foo 
    { 
     Task<int> _task; 

     public Foo() 
     { 
      _task = Task.Run(async() => { await Task.Delay(5000); return 5; }); 
     } 

     // Called from multiple threads 
     public async Task<int> Bar(int i) 
     { 
      return (await _task) + i; 
     } 
    } 

    class Program 
    { 
     public static void Main(string[] args) 
     { 
      Foo foo = new Foo(); 

      List<Task> tasks = new List<Task>(); 
      foreach (var i in Enumerable.Range(0, 100)) 
      { 
       tasks.Add(Task.Run(async() => { Console.WriteLine(await foo.Bar(i)); })); 
      } 

      Task.WaitAll(tasks.ToArray()); 
     } 
    } 
} 

Answer 1

Wie Sie erwähnt, ist await dünn genug, dass es doesn sehe Threads überhaupt nicht.

Der mit await verbundene Code (der vom Compiler generierte Code innerhalb der Statusmaschine und die Unterstützungsklassen in der BCL) wird immer nur mit einem Thread gleichzeitig ausgeführt. (er kann zu einem anderen Thread wechseln, wenn er von dem erwarteten zurückkommt, aber der vorherige Lauf ist bereits beendet)

Die tatsächliche Thread-Sicherheit hängt von dem Objekt ab, auf das Sie warten.
Es muss eine thread-sichere Möglichkeit geben, Callbacks hinzuzufügen (oder await es zweimal auf einmal brechen kann).

Darüber hinaus muss es den Rückruf genau einmal aufrufen, oder es kann die Zustandsmaschine brechen. (vor allem, wenn es seinen Callback auf zwei Threads zur gleichen Zeit läuft, werden die Dinge schrecklich schief gehen)

Task ist thread-safe.