Какие знаешь инструменты отмены задачи?

Инструменты отмены задач в iOS-разработке

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

1. Operation и OperationQueue

Классы Operation и OperationQueue предоставляют высокоуровневый API для отмены задач через метод cancel().

class DataProcessingOperation: Operation {
    override func main() {
        // Регулярно проверяем флаг отмены
        guard !isCancelled else { return }
        
        // Выполняем первую часть работы
        processFirstPart()
        
        guard !isCancelled else { return }
        
        // Выполняем вторую часть работы
        processSecondPart()
    }
    
    private func processFirstPart() { /* ... */ }
    private func processSecondPart() { /* ... */ }
}

// Использование
let operation = DataProcessingOperation()
let queue = OperationQueue()
queue.addOperation(operation)

// Отмена операции
operation.cancel()

Особенности:

• Кооперативная отмена - операция должна самостоятельно проверять isCancelled
• Возможность отмены всех операций в очереди через queue.cancelAllOperations()
• Поддержка зависимостей между операциями

2. DispatchWorkItem

В GCD (Grand Central Dispatch) для отмены задач используется DispatchWorkItem.

// Создаем work item с возможностью отмены
let workItem = DispatchWorkItem {
    // Долгая задача
    for i in 1...1000 {
        // Проверяем, не отменена ли задача
        if workItem.isCancelled {
            print("Задача отменена")
            return
        }
        print("Обработка \(i)")
        Thread.sleep(forTimeInterval: 0.1)
    }
}

// Запускаем на фоновой очереди
DispatchQueue.global().async(execute: workItem)

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

3. Swift Concurrency (async/await)

В современном Swift для отмены асинхронных задач используется механизм Task и TaskGroup.

Базовая отмена задачи:

Task {
    // Создаем задачу
    let task = Task {
        try await processData()
    }
    
    // Отменяем через 3 секунды
    try await Task.sleep(nanoseconds: 3_000_000_000)
    task.cancel()
}

func processData() async throws {
    // Проверяем отмену вручную
    try Task.checkCancellation()
    
    // Или проверяем флаг
    guard !Task.isCancelled else {
        print("Задача отменена")
        return
    }
    
    // Долгая асинхронная работа
    for _ in 1...100 {
        try await Task.sleep(nanoseconds: 100_000_000)
        try Task.checkCancellation() // Регулярная проверка
    }
}

Отмена в TaskGroup:

func processMultipleItems() async {
    await withTaskGroup(of: Void.self) { group in
        for item in items {
            group.addTask {
                // Каждая задача наследует контекст отмены
                await processItem(item)
            }
        }
        
        // Отменяем все задачи в группе
        group.cancelAll()
    }
}

4. Combine

Во фреймворке Combine для отмены подписок используется AnyCancellable.

import Combine

class ViewModel {
    private var cancellables = Set<AnyCancellable>()
    
    func fetchData() {
        URLSession.shared.dataTaskPublisher(for: url)
            .map(\.data)
            .decode(type: User.self, decoder: JSONDecoder())
            .sink { completion in
                // Обработка завершения
            } receiveValue: { user in
                // Обработка данных
            }
            .store(in: &cancellables) // Сохраняем для управления жизненным циклом
    }
    
    func cancelAllRequests() {
        // Отменяем все подписки
        cancellables.removeAll()
    }
}

5. URLSessionTask

Для отмены сетевых запросов используется метод cancel() у URLSessionTask.

class NetworkManager {
    private var currentTask: URLSessionTask?
    
    func fetchData(from url: URL) {
        currentTask = URLSession.shared.dataTask(with: url) { data, response, error in
            if let error = error as? URLError, error.code == .cancelled {
                print("Запрос отменен")
                return
            }
            // Обработка результата
        }
        currentTask?.resume()
    }
    
    func cancelCurrentRequest() {
        currentTask?.cancel()
        currentTask = nil
    }
}

Ключевые принципы отмены задач:

1. Кооперативная отмена - большинство механизмов требуют, чтобы задача сама проверяла флаг отмены и корректно завершалась
2. Распространение отмены - в Swift Concurrency отмена автоматически распространяется на дочерние задачи
3. Очистка ресурсов - при отмене необходимо освобождать захваченные ресурсы
4. Обработка ошибок отмены - важно корректно обрабатывать ошибки типа CancellationError

Рекомендации по выбору инструмента:

• Для современных асинхронных операций используйте Swift Concurrency (Task)
• Для реактивного программирования - Combine
• Для сложных зависимых операций - OperationQueue
• Для простых фоновых задач - DispatchWorkItem
• Для сетевых запросов - URLSessionTask или Combine

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