¿Es necesario usar un executor asíncrono en este…

Sí, es necesario.

Al acceder a actor desde fuera de su contexto aislado (en este caso, desde el contexto global), el compilador garantiza la seguridad de los hilos, requiriendo que el acceso se realice de forma asíncrona.

// Protocolo para demostración
protocol DataFetcher {
    func fetchData() async -> String
}

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

    func updateCache(key: String, value: String) {
        cache[key] = value // Se ejecuta dentro del contexto aislado del actor
    }

    func cachedData(forKey key: String) -> String? {
        return cache[key] // Se ejecuta dentro del contexto aislado del actor
    }

    nonisolated func clearCacheIsolated() {
        // Esta función está marcada como nonisolated y no tiene acceso al estado del actor
        // Para acceder, se requiere una llamada asíncrona
    }
}


class DataLoader {
    let cache: DataCache // Referencia al actor

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

    func loadData(key: String) async -> String {
        // Acceso asíncrono al actor desde fuera
        if let cached = await cache.cachedData(forKey: key) {
            return cached
        }

        // ... lógica de carga de datos ...
        let newData = "Data for \(key)"

        // Actualización asíncrona del actor
        await cache.updateCache(key: key, value: newData)

        return newData
    }

    func attemptClearCacheAsync() async {
        // Llamada asíncrona a método del actor desde fuera
        await cache.clearCacheIsolated()
    }

    func attemptClearCacheDirect() {
        // Error de compilación:
        // El método de instancia 'clearCacheIsolated()' aislado por actor no puede ser
        // llamado desde un contexto no aislado
        // cache.clearCacheIsolated()
    }
}

En este ejemplo:

Los métodos updateCache y cachedData se ejecutan dentro del contexto aislado de DataCache y son accesibles de forma síncrona dentro del actor.
Acceder a cache.cachedData(forKey: key) y cache.updateCache(key: key, value: newData) desde el método loadData (que está fuera del contexto del actor) requiere la palabra clave await, lo que indica ejecución asíncrona y uso de un executor asíncrono. El executor del actor se encarga de ejecutar estas operaciones en orden, garantizando acceso exclusivo al estado del actor.
El método clearCacheIsolated está marcado como nonisolated, pero incluso su llamada asíncrona await cache.clearCacheIsolated() es válida desde fuera del actor, aunque no es obligatoria para garantizar la seguridad de los hilos en este caso (ya que el método no modifica el estado del actor).
La llamada síncrona directa cache.clearCacheIsolated() desde un contexto no aislado (como en attemptClearCacheDirect) produce un error de compilación, confirmando la necesidad de acceso asíncrono.

Por lo tanto, para interactuar de forma segura con un actor desde su contexto externo, es necesario usar llamadas asíncronas que se ejecutan mediante un executor asíncrono gestionado por el propio actor.

¿Es necesario usar un executor asíncrono en este caso?