Verwirrung in Bezug auf threads und wenn asynchrone Methoden sind wirklich asynchron in C#

Dies ist ein wenig unklar ist mir wahrscheinlich, weil die definition von asynchron-in meinem Kopf ist nicht Schlange.

Gut auf Sie für Rückfragen.

In meinem Kopf, da ich vor allem UI-dev, async-code ist code, der nicht auf dem Benutzeroberflächenthread ausgeführt, sondern auf einem anderen thread.

Dass der glaube ist verbreitet, aber falsch. Es gibt keine Anforderung, dass die asynchrone Ausführung von code auf jedem zweiten thread.

Vorstellen, dass Sie Kochen Frühstück. Stellen Sie einen toast in den toaster, und während Sie darauf warten, dass das toast bis pop, die Sie gehen Sie durch Ihre mail von gestern, bezahlen einige Rechnungen, und hey, der toast aufgetaucht. Sie beenden die Zahlung dieser Rechnung, und dann gehen Sie Ihre butter toast.

Wo drin hast du evtl einen zweiten Arbeiter zu beobachten, Ihre toaster?

Nicht. Threads sind Arbeitnehmer. Asynchrone workflows kann passieren, alle in einem thread. Der Punkt der asynchronen workflow vermeiden die Einstellung von mehr Arbeiter, wenn Sie können, möglichst zu vermeiden.

Wenn ich eine lange laufende Aufgabe, die CPU-gebunden (sagen wir, es ist dabei eine Menge harte Mathematik), dann ausgeführt, dass die task asynchron ausgeführt werden müssen, blockieren einige thread richtig? So etwas hat eigentlich die Mathematik zu tun.

Hier, ich gebe Sie ein schwieriges problem zu lösen. Hier ist eine Spalte von 100 zahlen; bitte fügen Sie Sie von hand. So fügen Sie der ersten, der zweiten und der achten insgesamt. Dann fügen Sie das laufende Summe in der Dritten und bekommen insgesamt. Dann, oh, die Hölle, die zweite Seite der zahlen fehlt. Denken Sie daran, wo Sie waren, und machen uns einige toast. Oh, während der toast Toasten war ein Brief angekommen mit den restlichen zahlen. Wenn Sie fertig sind, die Butter toast, gehen, halten Sie auf addieren diese zahlen, und denken Sie daran, zu Essen der toast das nächste mal haben Sie einen freien moment.

Wo ist der Teil, wo Sie angeheuert, einen anderen Arbeitnehmer zu addieren Sie die zahlen? Rechenintensive arbeiten müssen nicht synchron sein, und muss nicht blockieren einen thread. Die Sache, die macht rechnerische Arbeit potenziell asynchrone ist die Möglichkeit, ihn zu stoppen, daran erinnern, wo Sie waren, gehen Sie etwas anderes tun, denken Sie daran, was zu tun ist nach, dass, und fortsetzen, wo Sie aufgehört haben.

Nun ist es sicherlich möglich mieten Sie ein zweiter Arbeiter, der nichts anderes macht, als zahlen zu addieren, und dann wird gefeuert. Und Sie könnten Fragen, die Arbeiter "bist du fertig?" und wenn die Antwort Nein ist, können Sie gehen ein sandwich, bis Sie fertig sind. So Sie und die Arbeiter beschäftigt sind. Aber es ist nicht eine Anforderung, dass ungleichzeitigkeiten betreffen mehrere Arbeitnehmer.

Wenn ich auf ihn warten dann einige thread ist blockiert.

NEIN, NEIN, NEIN. Dies ist der wichtigste Teil von Ihr Missverständnis. await bedeutet nicht "gehen, starten Sie diesen job asynchron". await bedeutet "ich habe ein asynchron erzeugte Ergebnis, dass hier möglicherweise nicht zur Verfügung. Wenn es nicht verfügbar ist, finden einige andere arbeiten zu tun, auf diesen thread so, dass wir nicht blockieren den thread. Erwarten ist die gegenüber, was Sie gerade gesagt haben.

