Swift异步初始化单例的线程安全实现及全局Actor使用疑问

一、核心问题：异步单例的线程安全隐患 #

你当前的单例实现中，静态变量_shared的读写没有同步保护。多线程并发调用shared()时，可能出现多个线程同时检测到_shared为nil，进而重复执行异步初始化逻辑，导致创建多个实例，违背单例的设计初衷。

二、全局Actor未生效的原因 #

你自定义的全局Actor写法存在错误：

@globalActor
struct SingletonActor {
    public actor SingletonActor {}
    public static let shared = SingletonActor()
}

@globalActor需要直接标记Actor类型，而非嵌套Actor的结构体。上述代码中，全局Actor的标记目标是结构体SingletonActor，而非内部的Actor类型，导致标记单例类后无法将静态成员纳入Actor的串行隔离域，因此无效。

三、正确的线程安全异步单例实现方案 #

方案1：修正全局Actor用法 #

先定义正确的全局Actor：

@globalActor
actor SingletonActor {
    static let shared = SingletonActor()
}

再修改单例类，将shared()函数标记为全局Actor上下文，确保静态变量的读写在串行队列中执行：

class Singleton {
    static private var _shared: Singleton?
    
    @SingletonActor
    static func shared() async -> Singleton {
        if let shared = _shared {
            return shared
        }
        let shared = await Singleton()
        _shared = shared
        return shared
    }
    
    private init() async {
        // 异步初始化逻辑
    }
}

方案2：嵌套Actor管理静态实例 #

通过嵌套Actor天然实现静态成员的线程安全，无需额外全局Actor：

class Singleton {
    // 嵌套Actor负责管理单例实例的创建与存储
    private actor SharedManager {
        static let shared = SharedManager()
        var instance: Singleton?
    }
    
    static func shared() async -> Singleton {
        await SharedManager.shared.withValue { manager in
            if let instance = manager.instance {
                return instance
            }
            let instance = await Singleton()
            manager.instance = instance
            return instance
        }
    }
    
    private init() async {
        // 异步初始化逻辑
    }
}

嵌套的SharedManager会保证所有对instance的操作在串行隔离域中执行，彻底避免竞态条件。

四、Firestore认证场景的正确实现 #

针对你提供的AuthRules和FirestoreServer，需对静态成员的访问逻辑做线程安全改造：

修正AuthRules #

actor AuthRules {
    private actor SharedManager {
        static let shared = SharedManager()
        var instance: AuthRules?
    }
    
    static func shared() async -> AuthRules {
        await SharedManager.shared.withValue { manager in
            if let instance = manager.instance {
                return instance
            }
            let instance = await AuthRules()
            manager.instance = instance
            return instance
        }
    }
    
    private init() async {
        await validateAnonymous()
    }
    
    private func signInAnonymously() async {
        do {
            print("AuthBackend.signInAnonymously: Attempting to sign in user anonymously")
            let result = try await Auth.auth().signInAnonymously()
            print("AuthBackend.signInAnonymously: Auth signed in as \(result.user.uid)")
        } catch(let error) {
            print("AuthBackend.signInAnonymously: Unable to sign in user anonymously \(error.localizedDescription)")
        }
    }
    
    private func validateAnonymous() async {
        if let currentUser = Auth.auth().currentUser, currentUser.isAnonymous {
            print("AuthBackend.validateAnonymous: Auth signed in as \(currentUser.uid)")
        } else {
            await signInAnonymously()
        }
    }
}

修正FirestoreServer #

actor FirestoreServer {
    private actor ServerManager {
        static let shared = ServerManager()
        var instance: FirestoreServer?
    }
    
    static func server() async -> FirestoreServer {
        await ServerManager.shared.withValue { manager in
            if let instance = manager.instance {
                return instance
            }
            let instance = await FirestoreServer()
            manager.instance = instance
            return instance
        }
    }
    
    private let db = Firestore.firestore()
    private let authRules: AuthRules
    
    private init() async {
        authRules = await AuthRules.shared()
    }
    
    // Firestore操作方法
}

内容的提问来源于stack exchange，提问作者Sahil Srivastava