Что означает Await в Async/Await?

Await в Async/Await

Что это такое

await — это ключевое слово в Swift, которое указывает компилятору: "Здесь может произойти приостановка выполнения функции (suspension point). Эта функция отдает управление, а потом может быть возобновлена."

Простое объяснение

// Без await — обычный вызов
let result = regularFunction()  // Исполняется сразу

// С await — асинхронный вызов
let result = await asyncFunction()  // Может приостановиться

Что происходит под капотом

// Когда мы пишем
let user = await fetchUser(id: 123)
let posts = await fetchPosts(userId: user.id)

// Компилятор превращает это в:

// 1. Начало выполнения fetchUser
// 2. Если это займет время — потоку дается возможность работать на чем-то другом
// 3. Когда результат готов — функция возобновляется
// 4. Переменная user получает результат
// 5. То же самое с fetchPosts

Ключевые принципы

1. Точки приостановки (Suspension Points)

func loadUserData() async throws {
    // ✅ await 1: Возможна приостановка здесь
    let user = await fetchUser()
    
    // ✅ await 2: Возможна приостановка здесь
    let profile = await fetchProfile(user.id)
    
    // ✅ await 3: Возможна приостановка здесь
    try await saveData(user, profile)
}

2. Исполнение последовательно, но неблокирующе

// Последовательно (с ожиданием)
let user = await fetchUser()      // Ждем ответа
let posts = await fetchPosts()    // Потом ждем этого
// Общее время: API_TIME_1 + API_TIME_2

// Параллельно (async let)
async let user = fetchUser()
async let posts = fetchPosts()
let (userData, postsData) = await (user, posts)
// Общее время: max(API_TIME_1, API_TIME_2)

Где необходимо await

// ❌ ОШИБКА: забыли await
let user = fetchUser()  // Типичная ошибка компиляции

// ✅ ПРАВИЛЬНО: с await
let user = await fetchUser()

// ❌ ОШИБКА: await не перед async функцией
await regularFunction()  // Компилятор выругается

// ✅ ПРАВИЛЬНО: только перед async функциями
await asyncFunction()

Технический процесс

Compiler создает State Machine:

func loadData() async {
    let step1 = await fetchData()   // State 1
    let step2 = await processData(step1)  // State 2
    return step2                    // State 3
}

// Превращается в состояния:
// State 0: Начало
// State 1: Ждем fetchData
// State 2: Ждем processData  
// State 3: Return

Почему это важно:

1. Неблокирующее — потоку не нужно ждать
2. Безопасное — компилятор проверит правильность
3. Читаемое — код как синхронный, но на самом деле асинхронный

Разница между вариантами

// 1. Просто вызов (без async/await)
func regularFunction() -> Int {
    return 42
}
let x = regularFunction()  // Исполняется немедленно

// 2. Асинхронная функция БЕЗ await
func asyncFunction() async -> Int {
    return 42
}
let task = asyncFunction()  // Возвращает Task, не результат!

// 3. Асинхронная функция С await
let result = await asyncFunction()  // Результат (Int)

// 4. Асинхронная функция внутри async контекста
func parent() async {
    let result = await asyncFunction()  // Правильно
}

// 5. Попытка вызвать async функцию без await
func sync() {  // Не async
    let result = asyncFunction()  // Ошибка! Нужен async контекст
}

Практические примеры

// Пример 1: Загрузка данных
func loadUserProfile(userId: String) async throws -> UserProfile {
    let user = try await apiClient.fetchUser(userId)
    let avatar = try await imageClient.fetchImage(user.avatarURL)
    let stats = try await statsService.fetchStats(userId)
    
    return UserProfile(user: user, avatar: avatar, stats: stats)
}

// Использование:
Task {
    let profile = try await loadUserProfile(userId: "123")
    print(profile)
}

// Пример 2: Параллельная загрузка
func loadDashboard() async throws -> Dashboard {
    async let users = apiClient.fetchUsers()
    async let posts = apiClient.fetchPosts()
    async let notifications = apiClient.fetchNotifications()
    
    return Dashboard(
        users: try await users,
        posts: try await posts,
        notifications: try await notifications
    )
}

// Пример 3: С обработкой ошибок
func safeFetch() async {
    do {
        let data = try await fetchData()  // await перед throw-ing функцией
        processData(data)
    } catch {
        handleError(error)
    }
}

Часто встречаемые ошибки

// ❌ Ошибка 1: Забыли async в определении функции
func wrongAsync() {  // Должна быть async
    let x = await asyncFunction()  // Ошибка компиляции
}

// ❌ Ошибка 2: Забыли await
func missingAwait() async {
    let x = asyncFunction()  // Возвращает Task, не результат
}

// ❌ Ошибка 3: await в @escaping closure
func wrongClosure() {
    let callback: @escaping () -> Void = {
        let x = await asyncFunction()  // Ошибка! closure не async
    }
}

// ✅ Правильно: async closure
func rightClosure() {
    let callback: @escaping () async -> Void = {
        let x = await asyncFunction()  // Правильно
    }
}

Почему await важен

До Swift 5.5 (Callback Hell):

fetchUser { user in
    fetchProfile(user.id) { profile in
        fetchSettings(user.id) { settings in
            updateUI(user, profile, settings)
        }
    }
}

После Swift 5.5 (Читаемо):

let user = await fetchUser()
let profile = await fetchProfile(user.id)
let settings = await fetchSettings(user.id)
updateUI(user, profile, settings)

Выводы

• await говорит: "здесь может быть приостановка"
• async говорит: "эта функция может содержать await"
• Suspension point — это точка, где управление может перейти другой задаче
• Compiler гарантирует правильность: забыли await = ошибка компиляции
• Результат: безопасный, читаемый, неблокирующий асинхронный код