Was ist ein Beispiel für eine wirklich asynchrone Methode und wie würden Sie eigentlich arbeiten? Sind diese beschränkt auf I/O-Operationen, die die Vorteile von einigen hardware-Fähigkeiten, so dass kein thread jemals gesperrt?

Asynchrone Arbeit oft mit benutzerdefinierten hardware-oder mehrere-threads, aber es muss nicht.

Glaube nicht, dass über Arbeitnehmer. Denke, über workflows. Die Essenz der ungleichzeitigkeiten ist Aufbrechen workflows in kleine Teile, so dass Sie können die Reihenfolge bestimmen, in der diese Teile müssen passieren, und dann Ausführung jeder Teil wiederum, aber so dass Teile, die keine Abhängigkeiten mit einander verzahnt werden.

In einem asynchronen workflow können Sie leicht erkennen stellen im workflow, wobei eine Abhängigkeit zwischen teilen, ausgedrückt wird. Solche Teile sind gekennzeichnet mit await. Das ist die Bedeutung von await: der code, der folgt, hängt dieser Teil der workflow abgeschlossen wird, so dass, wenn es nicht abgeschlossen ist, gehen Sie finden eine andere Aufgabe zu tun, und später darauf zurückkommen, wenn die Aufgabe abgeschlossen ist. Der springende Punkt ist, halten die Arbeiter arbeiten, auch in einer Welt, wo erforderlich, die Ergebnisse produziert werden in Zukunft.

Wenn Sie async/await, es gibt keine Garantie, dass die Methode, die Sie aufrufen, wenn Sie erwarten FooAsync() wird asynchron ausgeführt wird. Die interne Implementierung ist frei, um zurückzukehren, die Verwendung eines vollständig synchronen Pfad.

Dies ist ein wenig unklar ist mir wahrscheinlich, weil die definition von
asynchron in meinem Kopf ist nicht Schlange.

Dies bedeutet einfach, es gibt zwei Fälle beim Aufruf einer asynchronen Methode.

Die erste ist, dass bei der Rückgabe der Aufgabe an Sie, der Vorgang ist bereits abgeschlossen-dies wäre ein synchroner Weg. Das zweite ist, dass der Vorgang noch im Gange ist-das ist der async-Pfad.

Betrachten Sie diesen code, die zeigen sollte beide Wege. Wenn der Schlüssel in einem cache ist, wird er wieder synchron. Ansonsten, ein async-op gestartet und ruft zu einer Datenbank:

Task<T> GetCachedDataAsync(string key)
{
    if(cache.TryGetvalue(key, out T value))
    {
        return Task.FromResult(value); //synchronous: no awaits here.
    }

    //start a fully async op.
    return GetDataImpl();

    async Task<T> GetDataImpl()
    {
        value = await database.GetValueAsync(key);
        cache[key] = value;
        return value;
    }
}

So verstehen, dass, können Sie ableiten, dass in der Theorie der call of database.GetValueAsync() können einen ähnlichen code, und selbst in der Lage sein, um zurückzukehren synchron: so auch Ihre async-Pfad bis Ende Mai laufen 100% synchron. Aber Ihr code braucht nicht zu sorgen: async/await-Griffe beiden Fällen nahtlos.

Wenn ich eine lange laufende Aufgabe, die CPU-gebunden (sagen wir, es ist dabei eine Menge harte Mathematik), dann ausgeführt, dass die task asynchron ausgeführt werden müssen, blockieren einige thread richtig? So etwas hat eigentlich die Mathematik zu tun. Wenn ich erwarte es dann einige thread ist blockiert.

Sperrung ist ein gut definierter Begriff-es bedeutet, dein thread brachte seine Ausführung Fenster, während er wartet, dass etwas (I/O, mutex, und so weiter). Also dein thread tun, die Mathematik nicht als "blockiert": es ist tatsächlich der Durchführung der Arbeit.

