Swift编译器对Actor遵循Protocol严格限制的原因及崩溃解析

一、协议与Actor一致性编译失败的原因 #

为什么Swift编译器对协议一致性的要求如此严格？比如下面这段代码：

protocol TestProtocol {
    func testFunction()
}

actor TestClass: TestProtocol {
    func testFunction() {
    
    }
}

构建失败，错误提示：

Actor-isolated instance method 'testFunction()' cannot be used to satisfy nonisolated protocol requirement

Actor的核心目的不就是保障线程安全、防止数据竞争吗？那上述代码或协议一致性场景中存在什么数据竞争问题？

解析 #

Swift协议默认要求方法是非隔离（nonisolated）的，意味着可以在任意执行上下文同步调用。而Actor的所有实例方法默认都是Actor隔离的，必须在该Actor的专属执行器上运行——这是Actor保障线程安全的核心：所有对Actor内部状态的访问都会被串行化到它自己的执行队列中。

如果允许用Actor隔离的方法满足非隔离协议要求，会出现逻辑矛盾：当你通过协议类型（比如any TestProtocol）调用方法时，编译器无法确定该方法需要绑定到哪个Actor的执行器，也就无法保证线程安全。比如把TestClass实例赋值给let proto: any TestProtocol = TestClass()，然后在任意线程直接调用proto.testFunction()，会绕过Actor的隔离机制，导致对Actor内部状态的非串行访问，最终引发数据竞争。

编译器的严格要求是为了规避这种潜在漏洞，强制你明确处理隔离性：要么把协议方法标记为isolated（仅允许Actor类型遵守），要么把Actor中的方法标记为nonisolated（但需自行保证该方法不访问Actor的隔离状态）。

二、添加@preconcurrency后的运行时崩溃问题 #

基于他人回答编写了如下代码，但运行时崩溃，错误提示：Incorrect actor executor assumption

import Foundation

protocol TestProtocol {
    func increment()
    func decrement()
}

actor TestActor: @preconcurrency TestProtocol {
    var i = 5
    
    func increment() {
       i = i + 1
        print("incremented \(i)")
    }
    
    func decrement() {
        i = i - 1
        print("decremented \(i)")
    }
}

class TestClass {
    let testActor = TestActor()
    
    func g(x: any TestProtocol) {
        x.increment() // this synchronously calls an isolated method!
        x.decrement()
    }
    
    func f() {
        print("inside f")
        g(x: testActor)
    }
}

解析 #

添加@preconcurrency是告诉编译器“我会在并发场景下正确使用这个协议”，但你的代码并没有满足这个承诺。

在g(x:)方法中，你直接同步调用x.increment()和x.decrement()，但x实际是Actor实例，它的方法必须在自身执行器上运行。当通过any TestProtocol类型调用时，编译器无法自动插入Actor调度逻辑（比如await），默认认为这些方法可以在当前上下文同步执行，这就违反了Actor的执行器规则——Actor方法只能在自己的执行队列中运行，而当前TestClass的执行上下文并非TestActor的专属执行器，因此运行时抛出错误。

修复方案 #

方案1：将协议方法改为async

让协议明确要求异步调用，编译器会自动处理Actor调度：

protocol TestProtocol {
    func increment() async
    func decrement() async
}

actor TestActor: @preconcurrency TestProtocol {
    var i = 5
    
    func increment() async {
       i = i + 1
        print("incremented \(i)")
    }
    
    func decrement() async {
        i = i - 1
        print("decremented \(i)")
    }
}

class TestClass {
    let testActor = TestActor()
    
    func g(x: any TestProtocol) async {
        await x.increment()
        await x.decrement()
    }
    
    func f() async {
        print("inside f")
        await g(x: testActor)
    }
}

方案2：调用时显式切换到Actor上下文

如果不想修改协议，可以在调用时将协议类型转换回Actor类型，明确指定执行上下文：

class TestClass {
    let testActor = TestActor()
    
    func g(x: any TestProtocol) async {
        guard let actor = x as? TestActor else { return }
        await actor.increment()
        await actor.decrement()
    }
    
    func f() async {
        print("inside f")
        await g(x: testActor)
    }
}

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