/* Page prose (de) */
"RunningWorkConcurrentlyWithAsyncLet" = "# Arbeit nebenläufig mit `async let` ausführen\n\nHier fängt async/await an, sich auszuzahlen. Angenommen, ein Latte braucht zwei langsame Schritte: die Milch aufschäumen *und* den Shot ziehen. Jeder dauert etwa eine Sekunde. Stoppen wir zuerst die naheliegende Version:";
"RunningWorkConcurrentlyWithAsyncLet-2" = "Diese beiden Awaits laufen **sequenziell**: jedes `await` wird vollständig abgeschlossen, bevor die nächste Zeile beginnt. Die Milch schäumt auf (1 s), und erst *dann* startet der Shot (weitere 1 s). Gesamt: etwa **2 Sekunden**. Aber Milch aufschäumen und einen Shot ziehen hängen nicht voneinander ab; ein echter Barista würde sie gleichzeitig erledigen.\n\n`async let` lässt dich genau das sagen. Es **startet** die asynchrone Arbeit sofort und bindet das eventuelle Ergebnis an einen Namen; du machst `await` auf diesen Namen nur, wenn du den Wert tatsächlich brauchst:";
"RunningWorkConcurrentlyWithAsyncLet-3" = "Die beiden `async let`-Zeilen stoßen beide Arbeitsstücke direkt hintereinander an, ohne zu warten. Wenn du das `await` in der nächsten Zeile erreichst, haben sie die ganze Zeit *parallel* geschäumt und gezogen.\n\n**Sieh es laufen:** diese Seite gibt `Concurrent total: 1.0x s` aus. Vergleiche das mit der sequenziellen Version oben, die `Sequential total: 2.0x s` ausgibt, die beiden Ein-Sekunden-Wartezeiten aufgestapelt statt überlappt.\n\nDas ist die Schlagzeile: **zwei 1-Sekunden-Aufgaben werden in ~1 s fertig, nicht in ~2 s.** Du hast keine Threads oder Warteschlangen von Hand hinzugefügt; du hast Swift nur gesagt, welche Arbeit unabhängig war, und es hat das Warten für dich überlappt. Die verstrichenen Zahlen werden nicht genau `1.00` oder `2.00` sein (es gibt ein wenig Overhead), aber die Beinahe-Halbierung ist unverkennbar.\n\n> **Warum `async let` und nicht zwei `await`s?** Ein einfaches `await` *wartet* genau dort, wo es steht, sodass der zweite Aufruf nicht beginnen kann, bis der erste zurückkehrt. `async let` *startet* die Arbeit und verschiebt das Warten, was genau das ist, wodurch zwei unabhängige Aufgaben gleichzeitig laufen können. Greif danach, wann immer du Arbeit hast, die nicht von den Ergebnissen der anderen abhängt.\n\nDas ist dein erster Vorgeschmack auf **strukturierte Nebenläufigkeit**: mehrere Arbeitsstücke starten und ihre Ergebnisse innerhalb eines klaren Geltungsbereichs einsammeln. `async let` bewältigt zwei oder drei feste Stücke gut. Wenn du eine ganze *Sammlung* von Arbeit hast (sagen wir, zehn Getränke auf einmal), willst du eine **`TaskGroup`**, die der Schwerpunkt des Kapitels [Task Groups](Task%20Groups.playgroundchapter/Overview) ist. Und die Details von `Task` selbst kommen zuerst, im Kapitel [Tasks und Abbruch](Tasks%20and%20Cancellation.playgroundchapter/Overview).\n\n* callout(Probier es aus): Ändere die Verzögerung von `pullShot()` auf `.seconds(2)` und lass `steamMilk()` bei `.seconds(1)`, wie hoch ist der nebenläufige Gesamtwert jetzt, und welcher Schritt entscheidet ihn?\n\n[Zurück](@previous)  |  Seite 7 von 8  |  [Weiter: Zusammenfassung](@next)";
