Անհրաժեշտ է արդյոք այս դեպքում օգտագործել ասինխրոն գործարկիչ?

Այո, դա անհրաժեշտ է:

Երբ արտաքին կոնտեքստից (այս դեպքում գլոբալ կոնտեքստից) մուտք եք գործում actor-ին մեկուսացված կոնտեքստում, կոմպիլատորը երաշխավորում է թափանցիկության անվտանգությունը՝ պահանջելով ասինխրոնային մուտք:

// Դեմոնստրացիոն պրոտոկոլ
protocol DataFetcher {
    func fetchData() async -> String
}

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

    func updateCache(key: String, value: String) {
        cache[key] = value // Կատարվում է `actor`-ի մեկուսացված կոնտեքստում
    }

    func cachedData(forKey key: String) -> String? {
        return cache[key] // Կատարվում է `actor`-ի մեկուսացված կոնտեքստում
    }

    nonisolated func clearCacheIsolated() {
        // Այս ֆունկցիան նշված է որպես nonisolated և չունի մուտք `actor`-ի վիճակի վրա
        // Մուտք գործելու համար պահանջվում է ասինխրոնային կանչ
    }
}


class DataLoader {
    let cache: DataCache // Հղում `actor`-ին

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

    func loadData(key: String) async -> String {
        // Ասինխրոնային մուտք `actor`-ին
        if let cached = await cache.cachedData(forKey: key) {
            return cached
        }

        // ... տվյալների բեռնում
        let newData = "Data for \(key)"

        // Ասինխրոնային թարմացում `actor`-ում
        await cache.updateCache(key: key, value: newData)

        return newData
    }

    func attemptClearCacheAsync() async {
        // Ասինխրոնային կանչ `actor`-ի մեթոդին դուրս
        await cache.clearCacheIsolated()
    }

    func attemptClearCacheDirect() {
        // Կոմպիլատորի սխալ՝
        // `clearCacheIsolated()`-ը `actor`-ի մեկուսացված օրինակն չի կարող կանչվել ոչ-մեկուսացված կոնտեքստից
        // cache.clearCacheIsolated()
    }
}

Այս օրինակով՝

• updateCache և cachedData մեթոդները կատարվում են DataCache-ի մեկուսացված կոնտեքստում և հասանելի են սինխրոնապես actor-ի ներսում:
• cache.cachedData(forKey: key) և cache.updateCache(key: key, value: newData) կանչերը loadData մեթոդից (որը դուրս է actor-ի կոնտեքստից) պահանջում են await բառը, ինչը նշում է ասինխրոնային կատարման և ասինխրոնային գործարկողի օգտագործման անհրաժեշտությունը։ actor-ի գործարկողը պատասխանատու է այս գործողությունների կատարման համար հերթով՝ ապահովելով բացառիկ մուտք actor-ի վիճակի վրա:
• clearCacheIsolated մեթոդը նշված է որպես nonisolated, բայց նույնիսկ դրա համար կարելի է կատարել ասինխրոնային կանչ await cache.clearCacheIsolated() դուրս actor-ից, թեև դա պարտադիր չէ այս դեպքում (քանի որ մեթոդը չի փոխում actor-ի վիճակը):
• ուղղակի սինխրոնային կանչ cache.clearCacheIsolated() ոչ-մեկուսացված կոնտեքստից (օրինակ՝ attemptClearCacheDirect-ում) հանգեցնում է կոմպիլյատորի սխալի, ինչը հաստատում է ասինխրոնային մուտքի անհրաժեշտությունը:

Այսպիսով՝ անվտանգ փոխազդեցության համար actor-ի հետ դուրս նրա կոնտեքստից պետք է օգտագործել ասինխրոնային կանչեր, որոնք կատարվում են ասինխրոնային գործարկողի միջոցով, որը կառավարում է ինքն actor-ը։