使用Protocol替代@MainActor类触发数据竞争错误，如何正确抽象？

两种实现的核心差异 #

可正常编译的直接类调用版本 #

actor MyActor {
    let property: MainActorClass

    init(property: MainActorClass) {
        self.property = property
    }

    func doSomething() async {
        await property.foo()
    }
}

@MainActor
class MainActorClass {
    func foo() async {
        print("foo")
    }
}

当直接使用@MainActor标记的类时，Swift编译器会自动完成两项关键安全验证：

• 推断该类遵循Sendable协议，确认跨Actor传递实例是线程安全的；
• 明确该类所有方法必须在MainActor上下文执行，await property.foo()会自动切换到MainActor，编译器能完全验证调用的安全性，不会触发数据竞争警告。

使用协议抽象后报错的版本 #

actor MyActor {
    let property: MainActorProtocol

    init(property: MainActorProtocol) {
        self.property = property
    }

    func doSomething() async {
        await property.foo()
    }
}

@MainActor
protocol MainActorProtocol {
    func foo() async
}

class MainActorClass: MainActorProtocol {
    func foo() async {
        print("foo")
    }
}

报错的核心原因是协议的线程安全约束不完整：

• @MainActor仅约束了协议方法的执行上下文，但没有明确协议本身必须遵循Sendable；
• 编译器无法保证所有遵循MainActorProtocol的类型都是线程安全的（比如可能存在非Sendable的类遵循该协议）；
• 当自定义ActorMyActor持有协议类型实例时，编译器认为跨Actor传递该实例存在数据竞争风险，因此抛出错误。

正确的协议抽象方案 #

方案1：给协议添加Sendable约束（推荐） #

直接修改协议定义，明确要求所有遵循类型必须是Sendable：

@MainActor
protocol MainActorProtocol: Sendable {
    func foo() async
}

这样编译器就能确认协议实例的线程安全性，跨Actor传递和调用都能通过并发检查。

方案2：用MainActorIsolated包装协议实例 #

如果不想修改协议，可以通过MainActorIsolated明确绑定实例的执行上下文，消除编译器的线程安全顾虑：

actor MyActor {
    let property: MainActorIsolated<MainActorProtocol>

    init(property: MainActorProtocol) {
        self.property = MainActorIsolated(wrapping: property)
    }

    func doSomething() async {
        await property.value.foo()
    }
}

MainActorIsolated会强制内部实例只能在MainActor上被访问，确保所有操作都符合线程安全要求。

方案3：强化遵循类的Actor约束 #

给遵循协议的类添加@MainActor标记，进一步明确其执行上下文，配合前两种方案使用能强化整体线程安全：

@MainActor
class MainActorClass: MainActorProtocol {
    func foo() async {
        print("foo")
    }
}

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