Swift 在同步参与者隔离上下文中调用参与者隔离实例方法

您正在将隔离与非隔离以及同步与同步混为一谈，这是相互垂直的区别.

与某个参与者实例隔离的方法可以从与该参与者实例隔离的上下文同步调用.否则，必须同步调用它，即用await调用.从不与该参与者隔离的上下文中调用一个隔离方法还涉及"参与者 skip "，它有一些关于Sendable的要求，但我离题了.

async方法必须以everywhere方式被同步调用.您只能在async方法的正文中使用await.

您可以在一个参与者中声明这些组合的所有四种组合，并且协议没有理由不需要这些组合中的任何一种.

actor Foo {
    func f1() { // non-async isolated
        
    }
    
    nonisolated func f2() { // non-async non-isolated
        
    }
    
    func f3() async { // async isolated
        
    }
    
    nonisolated func f4() async { // nonisolated async
        
    }
}

您不能仅仅因为foo不是uc(尽管它是孤立的)而执行await impl.foo().

impl.foo()也无效，因为impl.foo与impl隔离，但您正在从与self(代理)隔离的上下文执行此调用.这些是不同的演员.请注意，这不仅是因为它们的类型不同，还因为self和impl是不同的instances.这与你不能做这样的事情的原因是相同的:

actor Foo {
    func foo() {
    }
    func bar() {
        // Foo().foo() is isolated to the new instance of Foo, not self!
        Foo().foo()
    }
}

为了使这个代理工作，您必须说服Swift，一旦执行被隔离到self(MyImplementation1Proxy)，它也被隔离到impl.

您应该实现unownedExecutor以返回impl的值.然后，用assumeIsolated结束通话.

actor MyImplementation1Proxy: MyActorProtocol {
    let impl: MyActorProtocol
    
    nonisolated var unownedExecutor: UnownedSerialExecutor {
        impl.unownedExecutor
    }
    
    init(impl: MyActorProtocol) {
        self.impl = impl
    }

    func foo() {
        impl.assumeIsolated {
            $0.foo()
        }
    }
}

当某人调用MyImplementation1Proxy.foo时，该调用由MyImplementation1Proxy.unownedExecutor执行，而MyImplementation1Proxy.unownedExecutor恰好与其impl正在使用的任何执行者相同.assumeIsolated判断当前执行人确实是impl.unownedExecutor，并运行foo.