Kód, který není tak úplně ekvivalentní: jak doopravdy funguje AsyncPublisher

Článek podrobně zkoumá chování AsyncPublisher a ukazuje, jak ho využít ve svůj prospěch i jak obejít jeho omezení.

Lukáš Valenta · 23. března 2023 · 8 min čtení

Read in English →Auf Deutsch lesen →

Vývoj v agentuře má tu výhodu, že často začínáme nové projekty, a můžeme tak pokaždé začít s čistým listem.

Můžeme tak využívat nová API od Applu a nemusíme řešit podporu starších verzí iOS s legacy kódem. Zároveň můžeme stavět na tom, co se osvědčilo v předchozích projektech, a zbavit se dřívějších nedostatků.

V posledních projektech jsme například nasadili moderní concurrency ve Swiftu, která kód aplikace výrazně zjednodušila. Kód se díky ní snadno čte a pravděpodobnost chyb je nižší než u podobných projektů postavených na Combine.

Práce s Modern Concurrency a jeden promyšlený komentář kolegy v code review mi pomohly uvědomit si spoustu věcí o něčem zdánlivě samozřejmém, totiž o chování AsyncSequence¹, a také o tom, v čem AsyncPublisher není bezpečný.

Všechno začalo testem

Kód byl napsaný pomocí async await. Dalším krokem bylo napsat test jeho funkčnosti. Protože test sledoval vlastnost @Published v SignInViewModel, napadlo mě nejdřív použít Combine. Jeden z výsledných testů vypadal následovně. Implementační detaily SignInViewModel jsou nad rámec tohoto článku. Jeho hlavním úkolem je validovat vstupy (e-mail a heslo), když jsou splněny určité podmínky. V tomto případě se chyba zobrazí pod textovým polem ve chvíli, kdy pole přestane být first responderem.

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)
}

Test prošel, byl jsem spokojený a odeslal jsem ho jako součást merge requestu s další funkčností přihlášení a dalšími testy.

Při code review kolega navrhl použít v testu místo Combine async-await. Krátce jsme to probrali a oba jsme byli přesvědčeni, že výsledek bude ekvivalentní. Ten nápad mě zavedl do králičí nory, ze které jsem se nějakou dobu dostával. Testy přepsané na swiftovou smyčku for await náhodně selhávaly. Začal jsem pochybovat o správnosti svého kódu i o implementačních detailech SignInViewModel. Když jsem se podíval na podrobnosti, zjistil jsem, že selhání způsobuje timeout: přijatých hodnot bylo jiné množství, než se čekalo. Při ladění kódu jsem přišel na to, že sledování viewError ve smyčce for-await vede k různým počtům přijatých hodnot. Zjistil jsem, že AsyncSequence se chová jinak, než jsem čekal, přestože jsem přečetl různé knihy, články i dokumentaci.

Nazujme si holínky a pusťme se do kopání.

První kopnutí: AsyncPublisher versus odběr přes Combine

SignInViewModel teď po zbytek článku opustím. Začněme něčím jednoduchým a postupně přidávejme na složitosti, abychom zjistili, co se tu děje: proč testy selhávaly a proč náhodně. Dokumentaci nechme stranou, pozorujme chování a vysvětlení zformulujme, až k němu dojdeme.

Nejdřív si připravme publisher. Dobrým kandidátem by měl být PassthroughSubject:

import Combine


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

A sledujme ho základním sinkem v Combine a přes smyčku for await a přijatou hodnotu vypišme.

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)")
}

Zatím není co sledovat, tak pošleme něco potrubím:

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

Když se teď podíváte do konzole, uvidíte spoustu vypsaných výsledků. A když se do výpisů zadíváte pořádně, s největší pravděpodobností jich bude z obou zdrojů stejně: AsyncPublisher se chová stejně jako základní sink.

Proč tedy test selhával, a tady ne? Tušení, co se děje, mi dal initializer typu AsyncStream. Vypadá takhle:

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

Zaujal mě parametr bufferingPolicy, který určuje, jak se bufferují nevyužité položky sekvence: jestli mají zůstat (a bufferovat se), nebo zmizet. Ověřme předpoklad, že rozdíl mezi smyčkou for-await a sinkem bude znát, když přidáme zpoždění v podobě náročného výpočtu, například hledání n-tého prvočísla voláním 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)")
}

Po přidání zpoždění máme konečně minimální pozorovatelný příklad problému. Jak vidíte, počet výpisů už nesedí: některá čísla smyčka for-await přeskočí, takže se výsledky mezi jednotlivými běhy liší. Za zmínku stojí, že nejvyšší číslo v asynchronní smyčce for často není 99, ale jiné, například 97, což je poslední správně zpracované číslo.

