Что такое обычный выход для группы задач в Swift Concurrency?

Они просто говорят, что с async let, если вы пренебрегаете await этой задачей до того, как она выйдет из области видимости, она будет «неявно отменена». Но в случае с группой задач, если вы явно await не укажете отдельные групповые задачи, они не будут отменены неявно.

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

Рассмотрим этот пример в SE-0313:

func go() async { 
    async let f = fast() // 300ms
    async let s = slow() // 3seconds
    print("nevermind...")
    // implicitly: cancels f
    // implicitly: cancels s
    // implicitly: await f
    // implicitly: await s
}

По общему признанию, это надуманный пример, который вы, вероятно, никогда бы не сделали на практике. Более реалистичным примером может быть код, в котором после создания задач с помощью async let у нас может быть некоторая логика, использующая ранний выход, в результате чего она никогда не достигает await одной или нескольких задач async let. В этом сценарии с помощью async let любые задачи, которые не ожидаются явно, будут неявно отменены.

Обрисовав, что означает «неявная отмена», давайте теперь рассмотрим ваш пример:

func fetchThumbnails(for ids: [String]) async throws -> [String: UIImage] {
    try await withThrowingTaskGroup(of: (String, UIImage).self) { group in
        for id in ids {
            group.addTask { [self] in
                try await (id, fetchOneThumbnail(withID: id))
            }
        }
        
        // Obtain results from the child tasks, sequentially,
        // in order of completion.

        var thumbnails: [String: UIImage] = [:]

        for try await (id, thumbnail) in group {
            thumbnails[id] = thumbnail
        }

        return thumbnails
    }
}

(Я заменил group.async на group.addTask и внес несколько косметических изменений, но по сути это то же самое, что и ваше.)

На самом деле это неприменимо к обсуждению «неявной отмены», потому что здесь есть цикл for, в котором есть await для каждой задачи в группе (по мере накопления результатов в словаре). Таким образом, сама идея «неявной отмены» неприменима, поскольку все дочерние задачи явно ожидаются.

Вместо этого давайте рассмотрим вариант на эту тему, возможно, тот, где fetchOneThumbnail на самом деле ничего не возвращал, а просто обновлял некоторый внутренний кеш. Тогда это может быть:

func fetchThumbnails(for ids: [String]) async {
    await withTaskGroup(of: Void.self) { group in
        for id in ids {
            group.addTask { [self] in
                await fetchOneThumbnail(withID: id)
            }
        }

        // NB: no explicit `for await` loop of `group` sequence is needed; unlike 
        // `async let` pattern, these tasks will *not* be implicitly canceled
    }
}

Но в этом примере, хотя мы вообще никогда не for await последовательность group (таким образом, ни одна из дочерних задач не ожидается явно, в отличие от предыдущего примера), это не приведет к неявной отмене задач в группе, в отличие от async let. Он автоматически await выполнит все эти задачи за нас.

Короче говоря, async let неявно отменит все, что не ожидается явно, в то время как группа задач не будет неявно ничего отменять (по крайней мере, в сценарии «нормального выхода»), а скорее неявно await дочерние задачи.