Der nicht ganz äquivalente Code: AsyncPublisher entmystifiziert

Der Artikel untersucht das Verhalten von AsyncPublisher im Detail und zeigt, wie Sie es zu Ihrem Vorteil nutzen und wie Sie seine Grenzen umgehen.

Lukáš Valenta · 23. März 2023 · 9 Min. Lesezeit

Read in English →Číst česky →

Die Entwicklung in einer Agentur hat den Vorteil, dass wir häufig neue Projekte starten und so frisch beginnen können, mit einem unbeschriebenen Blatt.

Das heißt, wir können neue APIs von Apple nutzen, ohne uns um die Unterstützung älterer iOS-Versionen mit Legacy-Code kümmern zu müssen. Außerdem können wir auf dem aufbauen, was in früheren Projekten gut funktioniert hat, und frühere Schwächen beseitigen.

In unseren jüngsten Projekten haben wir zum Beispiel Swifts Modern Concurrency eingesetzt, was den Code unserer Anwendung deutlich verschlankt hat. Das Ergebnis war gut nachvollziehbarer Code und eine geringere Fehlerwahrscheinlichkeit als in vergleichbaren Projekten mit Combine.

Die Arbeit mit Modern Concurrency und ein durchdachter Kommentar eines Kollegen im Code-Review haben mir viel über das scheinbar Offensichtliche klargemacht: das Verhalten von AsyncSequence¹ und die Sicherheitsprobleme, die AsyncPublisher mit sich bringt.

Alles begann mit einem Test

Der Code war mit async await geschrieben. Der nächste Schritt war ein Test für seine Funktionalität. Da der Test eine @Published-Property in einem SignInViewModel beobachten sollte, war mein erster Impuls, Combine zu verwenden. Einer der so entstandenen Tests sah wie folgt aus. Die Implementierungsdetails des SignInViewModel würden den Rahmen dieses Artikels sprengen. Seine Hauptaufgabe ist es, die Eingaben (E-Mail und Passwort) zu validieren, wenn bestimmte Bedingungen erfüllt sind. In diesem Fall wird der Fehler unter dem Textfeld angezeigt, sobald es nicht mehr First Responder ist.

func testFilledEmailWithLostPasswordAndEmailFocus() {
    let expectation = XCTestExpectation(description: "ViewError shows correct error strings") 


    let expectedState: SignInView.ViewError = .init(emailError: nil, passwordError: .empty)
    let firstResponders: [SignInView.FocusValue?] = [.password, .email, nil]
    
    // Subscribe to changes of the viewError property and then test that value against the expected state.
    sut.$viewError
        .dropFirst(3)
        .sink(receiveValue: { viewError in
            XCTAssertEqual(viewError, expectedState)
            // Fulfill the expectation to end the test
            expectation.fulfill()
        })
        .store(in: &cancellables)


    // Fill up email and password
    sut.email = "lukas.valenta@cleevio.com"
    sut.password = ""


    // Set first responders to emulate user switching textfields behavior
    firstResponders.forEach { sut.send(action: .becameFirstResponder($0)) }


    // Wait for the expectation to be fulfilled, or time out after 1 second
    wait(for: [expectation], timeout: 1)
}

Der Test lief durch, ich war zufrieden und reichte ihn als Teil eines Merge Requests mit weiterer Sign-in-Funktionalität und weiteren Tests ein.

Im Code-Review schlug ein Kollege vor, im Test async-await statt Combine zu verwenden. Wir haben kurz darüber gesprochen und waren beide überzeugt, dass das Ergebnis äquivalent wäre. Die Idee führte mich in einen Kaninchenbau, aus dem ich eine Weile nicht herausfand. Die umgeschriebenen Tests mit Swifts for-await-Schleife schlugen zufällig fehl. Das ließ mich an der Korrektheit meines Codes und an den Implementierungsdetails des SignInViewModel zweifeln. Als ich mir die Details ansah, stellte sich heraus, dass ein Timeout die Ursache war: Es kam eine andere Anzahl von Werten an als erwartet. Beim Debuggen entdeckte ich, dass das Beobachten von viewError in der for-await-Schleife zu unterschiedlich vielen empfangenen Werten führte. Ich stellte fest, dass sich AsyncSequence anders verhielt, als ich erwartet hatte, obwohl ich verschiedene Bücher, Artikel und die Dokumentation gelesen hatte.