Proč se smyčka for-await takhle chová? Nejspíš používá buffering policy, která zahazuje některé prvky, jež nejsou okamžitě zpracovány. Přesné nastavení buffering policy není pro toto zkoumání zásadní, ale jak uvidíte v části o AsyncStream, bufferuje se toho hodně.

Nejdůležitější ale je, jak smyčka for-await funguje. V iteraci pokračuje až poté, co doběhne closure aktuální iterace. Smyčka for tak iteruje synchronně, zatímco položky sekvence získává asynchronně.

Počítáme rozdíly

Je sice zajímavé vidět, že se počet výpisů liší, pořád ale musíme koukat do kódu a hádat. Připravme si počítadlo, abychom měli spolehlivější obraz výsledků. Vytvořil jsem ho jako actor, který přijímá typ jako parametr, aby byla konzole přehledná. Implementace vypadá takto:

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)")
    }
}

Jak vidíte, po každém zavolání addToCount() se počítadlo zvýší o jedna a vypíše se počet pro daný typ. Rozhodující pro nás tedy bude poslední výpis daného typu.

Vyzkoušejme to a podívejme se na výsledky. Nejdřív vytvoříme instance počítadel a použijeme je v našem stávajícím kódu (v Combine musíme pro zavolání asynchronní funkce vytvořit Task):

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()
}

Teď konečně vidíme v číslech, kolik se toho ztratilo. Poslední výpis počítadla pro Combine je 100, pro async 83. Na mém M1 Max bez optimalizací se tedy ztratilo 17 %.

Jak smyčku for await nad AsyncPublisher rozchodit

Máme teď výchozí stav a testovací prostředí. Viděli jsme, že Combine funguje bez problémů. Teď se zaměříme na opravu smyčky for-await, abychom dostali požadované výsledky.

Oprava je naštěstí jednoduchá. Stačí vytvořit Task a položky ve smyčce for-await zpracovávat asynchronně, bez čekání. Přijdeme tím o výhody sekvenčního vykonávání kódu, které Modern Concurrency nabízí, ale problém, se kterým se potýkáme, to vyřeší.

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

Řešení funguje, protože vytvoření Tasku není výpočetně náročná operace, kvůli které bychom o nějaké celé číslo přišli. Za běžných okolností by tento přístup měl fungovat dobře.

AsyncPublisher není bezpečný

V předchozí části jsme se dostali do bodu, kdy všechno fungovalo podle našich představ: díky asynchronnímu zpracování položek sekvence jsme ze smyčky for-await dostávali stejné výsledky jako z Combine. Znamená to, že můžeme AsyncPublisher bezpečně používat a nebát se, že o nějaké vstupy přijdeme? Bohužel ne.

Stačí poslat hodnotu souběžně a jsme zpátky na začátku. V mém pracovním prostředí bylo například po spuštění následujícího kódu počítadlo pro Combine na 1000 a pro async na 695. Žádná sláva.

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

Sledování přes smyčku for-await bohužel není bezpečné a může vést ke ztrátě dat. Podle situace lze problém někdy zmírnit. Pokud například víme, kolik položek dostaneme, můžeme na publisheru použít collect(). Nevidím ale žádný dobrý způsob, jak smyčku for-await přimět, aby fungovala stejně jako odběr publisheru v Combine, kde to vždy můžeme ošetřit asynchronním kódem. Zkoušel jsem několik dalších možností, například vytvořit z AsyncPublisher AsyncIterator, ale k ničemu to nevedlo.

Tato omezení jsou smyčce for-await vlastní, protože pracuje jen na jednom vlákně a nic negarantuje. V některých případech ale můžeme toto omezení využít ve svůj prospěch, zejména ve spojení s AsyncSequence, respektive s její implementací AsyncStream.

AsyncStream přichází na pomoc

AsyncStream je vestavěná implementace AsyncSequence v asynchronním kontextu. Umožňuje čekat na výsledky v sekvenci a zároveň do sekvence kdykoli publikovat (v asynchronní terminologii yield) pomocí její continuation.

Vytvořit instanci je velmi snadné. Pro naše účely můžeme udělat něco takového:

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


asyncStream = AsyncStream { continuation in 
    storedContinuation = continuation
}

Jak vidíte, asyncStream si ukládám do proměnné, abychom ho mohli použít později v kódu, a stejně tak si ukládám continuation. Proměnné sice unwrapujeme nebezpečně, kód je ale bezpečný, protože AsyncStream vrací continuation ve svém initu okamžitě (předaná closure neopouští aktuální scope).

Sledovat AsyncStream je jednoduché: stačí malá změna v naší smyčce for-await. Protože AsyncStream je AsyncSequence, můžeme ho iterovat přímo, stejně jako jakoukoli jinou Collection (například Array). Jediný rozdíl je v tom, že to děláme asynchronně.

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

Pokračujme v našem příkladu. Takhle bychom celá čísla posílali přes yield do continuation:

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