Was ist ein Beispiel für eine wirklich asynchrone Methode und wie würden Sie eigentlich arbeiten? Sind diese beschränkt auf I/O-Operationen, die die Vorteile von einigen hardware-Fähigkeiten, so dass kein thread jemals gesperrt?

Einem "wirklich async-Methode" wäre eine, die einfach nie blockiert. Es endet für gewöhnlich mit I/O, aber es kann auch bedeuten awaiting schweres Mathe-code, wenn Sie möchten, um Ihre aktuelle thread für etwas anderes (als bei der UI-Entwicklung), oder wenn Sie versuchen, die Einführung von Parallelität:

async Task<double> DoSomethingAsync()
{
    double x = await ReadXFromFile();

    Task<double> a = LongMathCodeA(x);
    Task<double> b = LongMathCodeB(x);

    await Task.WhenAll(a, b);

    return a.Result + b.Result;
}

Asynchron bedeutet nicht Parallel

Asynchrone impliziert nur die Parallelität. In der Tat, sogar die Verwendung von expliziten threads nicht garantieren, dass Sie gleichzeitig ausführen (z.B. wenn Sie die Fäden Affinität für die gleichen single-core -, oder häufiger, wenn es nur einen Kern in die Maschine, um mit zu beginnen).

Daher sollten Sie nicht erwarten, dass ein asynchroner Vorgang geschieht gleichzeitig etwas anderes. Asynchron bedeutet nur, dass es passieren wird, schließlich zu einem anderen Zeitpunkt (eine(Griechisch) = ohne, syn (griech.) = zusammen, khronos (Griechisch) = Zeit. => Asynchrone = nicht passiert zur gleichen Zeit).

Hinweis: Die Idee der Asynchronität ist, dass auf den Aufruf, Sie nicht zu kümmern, wenn der code tatsächlich ausgeführt wird. Dies ermöglicht es, das system zu nutzen von Parallelität, wenn möglich, zum ausführen der operation. Es kann auch sofort ausgeführt werden. Es kann sogar passieren auf dem gleichen thread... dazu später mehr.