Ziehen wir die Gummistiefel an und fangen wir an zu graben.

Der erste Spatenstich: AsyncPublisher im Vergleich zum Abonnieren über Combine

Das SignInViewModel lasse ich für den Rest dieses Artikels beiseite. Beginnen wir mit etwas Einfachem und steigern wir die Komplexität Schritt für Schritt, um zu verstehen, was hier passiert: warum die Tests fehlschlugen und warum das zufällig geschah. Lassen wir die Dokumentation hinter uns, beobachten wir das Verhalten und leiten wir die Erklärung her, sobald wir so weit sind.

Bereiten wir zuerst einen Publisher vor. PassthroughSubject sollte dafür ein guter Kandidat sein:

import Combine


let subject: PassthroughSubject<Int, Never> = .init()

Beobachten wir ihn mit einem einfachen sink in Combine und über eine for-await-Schleife und geben wir den empfangenen Wert aus.

var cancellables: Set<AnyCancellable> = .init()


// Combine observing
subject
    .sink(receiveValue: { integer in 
        print("Sink: \(integer)")
    })
    .store(in: &cancellables)


// Observing with for await loop
for await integer in subject.values {
    print("Async for loop: \(integer)")
}

Noch gibt es nichts zu beobachten, schicken wir also etwas durch die Pipe:

for integer in 0..<100 {
    subject.send(integer)
}

Wenn Sie nun in die Konsole schauen, sehen Sie viele ausgegebene Ergebnisse. Und wenn Sie sich die Ausgaben genau ansehen, sind es höchstwahrscheinlich aus beiden Quellen gleich viele: AsyncPublisher verhält sich wie ein einfacher sink.

Warum also schlug es im Test fehl und hier nicht? Eine Ahnung davon, was passiert, gab mir der Initializer von AsyncStream. Er sieht so aus:

init(Element.Type, bufferingPolicy: AsyncStream<Element>.Continuation.BufferingPolicy, (AsyncStream<Element>.Continuation) -> Void)

Aufgefallen ist mir der Parameter bufferingPolicy, der bestimmt, wie ungenutzte Elemente der Sequenz gepuffert werden: ob sie bleiben (und gepuffert werden) oder verworfen werden. Prüfen wir die Annahme, dass der Unterschied zwischen for-await-Schleife und sink sichtbar wird, wenn wir mit einer rechenintensiven Aufgabe eine Verzögerung einbauen, etwa mit der Suche nach der n-ten Primzahl über den Aufruf primeCount(100)².

// Combine observing
subject
    .sink(receiveValue: { integer in 
        countPrimes(100)
        print("Sink: \(integer)")
    })
    .store(in: &cancellables)


// Observing with for await loop
for await integer in subject.values {
    countPrimes(100)
    print("Async for loop: \(integer)")
}

Mit der Verzögerung haben wir endlich ein minimales beobachtbares Beispiel für das Problem. Wie Sie sehen, stimmt die Anzahl der Ausgaben nicht mehr überein: Einige Zahlen werden in der for-await-Schleife übersprungen, was zu unterschiedlichen Ergebnissen von Lauf zu Lauf führt. Bemerkenswert ist, dass die höchste Zahl in der asynchronen for-Schleife oft nicht 99 ist, sondern etwa 97, die letzte korrekt verarbeitete Zahl.

Warum verhält sich die for-await-Schleife so? Vermutlich verwendet sie eine Buffering Policy, die manche Elemente verwirft, die nicht sofort konsumiert werden. Die genaue Einstellung der Buffering Policy ist für diese Untersuchung nicht entscheidend, aber wie Sie im Abschnitt über AsyncStream sehen werden, wird eine Menge gepuffert.

Am wichtigsten ist jedoch, wie die for-await-Schleife arbeitet. Sie setzt die Iteration erst fort, wenn die Closure der aktuellen Iteration abgeschlossen ist. So iteriert die for-Schleife synchron, während sie die Elemente der Sequenz asynchron erhält.

Unterschiede zählen

Es ist zwar interessant zu sehen, dass die Anzahl der Ausgaben variiert, aber wir müssen dafür immer noch in den Code schauen und raten. Bereiten wir einen Zähler vor, um die Ergebnisse verlässlicher darzustellen. Ich habe den Zähler als Actor gebaut, der einen Typ als Parameter entgegennimmt, damit die Konsole übersichtlich bleibt. Die Implementierung sieht so aus:

