Вызов метода экземпляра, изолированного от актера, в синхронном контексте, изолированном от актера

Почему протокол актера может иметь неасинхронные методы объявлено без явного неизолированного ключевого слова?

Actor методы по своей сути синхронны. Однако эти синхронные методы могут быть частью более широкой async процедуры. Actors изолируют свои методы, чтобы защитить их общее изменяемое состояние от доступа некоторых других параллельных процедур.

Мутация может произойти только из изолированного метода внутри Actor. Изолированные методы не могут быть вызваны из синхронного контекста вне Actor.

actor MyActor {

    var state = 0

    func foo() {
        state += 1
    }

}

let actor = MyActor()
actor.foo() // Error: Call to actor-isolated instance method 'foo()' in a synchronous nonisolated context

Если вы хотите вызвать метод из синхронного контекста вне Actor, вам нужно сделать это nonisolated. Но это не будет означать мутации, поскольку Actor предназначены для защиты своего состояния.

actor MyActor {

    var state = 0

    nonisolated func foo() {
        state += 1 // Error: Actor-isolated property 'state' can not be mutated from a non-isolated context
    }

}

let actor = MyActor()
actor.foo()

Nonisolated будет работать только в том случае, если мы не будем изменять состояние Actor

actor MyActor {

    nonisolated func foo() {
        print("I'm not mutating here..")
    }

}

let actor = MyActor()
actor.foo()

Подводить итоги:

Методы в Актерах по своей сути не являются асинхронными, но если вы хотите вызывать их извне и при этом соблюдать правила изоляции, это необходимо делать из асинхронного контекста. С другой стороны, методы nonisolated должны быть неизменяемыми, чтобы они изначально соблюдали правила изоляции и их можно было безопасно вызывать из синхронного контекста.

Допустим, возможны неасинхронные методы, тогда зачем мне когда-нибудь в моем коде была ошибка-1?

Потому что MyImplementation1Proxy.foo() синхронен, и вы вызываете там метод, изолированный от актера MyImplementation1.foo(), тем самым не соблюдая MyImplementation1 правила изоляции.

РЕДАКТИРОВАТЬ 1:

Учитывая, что MyImplementation1Proxy также соответствует MyActorProtocol, и MyImplementation1.foo должен быть вызван в Task (по какой-либо причине), тогда кажется, что MyImplementation1.foo является «своего рода асинхронным», поэтому MyImplementation1Proxy.foo должен иметь такой «вид асинхронного контекста», как ну так почему у меня Ошибка-2

MyImplementation1.foo не является асинхронным, как я уже говорил, «методы актера по своей сути синхронны». И так MyImplementation1Proxy.foo синхронно. Но их в любом случае нужно вызывать из асинхронного контекста, чтобы соблюдать их правила изоляции, если только это не так nonisolated. Я знаю, это немного сложно.

Если вы хотите использовать await внутри этих методов, очевидно, что вам нужно явно сделать их асинхронными, потому что это не так. Таким образом Error-2

Вы объединяете изолированные и неизолированные и асинхронные и синхронизированные, которые являются ортогональными различиями.

Метод, изолированный от некоторого экземпляра актера, может быть синхронно вызван из контекста, изолированного от этого экземпляра актера. В противном случае его придется вызывать асинхронно, т. е. с помощью await. Вызов изолированного метода из контекста, не изолированного от этого актера, также включает в себя «переход актера», который имеет некоторые требования к Sendable, но я отвлекся.

Метод async должен везде вызываться асинхронно. Вы можете использовать await только в теле метода async.

Вы можете объявить все четыре их комбинации в акторе, и нет причин, по которым какая-либо из этих комбинаций не может потребоваться протоколу.

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
        
    }
}

Вы не можете сделать await impl.foo() просто потому, что foo не является асинхронным (хотя и изолированным).

impl.foo() также недействителен, поскольку impl.foo изолирован от impl, но вы выполняете этот вызов из контекста, изолированного от self (прокси). Это разные актеры. Обратите внимание: это происходит не только потому, что их типы разные, но и потому, что self и impl — разные экземпляры. Это та же причина, по которой вы не можете сделать что-то вроде этого:

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. Затем оберните вызов Предположим, изолирован.

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, который оказывается тем же исполнителем, что и тот, который используется impl. assumeIsolated проверяет, действительно ли текущий исполнитель impl.unownedExecutor, и запускает foo.