Wenn Sie await der asynchronen operation, die Sie erstellen Parallelität (com (Lat.) = zusammen, currere (Latein) = führen. => "und " Concurrent" = gemeinsam). Das ist, weil Sie Fragen für die asynchrone operation abgeschlossen ist, bevor Sie fortfahren. Wir können sagen, dass die Ausführung konvergiert. Dies ist ähnlich dem Konzept der Beitritt threads.

Als asynchrone nicht Parallel

Wenn Sie async/await, es gibt keine Garantie, dass die Methode, die Sie aufrufen, wenn Sie erwarten FooAsync() wird asynchron ausgeführt wird. Die interne Implementierung ist frei, um zurückzukehren, die Verwendung eines vollständig synchronen Pfad.

Geschehen kann dies auf drei Arten:

1. Ist es möglich, zu verwenden await auf alles, was zurück Task. Wenn Sie erhalten die Task es konnte bereits abgeschlossen.

   Doch das allein macht nicht den Eindruck erwecken, es lief synchron. In der Tat, es deuten, es lief asynchron und beendet, bevor Sie bekam die Task Instanz.

   Beachten Sie, dass Sie können await auf eine bereits abgeschlossene Aufgabe:

   private static async Task CallFooAsync()
   {
       await FooAsync();
   }
   
   private static Task FooAsync()
   {
       return Task.CompletedTask;
   }
   
   private static void Main()
   {
       CallFooAsync().Wait();
   }

   Auch, wenn ein async Methode hat keine await es dann synchron läuft.

   Hinweis: Wie Sie bereits wissen, eine Methode, die zurückgibt einen Task werden können, warten auf das Netzwerk oder auf das Dateisystem, etc... damit nicht implizieren, um eine neue Thread oder enqueue etwas auf die ThreadPool.

2. Unter einer Synchronisierung von Rahmen, die verarbeitet wird, durch einen einzelnen thread, das Ergebnis wird sein, führen Sie die Task synchron, mit einigen overhead. Dies ist der Fall, der UI-thread, ich werde sprechen mehr über das, was passiert unten.

3. Es ist möglich, schreiben Sie eine benutzerdefinierte Aufgabenplaner immer Aufgaben synchron. Auf dem gleichen thread, das funktioniert der Aufruf.

   Hinweis: vor kurzem schrieb ich eine benutzerdefinierte SyncrhonizationContext läuft, dass Aufgaben in einem einzigen thread. Sie finden ihn unter Erstellen einer (System.Threading.Aufgaben.)Task scheduler. Es würde dazu führen, dass diese TaskScheduler mit einem Aufruf FromCurrentSynchronizationContext.

   Den Standard - TaskScheduler wird enqueue-die Aufrufe zu den ThreadPool. Noch beim warten auf die Bedienung, wenn es nicht auf die ThreadPool es wird versuchen, Sie zu entfernen aus dem ThreadPool und führen Sie es inline (im selben thread, der wartet... der thread wartet sowieso, es ist also nicht besetzt).

   Hinweis: Eine Bemerkenswerte Ausnahme ist eine Task markiert mit LongRunning. LongRunning Tasks wird in einem separaten thread ausgeführt.

Ihre Frage

Wenn ich eine lange laufende Aufgabe, die CPU-gebunden (sagen wir, es ist dabei eine Menge harte Mathematik), dann ausgeführt, dass die task asynchron ausgeführt werden müssen, blockieren einige thread richtig? So etwas hat eigentlich die Mathematik zu tun. Wenn ich erwarte es dann einige thread ist blockiert.

Wenn Sie das tun, Berechnungen, Sie müssen geschehen, auf einige thread, das Teil ist Recht.

Doch, die Schönheit der async und await ist, dass der wartende thread muss nicht gesperrt werden (mehr dazu später). Dennoch, es ist sehr einfach zu Schießen selbst in den Fuß, indem er die erwartete Aufgabe geplant, auf dem gleichen thread ausgeführt, der darauf wartet, was bei der synchronen Ausführung (das ist eine einfache Fehler in der UI-thread).

Eines der zentralen Merkmale von async und await ist, dass Sie die SynchronizationContext von dem Anrufer. Für die meisten threads, die Ergebnisse bei der Verwendung der Standard - TaskScheduler (die, wie bereits erwähnt, verwendet die ThreasPool). Aber für den UI-thread es bedeutet, die Buchung der Aufgaben in der Warteschlange und dies bedeutet, dass Sie auf dem Benutzeroberflächenthread ausgeführt. Dies hat den Vorteil, dass Sie nicht haben, um zu verwenden Aufzurufen oder BeginInvoke Zugriff auf UI-Komponenten.

Bevor ich in wie await eine Task aus dem UI-thread ohne ihn zu blockieren, ich möchte zu beachten, dass es möglich ist zu implementieren eine TaskScheduler wo, wenn Sie await auf eine Task Sie nicht sperren thread oder es gehen im Leerlauf, sondern Sie lassen dein thread einen anderen Holen Task, das warten auf die Ausführung. Wenn ich Zurückportieren Aufgaben .NET 2.0 experimentierte ich mit diesem.

Was ist ein Beispiel für eine wirklich asynchrone Methode und wie würden Sie eigentlich arbeiten? Sind diese beschränkt auf I/O-Operationen, die die Vorteile von einigen hardware-Fähigkeiten, so dass kein thread jemals gesperrt?

Scheinen Sie zu verwirren asynchrone mit nicht einen thread blockiert. Wenn das, was Sie wollen, ist ein Beispiel für asynchrone Operationen .NET, die nicht erfordern einen thread blockiert, einen Weg, es zu tun, dass können Sie leicht zu fassen ist die Verwendung Fortsetzungen statt await. Und für die Fortsetzungen, die Sie ausführen müssen, um den auf dem UI-thread, die Sie verwenden können,Aufgabenplaner.FromCurrentSynchronizationContext.

Nicht umsetzen, Phantasie spin warten. Und damit meine ich mit einem Timer, Anwendung.Im Leerlauf oder etwas ähnliches.

Wenn Sie async Sie sagen, den compiler neu zu schreiben den code der Methode in einer Weise, die Sie brechen kann. Das Ergebnis ist ähnlich wie Fortsetzungen, mit einem viel bequemeren syntax. Wenn der thread erreicht eine await die Task geplant werden, und der thread ist frei, auch weiterhin nach den aktuellen async Aufruf (von der Methode). Wenn die Task ist gemacht, die Fortsetzung (nach der await) geplant ist.

Für den UI-thread dies bedeutet, dass, sobald es erreicht await ist es frei, auch weiterhin Nachrichten verarbeiten. Sobald die erwartete Task ist gemacht, die Fortsetzung (nach der await) geplant werden. Als Ergebnis erreichen await bedeutet nicht, um den thread zu blockieren.

Doch blind hinzufügen async und await wird nicht fix alle Ihre Probleme.

Ich Ihnen ein experiment. Erhalten Sie eine neue Windows Forms-Anwendung, Tropfen in ein Taste und ein TextBox, und fügen Sie den folgenden code:

    private async void button1_Click(object sender, EventArgs e)
    {
        await WorkAsync(5000);
        textBox1.Text = @"DONE";
    }

    private async Task WorkAsync(int milliseconds)
    {
        Thread.Sleep(milliseconds);
    }

Es blockiert die Benutzeroberfläche. Was passiert, ist, dass, wie bereits erwähnt, ist await verwendet automatisch die SynchronizationContext von der Aufrufer-thread. In diesem Fall ist der UI-thread. Daher WorkAsync wird auf dem Benutzeroberflächenthread ausgeführt.

Dies ist, was passiert:

• Die UI-threads bekommt, klicken Sie auf die Nachricht und ruft die click-Ereignishandler
• In der click-Ereignis-handler, der UI-thread erreicht await WorkAsync(5000)
• WorkAsync(5000) (und Terminierung Ihrer Fortsetzung) ist geplant auf der aktuellen Synchronisation Kontext des UI-thread-Synchronisation Zusammenhang... was bedeutet, dass es sendet eine Nachricht, um ihn auszuführen,
• Der UI-thread ist jetzt frei, um weiter verarbeitet Nachrichten
• Der UI-thread nimmt die Nachricht zur Ausführung WorkAsync(5000) und planen Ihre Fortsetzung
• Der UI-thread-Aufrufe WorkAsync(5000) mit Fortsetzung
• In WorkAsync im UI-thread läuft Thread.Sleep. Die UI ist nun irresponsive für 5 Sekunden.
• Die Fortsetzung Zeitpläne der rest der click-Ereignishandler ausgeführt werden, dies erfolgt durch Buchung einer anderen Meldung für den UI-thread
• Der UI-thread ist jetzt frei, um weiter verarbeitet Nachrichten
• Der UI-thread nimmt die Nachricht weiterhin in der click-Ereignishandler
• Der UI-thread aktualisiert die textbox

Das Ergebnis ist die synchrone Ausführung, mit overhead.

Ja, sollten Sie Aufgabe.Delay statt. Das ist nicht der Punkt; betrachten Sleep stand für einige Berechnung. Der Punkt ist, dass nur mit async und await überall nicht geben Ihnen eine Anwendung, die automatisch parallel. Es ist viel besser, zu Holen, was Sie wollen run auf einem hintergrund-thread (z.B. auf der ThreadPool) und was wollen Sie auf dem Benutzeroberflächenthread ausgeführt.

Nun versuchen Sie den folgenden code:

    private async void button1_Click(object sender, EventArgs e)
    {
        await Task.Run(() => Work(5000));
        textBox1.Text = @"DONE";
    }

    private void Work(int milliseconds)
    {
        Thread.Sleep(milliseconds);
    }

Finden Sie, die Sie erwarten, nicht blockiert die Benutzeroberfläche. Dies ist, weil in diesem Fall - Thread.Schlaf läuft jetzt auf der ThreadPool Dank Aufgabe.Run. Und Dank button1_Click wird async, sobald der code erreicht await im UI-thread frei ist, weiter zu arbeiten. Nach der Task geschehen ist, wird der code fortgesetzt, nachdem die await Dank für das umschreiben durch den compiler der Methode zu ermöglichen genau das.

Dies ist, was passiert:

• Die UI-threads bekommt, klicken Sie auf die Nachricht und ruft die click-Ereignishandler
• In der click-Ereignis-handler, der UI-thread erreicht await Task.Run(() => Work(5000))
• Task.Run(() => Work(5000)) (und Terminierung Ihrer Fortsetzung) ist geplant auf der aktuellen Synchronisation Kontext des UI-thread-Synchronisation Zusammenhang... was bedeutet, dass es sendet eine Nachricht, um ihn auszuführen,
• Der UI-thread ist jetzt frei, um weiter verarbeitet Nachrichten
• Der UI-thread nimmt die Nachricht zur Ausführung Task.Run(() => Work(5000)) und planen Ihre Fortsetzung, wenn Sie fertig
• Der UI-thread-Aufrufe Task.Run(() => Work(5000)) mit Fortführung, wird dies führen Sie auf die ThreadPool
• Der UI-thread ist jetzt frei, um weiter verarbeitet Nachrichten

Wenn die ThreadPool beendet ist, wird die Fortsetzung geplant wird der rest der click-Ereignishandler ausgeführt werden, dies erfolgt durch Buchung einer anderen Meldung für den UI-thread. Wenn der UI-thread nimmt die Nachricht weiterhin in der click-Ereignis-handler wird es aktualisiert die textbox.

Hier ist der asynchrone code, das zeigt, wie async /await kann code block-und release-regler zu einem anderen fließen, dann wieder Steuern, aber nicht brauchen einen thread.

public static async Task<string> Foo()
{
    Console.WriteLine("In Foo");
    await Task.Yield();
    Console.WriteLine("I'm Back");
    return "Foo";
}


static void Main(string[] args)
{
    var t = new Task(async () =>
    {
        Console.WriteLine("Start");
        var f = Foo();
        Console.WriteLine("After Foo");        
        var r = await f;
        Console.WriteLine(r);
    });
    t.RunSynchronously();
    Console.ReadLine();
}

So ist es, dass das loslassen von Kontrolle und resynching, wenn Sie wollen Ergebnisse, dass die Schlüssel mit async/await ( die gut funktioniert mit threading )

HINWEIS: es werden Keine Threads blockiert wurden in der Herstellung dieser code 🙂

Ich denke manchmal, dass die Verwirrung kommen könnte "Aufgaben" die bedeutet nicht, dass etwas läuft auf einem eigenen thread. Es bedeutet nur eine Sache zu tun, async /await-können die Aufgaben werden aufgeteilt in Phasen und Koordinierung dieser verschiedenen Stufen in einem Fluss.

Es ist ein bisschen wie Kochen Sie das Rezept Folgen. Sie tun müssen alle Vorarbeiten vor der Montage der Schale Kochen. So schalten Sie den Ofen, starten Sie schneiden die Dinge, Gitter, usw. Dann wartest du auf die temp im Ofen und warten auf die Vorbereitungsarbeit. Sie könnte es selbst tun, tauschen zwischen Aufgaben in einer Weise, die logisch scheint (Aufgaben /async /await), aber man kann jemand anderes helfen, Käse reiben, während Sie hacken, Karotten (threads), um Dinge zu erledigen schneller.