final actor CounterActor {
    enum ObservingType {
        case async
        case combine
    }
    
    let type: ObservingType
    var count: Int = 0
    
    init(type: ObservingType) {
        self.type = type
    }
    
    func addToCount() {
        count += 1
        print("Count \(type): \(count)")
    }
}

Wie Sie sehen, erhöht sich der Zähler nach jedem Aufruf von addToCount() um eins, und der Zählerstand des Typs wird ausgegeben. Für uns ist also die letzte Ausgabe eines Typs die relevante.

Testen wir das und sehen wir uns die Ergebnisse an. Zuerst instanziieren wir die Zähler und verwenden sie in unserem bestehenden Code (in der Combine-Variante müssen wir einen Task erzeugen, um die asynchrone Funktion aufzurufen):

let asyncCounter = CounterActor(type: .async)
let combineCounter = CounterActor(type: .combine)


// Combine observing
subject
    .sink(receiveValue: { integer in 
        countPrimes(100)
        Task {
            await combineCounter.addToCount()
        }
    })
    .store(in: &cancellables)


// Observing with for await loop
for await integer in subject.values {
    countPrimes(100)
    await asyncCounter.addToCount()
}

Jetzt sehen wir endlich in Zahlen, wie viel verloren gegangen ist. Die letzte Ausgabe des Combine-Zählers ist 100, bei async ist es 83. Auf meinem M1 Max ohne Optimierungen sind also 17 % verloren gegangen.

Die for-await-Schleife von AsyncPublisher zum Laufen bringen

Wir haben nun eine Ausgangsbasis und eine Testumgebung. Wir haben gesehen, dass Combine problemlos funktioniert. Konzentrieren wir uns jetzt darauf, die for-await-Schleife so zu korrigieren, dass sie die gewünschten Ergebnisse liefert.

Zum Glück ist die Lösung einfach. Wir müssen einen Task erzeugen und die Elemente in der for-await-Schleife asynchron verarbeiten, ohne zu warten. Damit verlieren wir die Vorteile der sequenziellen Codeausführung, die Modern Concurrency bietet. Das Problem, mit dem wir uns beschäftigen, ist damit aber behoben.

// Observing with for await loop
for await integer in subject.values {
    Task {
        countPrimes(100)
        await asyncCounter.addToCount()
    }
}

Diese Lösung funktioniert, weil das Erzeugen eines Tasks keine rechenintensive Aktion ist, durch die uns ein Integer verloren ginge. Unter normalen Umständen sollte dieser Ansatz gut funktionieren.

AsyncPublisher ist nicht sicher

Im vorigen Abschnitt sind wir an einem Punkt angekommen, an dem alles so funktionierte, wie wir es wollten: Durch die asynchrone Verarbeitung der Elemente der Sequenz erhielten wir in der for-await-Schleife dieselben Ergebnisse wie mit Combine. Heißt das, dass wir AsyncPublisher bedenkenlos einsetzen können, ohne Eingaben zu verlieren? Leider nein.

Es genügt, einen Wert nebenläufig zu senden, und wir sind wieder da, wo wir angefangen haben. In meiner Arbeitsumgebung stand der Zähler nach Ausführung des folgenden Codes bei Combine auf 1000 und bei async auf 695. Nicht gerade toll.

await withTaskGroup(of: Void.self) { group in 
    for _ in 0..<10 {
        group.addTask {
            for integer in 0..<100 {
                subject.send(integer)
            }
        }
    }
}

Das Beobachten mit einer for-await-Schleife ist leider nicht sicher und kann zu Datenverlust führen. Je nach Situation gibt es Möglichkeiten, das Problem abzumildern. Wenn wir zum Beispiel wissen, wie viele Elemente wir erhalten, können wir collect() auf dem Publisher verwenden. Ich sehe jedoch keinen guten Weg, die for-await-Schleife so arbeiten zu lassen wie ein Abonnement des Publishers in Combine, wo wir das immer über asynchronen Code abfangen können. Ich habe mehrere andere Optionen ausprobiert, etwa einen AsyncIterator aus AsyncPublisher zu erzeugen, aber das brachte keine positiven Ergebnisse.

