Kas seejuhtum nõuab asünkroonse täitja kasutamist…

Jah, see on vajalik.

Kui pääsete actor-ile väljastpoolt eraldatud kontekstist (selles juhul globaalsest kontekstist), tagab kompilaator niidi-turvalisuse, nõudes asünkroonset juurdepääsu.

// Demonstratiivne protokoll
protocol DataFetcher {
    func fetchData() async -> String
}

actor DataCache {
    var cache: [String: String] = [:]

    func updateCache(key: String, value: String) {
        cache[key] = value // Toimib `actor`-i eraldatud kontekstis
    }

    func cachedData(forKey key: String) -> String? {
        return cache[key] // Toimib `actor`-i eraldatud kontekstis
    }

    nonisolated func clearCacheIsolated() {
        // See funktsioon on märgitud kui nonisolated ja ei pääse `actor`-i olekule ligi
        // Ligipääsuks on vaja asünkroonset väljakutset
    }
}


class DataLoader {
    let cache: DataCache // Viide `actor`-ile

    init(cache: DataCache) {
        self.cache = cache
    }

    func loadData(key: String) async -> String {
        // Asünkroonne juurdepääs `actor`-ile
        if let cached = await cache.cachedData(forKey: key) {
            return cached
        }

        // ... andmete laadimise loogika ...
        let newData = "Data for \(key)"

        // Asünkroonne `actor`-i uuendamine
        await cache.updateCache(key: key, value: newData)

        return newData
    }

    func attemptClearCacheAsync() async {
        // Asünkroonne väljakutse `actor`-i meetodile
        await cache.clearCacheIsolated()
    }

    func attemptClearCacheDirect() {
        // Kogemata kompilaatoriviga:
        // `actor`-i isoleeritud eksemplari meetod `clearCacheIsolated()` ei saa kutsuda mitte-isoleeritud kontekstist
        // cache.clearCacheIsolated()
    }
}

Selles näites:

Meetodid updateCache ja cachedData toimivad DataCache-i isoleeritud kontekstis ning on saadaval sünkroniseeritult actor-i sees.
Kutsed cache.cachedData(forKey: key) ja cache.updateCache(key: key, value: newData) loadData meetodist (mis asub väljaspool actor-i konteksti) nõuavad await sõna, mis tähistab asünkroonset täitmist ja asünkroonse täitja kasutamist. actor-i täitja vastutab nende operatsioonide järjekorras täitmise eest, tagades eksklusiivse juurdepääsu actor-i olekule.
Meetod clearCacheIsolated on märgitud kui nonisolated, kuid sellele on samuti võimalik teha asünkroonne väljakutse await cache.clearCacheIsolated() väljaspool actor-i, kuigi see pole selles olukorras kohustuslik (sest see meetod ei muuda actor-i olekut).
Otse sünkrooniline väljakutse cache.clearCacheIsolated() mitte-isoleeritud kontekstist (nagu attemptClearCacheDirect) põhjustab kompilaatorivea, kinnitades asünkroonse juurdepääsu vajadust.

Seega, ohutuks suhtlemiseks actor-iga väljaspool selle konteksti on vajalik kasutada asünkroonseid väljakutseid, mis täidetakse asünkroonse täitja abil, mida juhib ise actor.

Kas seejuhtum nõuab asünkroonse täitja kasutamist?