Краткий ответ

withUnsafeCurrentTask предоставляет сведения только о задаче, которая выполняет текущий код, и только внутри переданного замыкания. Это механизм интроспекции, а не дескриптор для управления произвольной задачей: через него нельзя надёжно организовать отмену, ожидание или владение другой задачей.

Исторический контекст

Structured Concurrency добавила вложенные задачи, отмену и наследование контекста, но при этом сохранила кооперативную модель выполнения. Для низкоуровневых библиотек понадобился способ узнать состояние текущей задачи без передачи обычного Task через каждый вызов.

withUnsafeCurrentTask решает именно эту задачу наблюдения. Его название подчёркивает ограниченный и потенциально небезопасный характер доступа: API не превращает текущую задачу в универсальный объект управления.

Постановка проблемы

Библиотечный код может не получать дескриптор Task, но ему иногда нужно проверить, отменена ли текущая операция, или учесть её приоритет. Ошибочное решение — сохранить результат withUnsafeCurrentTask и использовать его как ссылку на жизненный цикл задачи либо пытаться с его помощью управлять задачей, созданной в другом месте.

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

Подробное решение

Замыкание withUnsafeCurrentTask получает сведения о задаче, выполняющей текущий фрагмент. Если вызов происходит вне задачи, значение может отсутствовать. Наиболее типичный сценарий — проверить флаг отмены и своевременно прекратить дальнейшую работу.

func process() throws {
    let cancelled = withUnsafeCurrentTask { task in
        task?.isCancelled ?? false
    }

    if cancelled {
        throw CancellationError()
    }

    // Продолжение синхронной работы
}

Этот API не создаёт новую задачу и не возвращает обычный дескриптор Task, который можно хранить, ожидать через value или отменять вызовом cancel(). Он также не отменяет автоматически внешнюю или дочернюю задачу и не продлевает её жизненный цикл.

Для управления конкретной задачей нужно сохранить именно её дескриптор, полученный при создании Task или другого поддерживаемого вида задачи. Для проверки отмены текущей задачи обычно предпочтительнее Task.isCancelled; withUnsafeCurrentTask нужен, когда библиотечному или низкоуровневому коду требуется доступ к сведениям о текущей задаче в специальном контексте.

Слово unsafe означает, что разработчик должен соблюдать ограничения области использования и не строить на этом API долгоживущую модель владения. Проверка состояния также не отменяет работу сама по себе: отмена в Swift кооперативная, поэтому код должен проверить состояние и корректно завершиться или бросить CancellationError.

Ситуация из практики

Допустим, библиотека обрабатывает большой входной поток и вызывается из задачи приложения. Вариант с withUnsafeCurrentTask позволяет библиотеке периодически проверять отмену текущей задачи, не меняя публичный API. Плюс — минимальная связанность; минус — библиотека не получает возможности отменить отдельную внутреннюю операцию или дождаться её результата.

Другой вариант — передать в библиотеку дескриптор созданной задачи. Это даёт явное управление отменой и ожиданием, но увеличивает сложность API и требует правильно определить владельца задачи.

Практичное решение: использовать withUnsafeCurrentTask только для локальной проверки контекста, а дескриптор Task передавать явно, если библиотека действительно должна управлять конкретной задачей. Так наблюдение не подменяется владением, а отмена остаётся предсказуемой.

Что кандидаты часто упускают

Вопрос: Может ли проверка isCancelled через withUnsafeCurrentTask сама остановить выполнение?

Ответ: Нет. Она только читает состояние отмены текущей задачи. Остановка произойдёт лишь после того, как код отреагирует на это состояние: выйдет из функции, бросит CancellationError, вызовет отменяемую операцию или выполнит другую предусмотренную логику.
Вопрос: Почему сведения о текущей задаче нельзя считать заменой переданному дескриптору Task?

Ответ: Дескриптор Task представляет конкретный результат асинхронной операции и поддерживает управление её жизненным циклом: ожидание результата и отмену. withUnsafeCurrentTask лишь предоставляет ограниченный доступ к контексту выполняющегося кода и не выражает владение произвольной задачей.
Вопрос: Что произойдёт, если код вызовет withUnsafeCurrentTask из синхронной функции, запущенной не внутри задачи?

Ответ: Текущая задача может отсутствовать, поэтому замыкание получит nil. Код должен обрабатывать этот случай и не предполагать, что любой синхронный вызов автоматически связан с задачей Swift; наличие потока или очереди исполнения само по себе не создаёт текущую Swift-задачу.