Diese Einschränkungen liegen in der Natur der for-await-Schleife, da sie nur auf einem Thread arbeitet und keine Garantien gibt. In bestimmten Anwendungsfällen können wir diese Einschränkung aber zu unserem Vorteil nutzen, vor allem zusammen mit AsyncSequence oder ihrer Implementierung AsyncStream.

AsyncStream eilt zur Rettung

AsyncStream ist eine eingebaute Implementierung von AsyncSequence im asynchronen Kontext. Er erlaubt es, seine Ergebnisse in einer Sequenz per await abzuwarten, und ebenso, jederzeit über seine Continuation in die Sequenz zu publizieren (yield in der Async-Terminologie).

Die Instanziierung ist sehr einfach. Für unsere Zwecke können wir etwa Folgendes tun:

var asyncStream: AsyncStream<Int>!
var storedContinuation: AsyncStream<Int>.Continuation!


asyncStream = AsyncStream { continuation in 
    storedContinuation = continuation
}

Wie Sie sehen, speichere ich den asyncStream in einer Variable, damit wir ihn später im Code verwenden können, und ebenso die Continuation. Obwohl wir die Variablen unsicher unwrappen, ist der Code sicher, weil AsyncStream die Continuation in seinem init sofort zurückgibt (die übergebene Closure verlässt den aktuellen Scope nicht).

Den AsyncStream zu beobachten ist einfach: Wir müssen nur eine kleine Änderung an unserer for-await-Schleife vornehmen. Da AsyncStream eine AsyncSequence ist, können wir direkt darüber iterieren, wie über jede andere Collection (etwa Array). Der einzige Unterschied ist, dass wir es asynchron tun.

// Observing AsyncStream with for-await loop
for await integer in asyncStream {
    Task {
        countPrimes(100)
        await asyncCounter.addToCount()
     }
}

Bleiben wir bei unserem Beispiel: So würden wir die Integer per yield an die Continuation übergeben:

for integer in 0..<100 {
    storedContinuation.yield(integer)
}

Mit AsyncStream erreicht der Zähler jedes Mal 100. Dasselbe gilt, wenn wir mit dem bereits verwendeten Code bis 1000 zählen. Kein einziger Integer geht verloren.

await withTaskGroup(of: Void.self) { group in 
    for _ in 0..<10 {
        group.addTask {
            for integer in 0..<100 {
                storedContinuation.yield(integer)
            }
        }
    }
}

Wir müssen die Elemente nicht einmal mehr asynchron verarbeiten und können den Beobachtungscode daher vereinfachen zu:

// Observing AsyncStream with for await-loop simplified
for await integer in asyncStream {
    countPrimes(100)
    await asyncCounter.addToCount()
}

Und warum funktioniert AsyncStream? Wegen seiner Buffering Policy, die bei der Initialisierung festgelegt wird. Standardmäßig ist die Policy unbounded, das heißt, jeder Integer wird gepuffert, egal wie lange die Verarbeitung einer einzelnen Iteration dauert.

Wir könnten diese Fähigkeit unseres AsyncStream durchaus zerstören, wenn wir wollten. Würden wir AsyncStream zum Beispiel mit bufferingPolicy: .bufferingNewest(1) initialisieren, würde der Zähler nur 2 statt 1000 anzeigen. Das stützt die Hypothese, dass AsyncPublisher eine Buffering Policy hat, möglicherweise eine großzügige. Ihre Grenzen müssen wir aber noch verstehen, für Situationen, in denen wir ihn brauchen.

asyncStream = AsyncStream(bufferingPolicy: .bufferingNewest(1)) { continuation in 
    storedContinuation = continuation
}

AsyncStream ist der Held unserer Geschichte, weil wir mit ihm die Buffering Policy an unsere Bedürfnisse und Erwartungen anpassen können. Er ermöglicht es uns, asynchrone Werte in einem asynchronen Kontext zu beobachten.

Und wenn wir einen Combine-Publisher beobachten müssen?

Die Frage lautet: Wie beobachten wir einen Combine-Publisher asynchron? Wie ich zuvor gezeigt habe, erreichen wir das, indem wir im sink des Subscribers einfach Task {} aufrufen. Mit dieser Methode können wir allerdings nicht die geordnete Verarbeitung der Elemente nutzen, die eine for-await-Schleife bietet.

