Is it necessary to use an asynchronous executor in this case?

Yes, it is necessary.

When accessing an actor from outside its isolated context (in this case, from the global context), the compiler guarantees thread safety by requiring the access to be performed asynchronously.

// Protocol for demonstration
protocol DataFetcher {
    func fetchData() async -> String
}

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

    func updateCache(key: String, value: String) {
        cache[key] = value // Executed within the actor's isolated context
    }

    func cachedData(forKey key: String) -> String? {
        return cache[key] // Executed within the actor's isolated context
    }

    nonisolated func clearCacheIsolated() {
        // This function is marked as nonisolated and does not have access to the actor's state
        // Access requires an asynchronous call
    }
}


class DataLoader {
    let cache: DataCache // Reference to the actor

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

    func loadData(key: String) async -> String {
        // Asynchronous access to the actor from outside
        if let cached = await cache.cachedData(forKey: key) {
            return cached
        }

        // ... data loading logic ...
        let newData = "Data for \(key)"

        // Asynchronous update of the actor
        await cache.updateCache(key: key, value: newData)

        return newData
    }

    func attemptClearCacheAsync() async {
        // Asynchronous call to the actor's method from outside
        await cache.clearCacheIsolated()
    }

    func attemptClearCacheDirect() {
        // Compilation error:
        // Actor-isolated instance method 'clearCacheIsolated()' cannot be
        // called from a non-isolated context
        // cache.clearCacheIsolated()
    }
}

In this example:

• Methods updateCache and cachedData are executed within the isolated context of DataCache and are available synchronously inside the actor.
• Accessing cache.cachedData(forKey: key) and cache.updateCache(key: key, value: newData) from the loadData method (which is outside the actor context) requires the await keyword, indicating asynchronous execution and the use of an asynchronous executor. The actor's executor manages the execution of these operations in an order that guarantees exclusive access to the actor's state.
• The method clearCacheIsolated is marked as nonisolated, but even calling it asynchronously with await cache.clearCacheIsolated() from outside the actor is valid, although not necessary for thread safety in this case (since the method does not modify the actor's state).
• A direct synchronous call cache.clearCacheIsolated() from a non-isolated context (as in attemptClearCacheDirect) results in a compilation error, confirming the need for asynchronous access.

Thus, to interact safely with an actor from outside its context, it is necessary to use asynchronous calls executed with the actor's managed asynchronous executor.