Можно ли отменять Task?

Можно ли отменять Task?

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

Механизм отмены Task

Отмена происходит через объект Task, который предоставляет метод cancel(). Однако важно понимать, что отмена — это кооперативный механизм: сама задача не автоматически прекращает выполнение, но получает сигнал о необходимости остановиться. Ваша асинхронная функция должна проверять состояние отмены и корректно реагировать на него.

let task = Task {
    do {
        for i in 1...10 {
            // Проверяем, была ли задача отменена
            if Task.isCancelled {
                print("Задача отменена")
                return // или throw CancellationError()
            }
            print("Шаг \(i)")
            try await Task.sleep(nanoseconds: 1_000_000_000) // 1 секунда
        }
    } catch {
        // Task.sleep может выбросить CancellationError при отмене
        print("Ошибка: \(error)")
    }
}

// Отменяем задачу через 3 секунды
DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
    task.cancel()
}

Проверка состояния отмены

Существует два основных способа проверки:

1. Task.isCancelled — проверка布尔 флага в рамках самой задачи.
2. CancellationError — многие асинхронные API (например, Task.sleep, Task.yield) автоматически выбрасывают эту ошибку при отмене задачи, что позволяет использовать механизм try/ catch для обработки.

Также можно использовать Task.checkCancellation(), который автоматически выбрасывает CancellationError, если задача была отменена:

func performLongOperation() async throws {
    for _ in 1...100 {
        Task.checkCancellation() // Выбросит CancellationError если задача отменена
        await someAsyncWork()
    }
}

Особенности и рекомендации

• Кооперативная отмена: Код внутри задачи должен быть подготовлен к отмене. Если он не проверяет isCancelled и не вызывает методы, которые выбрасывают CancellationError, задача может продолжить выполнение даже после вызова cancel().
• Группы задач (TaskGroup): При отмене родительской задачи в TaskGroup, все дочерние задачи также автоматически получают сигнал отмены.
• Отмена и состояние: После отмены задача не может быть "возобновлена". Отмена устанавливает внутренний флаг, и все последующие проверки будут возвращать true.
• Обработка ошибок: Лучше всего использовать throw CancellationError() для раннего прекращения выполнения, так как это интегрируется с механизмом ошибок async/await.

Пример обработки отмены в реальном сценарии

Рассмотрим ситуацию, когда мы загружаем данные с сети, и пользователь покидает экран:

class ViewModel {
    private var downloadTask: Task<Void, Error>?

    func startDownload() {
        downloadTask = Task {
            do {
                let data = try await downloadFromServer()
                process(data)
            } catch let error as CancellationError {
                print("Загрузка была отменена")
            } catch {
                print("Произошла другая ошибка: \(error)")
            }
        }
    }

    func cancelDownload() {
        downloadTask?.cancel()
        downloadTask = nil
    }

    private func downloadFromServer() async throws -> Data {
        // Эту функцию можно реализовать с периодической проверкой Task.isCancelled
        // или использовать API, которые автоматически реагируют на отмену
        try await URLSession.shared.data(from: someURL)
    }
}

Заключение

Отмена Task — мощный и необходимый инструмент для создания эффективных и устойчивых асинхронных приложений на iOS. Правильное его использование включает:

• Регулярную проверку состояния отмены внутри длительных операций.
• Интеграцию с механизмом ошибок через CancellationError.
• Очистку ресурсов при отмене (например, закрытие сетевых соединений).
• Учет кооперативной природы отмены, что требует явной поддержки от разработчика.

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