S AsyncStream se počítadlo pokaždé dostane na 100. Totéž platí, když kódem, který jsme už použili, počítáme do 1000. Neztratí se ani jedno číslo.

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

Položky už ani nemusíme zpracovávat asynchronně, takže kód pro sledování můžeme zjednodušit na:

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

A proč AsyncStream funguje? Díky své buffering policy, která se definuje při inicializaci. Výchozí hodnota je unbounded, takže se bufferuje každé celé číslo bez ohledu na to, jak dlouho trvá zpracování jedné iterace.

Tuto schopnost našeho AsyncStream bychom mohli klidně zničit, kdybychom chtěli. Kdybychom například AsyncStream inicializovali s bufferingPolicy: .bufferingNewest(1), počítadlo by místo 1000 ukázalo jen 2. To podporuje hypotézu, že AsyncPublisher má buffering policy, možná i dost velkorysou, ale pro situace, kdy ho potřebujeme, musíme ještě pochopit její limity.

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

AsyncStream je hrdinou našeho příběhu, protože nám umožňuje nastavit buffering policy podle našich potřeb a očekávání. Díky němu můžeme asynchronní hodnoty sledovat v asynchronním kontextu.

A co když potřebujeme sledovat publisher z Combine?

Otázka zní: Jak asynchronně sledovat publisher z Combine? Jak jsem ukázal dříve, stačí v sinku subscriberu zavolat Task {}. Takhle ale nemůžeme využít zpracování položek popořadě, které umí smyčka for-await.

Pokud si vytváříme vlastní publisher, doporučuji místo publisherů z Combine použít AsyncStream, pokud pro jiné části kódu nepotřebujeme reaktivní kouzla.

Pokud si vlastní AsyncStream vytvořit nemůžeme nebo chceme sledovat publisher, který jsme nevytvořili, můžeme vždy vytvořit AsyncStream, přihlásit se k odběru publisheru a hodnoty do AsyncStream posílat přes yield.

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

A abych mluvil méně abstraktně: rozdíl mezi sledováním streamu ve smyčce for-await s čekáním na výsledky a sledováním v Combine přes sink se podle mě dá hezky ukázat na zobrazování informačních zpráv v aplikaci.

Řekněme, že máme následující funkci, ze které zobrazujeme infoBar:

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

Pokud publisher sledujeme v Combine, dostaneme následující výsledek. Jak vidíte, zprávy se zobrazují přes sebe, což není zrovna ideální chování.

Vždy to ale můžeme udělat přes AsyncStream a na výsledek completion počkat pomocí withCheckedContinuation, například takto:

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

Výsledkem jsou čitelné zprávy, které se zobrazují jedna po druhé. Požadované chování máme bez jakýchkoli potíží. A co je nejlepší, můžeme použít Modern Concurrency, takže kód je docela čitelný.

Závěrem

Kvůli neúplné dokumentaci rozumíme Modern Concurrency ve Swiftu jen omezeně a máme se ještě hodně co učit. Můžeme se proto jen domnívat a hádat. Víc bychom se sice dozvěděli z analýzy zdrojového kódu, ale nemuselo by to být dobré využití času a pochopit všechny detaily jen ze čtení kódu může být těžké.

Tato oblast si proto zaslouží další zkoumání. Doufám, že se víc lidí ponoří hlouběji a nezůstane jen na povrchu.

Do té doby se nehrňme do přepisování každého kousku kódu na async-await bez důkladného rozmyšlení. Své předpoklady bychom si měli vždy ověřit, abychom do kódu nezanášeli zbytečné chyby.

¹ AsyncPublisher v podstatě umožňuje sledovat jakýkoli výsledek z publisheru v asynchronní smyčce for-await. Více najdete v dokumentaci: https://developer.apple.com/documentation/combine/asyncpublisher

² Gist najdete tady: https://gist.github.com/lvalenta/07770221e7d653f6cfad6f2bda63af73. Je to jen náhodná funkce, kterou našel kolega.

Lukáš ValentaiOS Developer
Další články

Další články z blogu.

Ocenění a uznání

Stavíme věci, které vyniknou.

V souladu s GDPRData neuchováváme
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
Druhý názor

Zeptejte se někoho
jiného než nás.

Kontext jsme už připravili.
Zeptejte se, v čem jsme dobří – a v čem ne.

Otevře nový chat s předvyplněným kontextem.

Obchod a AI poradenství

Začněte s Jakubem.

Přijďte s byznysovým problémem, procesem nebo nápadem. Pomůžeme vám najít správný další krok.

Krátký úvodní hovor je často nejrychlejší cesta, jak zjistit, co stojí za to řešit.

Jakub DurecOd tvůrců pro tvůrce
Jakub DurecAI Advisory Lead

Používáme cookies

Zásady ochrany osobních údajů