Swift Concurrency: await и Task

Swift Concurrency – это фреймворк, представленный в Swift 5.5, который значительно упрощает написание асинхронного кода. Ключевыми компонентами этого фреймворка являются async, await и Task. Рассмотрим их работу подробно.

Async

Ключевое слово async используется для объявления функции или метода как асинхронного. Это означает, что функция может приостанавливать свое выполнение без блокировки текущего потока, позволяя другим задачам выполняться. Когда асинхронная функция вызывается, она возвращает AsyncStream (если возвращаемый тип – поток) или результат типа Result, который будет доступен позже. Важно понимать, что async само по себе не запускает функцию параллельно; оно лишь указывает компилятору, что функция может приостанавливаться и возобновляться.

Пример:

func fetchUserData(userId: Int) async throws -> String {
    // Имитация сетевого запроса
    try await Task.sleep(nanoseconds: 1_000_000_000) // Задержка в 1 секунду
    return "User data for user \(userId)"
}

В этом примере fetchUserData объявлена как асинхронная функция, которая может приостанавливать свое выполнение с помощью `await`.

Await

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

Пример:

func processUserData() async {
    do {
        let userData = try await fetchUserData(userId: 123)
        print(userData)
    } catch {
        print("Error fetching user data: \(error)")
    }
}

Здесь await используется для ожидания результата вызова fetchUserData. Пока fetchUserData выполняется, текущий поток может выполнять другие задачи. Когда результат будет готов, выполнение `processUserData` продолжится с использованием полученных данных.

Task

Task – это структура, представляющая собой независимую единицу асинхронной работы. Она позволяет запускать асинхронные функции параллельно и управлять их жизненным циклом. Создание нового Task не блокирует текущий поток.

Создание Task

Существует несколько способов создания Task:

  • detached: Запускает задачу в отдельном контексте, не связанном с текущим.
Task {
    do {
        let userData = try await fetchUserData(userId: 456)
        print("Detached task result: \(userData)")
    } catch {
        print("Detached task error: \(error)")
    }
}
  • current: Запускает задачу в текущем контексте. Чаще всего используется внутри асинхронных функций.
func startTasks() async {
    async let task1 = Task {
    
        do {
            let result1 = try await fetchUserData(userId: 789)
            return result1
        } catch {
            return "Error in task 1"
        }
    }

    async let task2 = Task {
        do {
            let result2 = try await fetchUserData(userId: 012)
            return result2
        } catch {
                return "Error in task 2"
        }
    }

    // Ожидание завершения обеих задач. Результаты будут доступны в том порядке, в котором они завершатся.
    let (result1, result2) = await (task1, task2)
    print("Task 1 result: \(result1)")
    print("Task 2 result: \(result2)")
}
  • init: Создает задачу с явным приоритетом.

Управление жизненным циклом Task

* Cancellation: Задачи можно отменять, используя `cancellation`. Когда задача отменяется, все ожидающие вызовы `await` внутри нее выбрасывают ошибку `CancellationError`.

let task = Task {
    do {
        for i in 1...10 {
            try await Task.sleep(nanoseconds: 500_000_000) // Задержка в 0.5 секунды
            print("Task running \(i)")
        }
    } catch {
        if (error as? CancellationError) != nil {
            print("Task cancelled")
        } else {
            print("Task error: \(error)")
        }
    }
}

    // Отмена задачи через 2 секунды
DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
    task.cancel()
}
  • Value: Результат выполнения задачи можно получить с помощью свойства value. Если задача еще не завершена, вызов value приостановит текущий поток до тех пор, пока результат не станет доступным.
let task = Task {
    do {
        try await Task.sleep(nanoseconds: 1_000_000_000)
        return "Task completed"
    } catch {
        return "Task failed"
    }
}

let result = await task.value // Ожидание завершения задачи и получение результата
print(result)
  • Error: Если задача завершилась с ошибкой, можно получить эту ошибку через свойство error.

Преимущества Swift Concurrency

  • Упрощение асинхронного кода: async и await делают асинхронный код более читаемым и понятным.
  • Избежание callback hell: Swift Concurrency позволяет писать асинхронный код в последовательном стиле, избегая сложных цепочек callbacks.
  • Безопасность потоков: Фреймворк обеспечивает безопасность потоков, предотвращая гонки данных и другие проблемы, связанные с многопоточностью.
  • Структурированная конкуренция: Task позволяет управлять жизненным циклом асинхронных задач, упрощая обработку ошибок и отмену операций.

Заключение

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


Будет интересно

Nikulux в Telegram

Статьи, архивы материалов, скоро ещё и мемы

(= Подписаться =)