Async Await für parallelen Code

  • VB.NET
  • .NET 7–8

Es gibt 36 Antworten in diesem Thema. Der letzte Beitrag () ist von Haudruferzappeltnoch.

    Jo. Ich habe mich auch schon wieder länger nicht mit dieser async-await Geschichte befasst.

    Das wäre für mich irgendwie die richtige und logische Vorgehensweise.
    Spoiler anzeigen

    C#-Quellcode

    1. internal partial class Program
    2. {
    3. public static void Main()
    4. {
    5. //TestSeq();
    6. TestParallelAsyncAwait();
    7. //TestParallelOnlyTask();
    9. //TestParallelForEach();
    11. Console.ReadLine();
    12. }
    14. private static void TestSeq()
    15. {
    16. //Se­quen­zi­eller Ablauf.
    18. Thread.Sleep(1000);
    20. Console.WriteLine($"{nameof(TestSeq)}: {DateTime.Now.ToLongTimeString()}");
    21. Console.WriteLine("Start");
    23. //se­quen­zi­eller Ablauf ohne Rücksetzung (using) der Task.
    24. //Vorgehensweise wird oft verwendet, ist aber streng genommen
    25. //nicht die richtige, weil für die sequentielle kein Task
    26. //gebraucht wird.
    27. //Task.Run(HeavyWork1).Wait();
    28. //Task.Run(HeavyWork2).Wait();
    30. HeavyWork1();
    31. HeavyWork2();
    33. Console.WriteLine("End");
    34. Console.WriteLine($"{nameof(TestSeq)}: {DateTime.Now.ToLongTimeString()}");
    35. Console.WriteLine();
    36. }
    38. private async static void TestParallelAsyncAwait()
    39. {
    40. //Alle Task laufen Parallel mit async await
    42. Thread.Sleep(1000);
    44. Console.WriteLine($"{nameof(TestParallelAsyncAwait)}: {DateTime.Now.ToLongTimeString()}");
    45. Console.WriteLine("Start");
    47. using var t1 = Task.Run(HeavyWork1);
    48. using var t2 = Task.Run(HeavyWork2);
    50. // .. oder wenn z.B. CancellationToken verwendet wird.
    51. //await t1.WaitAsync();
    52. //await t2.WaitAsync();
    54. //... oder so
    55. //var tasks = new List<Task> { t1, t2 };
    56. //await Task.WhenAll(tasks);
    58. //... oder so
    59. await Task.WhenAll(t1, t2);
    61. Console.WriteLine("End");
    62. Console.WriteLine($"{nameof(TestParallelAsyncAwait)}: {DateTime.Now.ToLongTimeString()}");
    63. Console.WriteLine();
    64. }
    66. private static void TestParallelOnlyTask()
    67. {
    68. //Alle Task laufen Parallel OHNE async await
    70. Thread.Sleep(1000);
    72. Console.WriteLine($"{nameof(TestParallelOnlyTask)}: {DateTime.Now.ToLongTimeString()}");
    73. Console.WriteLine("Start");
    75. using var t1 = Task.Run(HeavyWork1);
    76. using var t2 = Task.Run(HeavyWork2);
    78. //mit jeweiligen Wait() ...
    79. //t1.Wait(); t2.Wait();
    81. //..Alle Wait() einfach über eine foreach
    82. //Task[] tasks = [ t1, t2 ];
    83. //foreach (var t in tasks)
    84. // t.Wait();
    86. //.. oder die schönste vorgehensweise
    87. Task.WaitAll(t1, t2);
    89. Console.WriteLine("End");
    90. Console.WriteLine($"{nameof(TestParallelOnlyTask)}: {DateTime.Now.ToLongTimeString()}");
    91. Console.WriteLine();
    92. }
    94. private static void TestParallelForEach()
    95. {
    97. //Alle Task laufen Parallel OHNE async-await
    99. Thread.Sleep(1000);
    101. Console.WriteLine($"{nameof(TestParallelForEach)}: {DateTime.Now.ToLongTimeString()}");
    102. Console.WriteLine("Start");
    104. using var t1 = Task.Run(HeavyWork1);
    105. using var t2 = Task.Run(HeavyWork2);
    106. Task[] tasks = [t1, t2];
    108. //Da Task die 'Task.WhenAll' besitzt,
    109. //macht die Parallel.ForEach keinen Sinn.
    110. //Möglich ist die vorgehensweise aber.
    111. var plr = Parallel.ForEach(tasks, t =>
    112. {
    113. t.Wait();
    114. });
    116. //while (!plr.IsCompleted) ;
    118. Console.WriteLine("End");
    119. Console.WriteLine($"{nameof(TestParallelForEach)}: {DateTime.Now.ToLongTimeString()}");
    120. Console.WriteLine();
    121. }
    123. private static void HeavyWork1()
    124. {
    125. Console.WriteLine($"{nameof(HeavyWork1)} Before: {DateTime.Now.ToLongTimeString()}");
    127. Thread.Sleep(1000);
    129. Console.WriteLine($"{nameof(HeavyWork1)} After: {DateTime.Now.ToLongTimeString()}");
    130. }
    132. private static void HeavyWork2()
    133. {
    134. Console.WriteLine($"{nameof(HeavyWork2)} Before: {DateTime.Now.ToLongTimeString()}");
    136. Thread.Sleep(1000);
    138. Console.WriteLine($"{nameof(HeavyWork2)} After: {DateTime.Now.ToLongTimeString()}");
    139. }
    140. }

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „exc-jdbi“ () aus folgendem Grund: Bisserl ausgehübst

    Der Code in Post#15 ergibt, nach Ergänzung, dass in Test1 die Tasks - entsprechend Wait - nacheinander abgearbeitet werden, in Test 2 gleichzeitig. Ok, da ist jetzt unklar, warum. Es macht ja quasi das gleiche. Ob jetzt

    Quellcode

    1. A()
    2. B()
    oder

    VB.NET-Quellcode

    1. For Each C In {A, B}
    2. C()
    3. Next
    Ich verstehe das Problem langsam.

    ##########

    VB.NET-Quellcode

    1. Dim A = Task.Run(AddressOf HeavyWork1)
    2. Dim B = Task.Run(AddressOf HeavyWork2)
    3. A.Wait()
    4. B.Wait()

    Das führt zum gleichen Ergebnis wie die For-Schleife. Beide Tasks werden gleichzeitig gestartet (also nicht nur vorbereitet) und B.Wait wird erreicht, wenn ein Task fertig ist.
    Bilder

    • Console.png

      9,97 kB, 635×344, 24 mal angesehen
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VaporiZed“ ()

    Haudruferzappeltnoch schrieb:

    Task.Run(AddressOf HeavyWork1).Wait
    Task.Run(AddressOf HeavyWork2).Wait


    Haudruferzappeltnoch schrieb:

    For Each t In {Task.Run(AddressOf HeavyWork1), Task.Run(AddressOf HeavyWork2)}
    t.Wait()
    Next



    sind leider nicht das gleiche weil in der foreach wird eine Array<Task> abgearbeitet, und in der oben ist es die Wait-Methode, also eine void-Methode die nacheinander aufgerufen wird ohne vorher je ein Task-Datentyp erzeugt zu haben.

    So Task.Run(AddressOf HeavyWork2).Wait wird also nie vorab ein Task-Datentyp erstellt. Der ist aber anscheinend notwending, um alle Wait-Methoden zusammenzuführen um es nachher Parallel wie es in der Foreach gemacht wird auszuführen.

    Gruss exc-jdbi

    VB.NET-Quellcode

    1. For Each t In {Task.Run(AddressOf HeavyWork1), Task.Run(AddressOf HeavyWork2)}
    2. t.Wait()
    3. Next
    Zeile#1 erzeugt 2 Tasks, und die rennen schon.
    In zeile#2 wird zunächstmal auf Task1 gewartet.
    Wenn er durch ist wird direkt danach auf Task2 gewartet. Der ist aber schon die ganze Zeit gelaufen, und deshalb ist die Rest-Wartezeit natürlich kürzer.
    Bzw. wenn Task2 schon fertig ist, wenn auf ihn gewartet werden soll ist die Rest-Wartezeit 0.

    Insgesamt wird also bei dieser Konstruktion auf den langsamsten der beiden Tasks gewartet, egal obs Task1 ist oder Task2.

    Dank der Erkenntnisse, die ihr mir vermitteln konntet, habe ich nun die Async/Await Version gefunden (also kein Run, WhenAny, WhenAll):

    VB.NET-Quellcode

    1. Module Program
    2. Sub Main()
    3. HeavyWorkReihe()
    4. HeavyWorkParallel()
    5. Console.ReadLine()
    6. End Sub
    8. Private Sub HeavyWorkReihe()
    9. Thread.Sleep(1000)
    10. Console.WriteLine($"{NameOf(Test1)}: {Date.Now.ToLongTimeString()}")
    11. Console.WriteLine("Start")
    12. HeavyWork1()
    13. HeavyWork2()
    14. Console.WriteLine("End")
    15. Console.WriteLine($"{NameOf(Test1)}: {Date.Now.ToLongTimeString()}")
    16. Console.WriteLine()
    17. End Sub
    19. Private Sub HeavyWorkParallel()
    20. Thread.Sleep(1000)
    21. Console.WriteLine($"{NameOf(Test2)}: {Date.Now.ToLongTimeString()}")
    22. Console.WriteLine("Start")
    23. Dim A = HeavyWork1Async()
    24. Dim B = HeavyWork2Async()
    25. A.Wait()
    26. B.Wait()
    27. Console.WriteLine("End")
    28. Console.WriteLine($"{NameOf(Test2)}: {Date.Now.ToLongTimeString()}")
    29. Console.WriteLine()
    30. End Sub
    32. Private Sub HeavyWork1()
    33. HeavyWork1Async.Wait()
    34. End Sub
    36. Private Sub HeavyWork2()
    37. HeavyWork2Async.Wait()
    38. End Sub
    40. Private Async Function HeavyWork1Async() As Task
    41. Console.WriteLine($"{NameOf(HeavyWork1)} Before: {Date.Now.ToLongTimeString()}")
    42. Await Task.Delay(1000)
    43. Console.WriteLine($"{NameOf(HeavyWork1)} After: {Date.Now.ToLongTimeString()}")
    44. End Function
    46. Private Async Function HeavyWork2Async() As Task
    47. Console.WriteLine($"{NameOf(HeavyWork2)} Before: {Date.Now.ToLongTimeString()}")
    48. Await Task.Delay(1000)
    49. Console.WriteLine($"{NameOf(HeavyWork2)} After: {Date.Now.ToLongTimeString()}")
    50. End Function
    51. End Module

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Haudruferzappeltnoch“ ()

    jo, und nu probierma so:

    VB.NET-Quellcode

    1. Private Async Sub HeavyWorkParallel2()
    2. Thread.Sleep(1000)
    3. Console.WriteLine($"{NameOf(HeavyWorkParallel2)}: {Date.Now.ToLongTimeString()}")
    4. Console.WriteLine("Start")
    5. Await Task.WhenAll(HeavyWork1Async(), HeavyWork2Async())
    6. Console.WriteLine("End")
    7. Console.WriteLine($"{NameOf(HeavyWorkParallel2)}: {Date.Now.ToLongTimeString()}")
    8. Console.WriteLine()
    9. End Sub

    Funktioniert, aber hier kommt jetzt der Punkt den ich immer noch nicht verstehe:
    Das funktioniert auch:

    VB.NET-Quellcode

    1. Private Sub HeavyWorkParallel2()
    2. Thread.Sleep(1000)
    3. Console.WriteLine($"{NameOf(HeavyWorkParallel2)}: {Date.Now.ToLongTimeString()}")
    4. Console.WriteLine("Start")
    5. Task.WhenAll(HeavyWork1Async(), HeavyWork2Async()).Wait()
    6. Console.WriteLine("End")
    7. Console.WriteLine($"{NameOf(HeavyWorkParallel2)}: {Date.Now.ToLongTimeString()}")
    8. Console.WriteLine()
    9. End Sub
    Wo ist da jetzt noch der Unterschied?
    Und ich finde es auch ganz unintuitiv, dass ich aus dem Ausführen von Tasks wieder eine neue Task mache, was die WhenAll, Run, etc. Methoden ja tun. Ist das nicht doppelt gemoppelt?

    Await Task entspricht Task.Wait. Await kam einfach syntaktisch später.

    ##########

    hab's nicht komplett gelesen, aber hier ein Artikel dazu
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VaporiZed“ ()

    Das ist genau der Punkt wo ich Unterschiede zwischen Consolenanwendungen oder Windowsprogrammen, obwohl ich diese Unterscheidung nicht unbedingt gerne mache.

    Das von EDR in #29 gezeigte Beispiel funkst nämlich in einem Windowsprogramm, weil dort das Fenster nach dem aufgebaut konstant auf dem Bildschirm gezeigt wird.

    In der Consolenanwendung funkst das nur, wenn ein Console.ReadLine() oder etwas dergleichen vorliegt. Ich stell mir das immer vor, wie ein sehr grosser Winderstand der das Ausführen von noch nicht ausgeführten Task zwingt, endlich ausgeführt zu werden. (Ähnlich wie DoEvent).

    Ein weiteres Vorteil den ich im Zusammenhang mit async-await nutzen will, ist die Entscheidung, wann und vorallem wo, ein Task komplett fertig ausgeführt wird. Da Void-Methoden keinen Rückgabewert haben, kann ich als Entwickler nicht direkt entscheiden wo und wann der Task komplett fertig ausgeführt wird. Die Ausführung muss nämlich in der entsprechenden Void-Methode direkt gemacht werden. (ausser man arbeitet mit Fenster dann kann wie der Code von EDR zeigt der Task auch so zum direkten Ausführen gebracht werden, dass funkst dann mit der deklaration von await, und die Wait()-Methode muss nicht mehr erwähnt werden.)

    EDIT: Wer sich Async/Await in Anwendung einer Console anschauen will, ich habe hier das Generieren von Primes so umgesetzt.
    Power Fast Prime Generator

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „exc-jdbi“ ()

    VaporiZed schrieb:

    Await Task entspricht Task.Wait. Await kam einfach syntaktisch später.
    Nein. Task.Wait blockiert den aktuellen Thread. Da geht dann nichts mehr - eingefrorene Bildschirm. In einer Console mag das sehr erwünscht sein.
    Await returnt die Async-Methode vorzeitig.sodasss der MainThread nicht blockiert.
    Wenn der NebenThread dann durch ist, springt er wieder an die Await-Stelle und macht danach weiter.
    Kaum zu glauben, schwer zu verstehen, aber in Winforms ungemein praktisch.
    Hier isses richtig erklärt: codeproject.com/Articles/10296…ithout-any-additional-Lin

    Folgende Schleife:

    VB.NET-Quellcode

    1. Dim Tasks As New List(Of Task)
    2. For Each dest In {New FileInfo(path1), New FileInfo(path2)}
    3. Tasks.Add(Task.Run(Sub()
    4. For Each request In Requests
    5. SendTo(dest, request)
    6. Next
    7. End Sub))
    8. Next
    9. Await Task.WhenAll(Tasks)
    10. For Each t In Tasks
    11. t.Dispose()
    12. Next
    gibt es da was dran zu verbessern?
    Also die Requests laufen anständig synchron und die Destinations parallel.

    Haudruferzappeltnoch schrieb:

    gibt es da was dran zu verbessern?


    Lass das Dispose noch weg, Tasks müssen nicht Disposed werden:

    Do I need to dispose of Tasks?
    Here’s my short answer to this question:
    “No. Don’t bother disposing of your tasks.”

Facebook
Telefonspende