Что такое «параллельный контекст»?

вр; доктор

В контексте параллелизма Swift термин «контекст» означает среду выполнения, в которой находится код. Говорят, что код, который выполняется вне параллелизма Swift, выполняется в «синхронном контексте». Говорят, что код, который работает в системе параллелизма Swift, работает в «асинхронном контексте». И две отдельные асинхронные процедуры, не изолированные от одного и того же актера, будут рассматриваться как находящиеся в разных асинхронных контекстах.

Как бы то ни было, термин «асинхронный контекст» широко используется (но никогда официально не определен) в SE-0296 – Async/await , SE-0304 – Структурированный параллелизм и SE-0306 – Актеры. Насколько я вижу, Apple обычно не использует термин «контекст параллелизма», а скорее «асинхронный контекст», но мы можем легко догадаться о намерениях автора.

Чтобы конкретно прокомментировать цитаты, которыми вы с нами поделились, нам могут понадобиться более откровенные выдержки. Но рассмотрим вашу первую цитату:

Task имеет инициализатор с замыканием, которое само по себе является параллельным контекстом

Task {…} создаст новую задачу верхнего уровня от имени текущего актера (если таковой имеется). Итак, если Task был создан из синхронного контекста, да, замыкание будет работать в другом контексте, а именно в асинхронном контексте, но изолированном от текущего актера (если таковой имеется). Но если вы используете Task {…} из асинхронного контекста, изолированного от актера, эта новая задача будет изолирована от того же актера, из которого она была вызвана. Таким образом, детали будут различаться в зависимости от непосредственного контекста, в котором был создан Task.

Возможно, это придирки, но в любом случае я бы не решился сказать, что замыкание «является параллельным контекстом». Замыкание само по себе не является «контекстом». Было бы точнее описать это как замыкание, которое будет работать в определенном асинхронном контексте.

Для полноты картины следует отметить, что такое поведение Task {…} отличается от поведения Task.detached {…}, которое никогда не запускает код от имени текущего актера.

Рассмотрим вторую цитату:

Что произойдет, если у вас нет параллельного контекста? Где-то вверху в иерархии вызовов вы обнаружите ситуацию, в которой вообще нет параллельного контекста для запуска кода.

Мне совершенно непонятно, что хочет сказать автор. В параллелизме Swift он не перемещается «вверх по иерархии», чтобы определить, в каком контексте он находится. (Именно так это работало в GCD, и это одна из причин того, что код GCD может быть таким хрупким; но он работает не так. в параллелизме Swift.) Он просто просматривает текущую функцию, чтобы определить, от какого актера, если таковой имеется, она была изолирована. Если текущая функция изолирована от конкретного актера, то Task {…} создаст новую задачу верхнего уровня от имени этого актера. Но если текущая функция не изолирована от актера, то Task {…} также не будет изолирован ни от одного актера, независимо от того, что произошло ранее в иерархии вызовов.

Учитывать:

@MainActor 
class Foo {
    func foo() {
        // This is isolated to the main actor.

        Bar().bar()
    }
}

class Bar {
    func bar() {
        // This synchronous function is not isolated to any actor, so it will
        // happen to just run on whatever thread from which it was called.

        // If this is called from `Foo`’s `foo` method, isolated to the main actor,
        // this will happen to also run on the main thread. But if called from
        // somewhere not on the main thread, this will just run on the current
        // thread, whatever it was.
       
        Baz().baz()
    }
}

class Baz {
    func baz() {
        // If called from the main thread, this will run on the main thread. If 
        // called from some other thread, this will run on whatever thread it was
        // called.
        //
        // The key is, `baz` is not isolated to any particular actor…

        Task {
            // … thus, this is not isolated to any particular actor, either.
            //
            // Notably, even if `foo` called `bar`, and `bar` called `baz`, this
            // will *not* run on the main actor.
        }
    }
}

В этом примере foo случайно вызвал bar в основном потоке, и bar тоже вызвал baz в основном потоке. Но baz не изолирован ни от одного конкретного актера, поэтому, хотя в этом примере он начался в основном потоке, его Task {…} не изолирован от главного актера. Обратите внимание: я написал три функции, не относящиеся к async. Детали будут немного отличаться, если бы функции были async, но ключевое сообщение по-прежнему остается в силе: контекст, используемый замыканием, передаваемым в Task {…}, будет зависеть от того, был ли вызывающий объект изолирован от актера или нет.

Возможно, ваша цитата относилась к какому-то конкретному фрагменту кода, который нам не был предоставлен, поэтому я не могу комментировать дальше. Но я хотел бы разубедить кого-либо в том, что случайный код параллелизма Swift просматривает иерархию вызовов, чтобы выяснить ее контекст. Контекст функции определяется тем, была ли текущая функция (или тип, членом которого она является) изолирована от конкретного актера или нет.