Wenn wir einen eigenen Publisher erstellen, empfehle ich, AsyncStream statt Combine-Publishern zu verwenden, solange wir die reaktive Magie nicht für andere Teile des Codes brauchen.

Wenn wir keinen eigenen AsyncStream erstellen können oder einen Publisher beobachten wollen, den wir nicht selbst erstellt haben, können wir jederzeit einen AsyncStream erzeugen, den Publisher abonnieren und die Werte per yield an den AsyncStream weitergeben.

 //Combine observing and sending it to AsyncStream via Continuation
subject
    .sink(receiveValue: { integer in 
        storedContinuation.yield(integer)
    })
    .store(in: &cancellables)

Und um weniger abstrakt zu werden: Ich denke, der Unterschied zwischen dem Beobachten eines Streams in einer for-await-Schleife mit Abwarten der Ergebnisse und dem Beobachten in Combine mit sink lässt sich gut an der Anzeige von Informationsmeldungen in der Anwendung zeigen.

Nehmen wir an, wir haben die folgende Funktion, aus der wir die infoBar anzeigen:

func showInfoBar(with content: InfoBarContent, completion: (() -> Void)? = nil)

Wenn wir den Publisher in Combine beobachten, erhalten wir das folgende Ergebnis. Wie Sie sehen, werden die Meldungen übereinander angezeigt, was nicht gerade ideal ist.

Wir können es aber jederzeit über AsyncStream lösen und das Ergebnis der Completion mit withCheckedContinuation abwarten, etwa so:

@MainActor
private func observeInfoBarContent() async {
    for await content in infoBarManager.infoBarContentStream {
        await withCheckedContinuation { continuation in
            showInfoBar(with: content) {
                continuation.resume()
            }
        }
    }
}

Das Ergebnis sind lesbare Meldungen, die nacheinander angezeigt werden. Wir bekommen das gewünschte Verhalten ohne Schwierigkeiten. Und das Beste: Wir können Modern Concurrency nutzen, sodass der Code gut lesbar ist.

Abschließende Gedanken

Die unvollständige Dokumentation ist der Grund für unser begrenztes Verständnis von Swifts Modern Concurrency, und es bleibt noch viel zu lernen. Deshalb können wir nur vermuten und raten. Zwar könnten wir durch die Analyse des Quellcodes mehr erfahren, doch wäre das womöglich keine gute Verwendung unserer Zeit, und es dürfte schwer sein, alle Details allein durch Hinsehen zu erfassen.

Deshalb sind weitere Untersuchungen in diesem Bereich nötig. Ich hoffe, dass mehr Menschen tiefer einsteigen, statt nur an der Oberfläche zu kratzen.

Bis dahin sollten wir nicht vorschnell jedes Stück Code ohne sorgfältige Überlegung auf async-await umschreiben. Wir sollten unsere Annahmen immer prüfen, um keine unnötigen Bugs einzubauen.

¹ Im Kern ermöglicht AsyncPublisher, jedes Ergebnis eines Publishers in einer asynchronen for-await-Schleife zu beobachten. Mehr dazu finden Sie in der Dokumentation: https://developer.apple.com/documentation/combine/asyncpublisher

² Einen Gist finden Sie hier: https://gist.github.com/lvalenta/07770221e7d653f6cfad6f2bda63af73. Es ist nur eine beliebige Funktion, die ein Kollege gefunden hat.

Lukáš ValentaiOS Developer
Als Nächstes lesen

Mehr aus dem Blog.

Awards & recognition

Built to stand out.

GDPR compliantZero data retention
Clutch Global Fall 2023Clutch Global Spring 2024Clutch Global Fall 2024Clutch Top Web3 Development — Czech Republic 2024
Deloitte Technology Fast 50 — 2023 Central EuropeDeloitte Technology Fast 50 — Czech RepublicDeloitte Technology Fast 500 — 2023 EMEA
Second opinion

Ask someone
who isn't us.

We've pre-loaded the context.
Ask what we're good at — and what we're not.

Opens a new chat, context already written.

Sales & AI Advisory

Start with Jakub.

Bring a business problem, a process or an idea. We’ll help you find the right next step.

A short intro call is often the fastest way to see what’s worth pursuing.

Jakub DurecFrom makers to makers
Jakub DurecAI Advisory Lead

We use cookies

Privacy policy