Почему Actor гарантирует потокобезопасность в async/await?

Как Actor обеспечивает потокобезопасность в Swift concurrency

Actor — это фундаментальная примитивная конструкция в модели параллелизма Swift, которая обеспечивает потокобезопасность (thread safety) за счёт взаимного исключения (mutual exclusion) доступа к своему изменяемому состоянию.

Основной принцип: изоляция состояния

Ключевая идея актора заключается в изоляции состояния (state isolation). Все свойства и методы, объявленные внутри актора, являются частью его изолированного контекста. Swift компилятор гарантирует, что в любой момент времени только одна задача может иметь доступ к этому изолированному состоянию.

actor BankAccount {
    private var balance: Double = 0
    
    func deposit(amount: Double) {
        balance += amount
    }
    
    func withdraw(amount: Double) -> Double? {
        guard balance >= amount else { return nil }
        balance -= amount
        return amount
    }
    
    func currentBalance() -> Double {
        return balance
    }
}

Механизм работы: сериализация доступа

Когда вы вызываете метод или обращаетесь к свойству актора извне, Swift автоматически сериализует эти обращения:

1. Все обращения к актору становятся асинхронными — даже если метод не помечен как async, вызов извне требует использования await
2. Компилятор вставляет точки приостановки — при вызове метода актора задача приостанавливается, если актор уже обрабатывает другой запрос
3. Очередь задач формируется автоматически — система поддерживает очередь входящих запросов к актору

// Пример использования актора
let account = BankAccount()

Task {
    await account.deposit(amount: 100)  // Вызов приостановит задачу, если актор занят
    let current = await account.currentBalance()
    print("Баланс: \(current)")  // Всегда будет предсказуемое значение
}

Сравнение с традиционными подходами

Почему это безопаснее ручных подходов?

1. Компиляторная проверка — Swift предотвращает прямой доступ к состоянию актора извне без await
2. Отсутствие гонок данных — автоматическая сериализация исключает race conditions
3. Предотвращение deadlock — акторы не используют блокирующие примитивы, вместо этого применяется модель приостановки/возобновления задач

// БЕЗОПАСНО: Компилятор не позволит сделать так
// let badAccess = account.balance  // Ошибка: Actor-isolated property

// ПРАВИЛЬНО: Только через await
Task {
    let safeAccess = await account.currentBalance()
}

Внутренняя реализация

Под капотом актор использует глобальный исполнитель задач (Global Actor Executor) и модель сооперативной отмены и приостановки. Когда задача обращается к актору:

// Псевдокод внутренней логики
extension BankAccount: Actor {
    func enqueue(_ job: Job) {
        // 1. Добавить задачу в очередь актора
        // 2. Если актор свободен — начать выполнение
        // 3. Если занят — задача ждёт в очереди
        // 4. Задача приостанавливается без блокировки потока
    }
}

Ограничения и особенности

• Акторы не решают всех проблем параллелизма — они защищают только внутреннее состояние
• reentrancy — акторы могут быть реентерабельными, что требует аккуратного проектирования
• Производительность — минимальные накладные расходы по сравнению с ручными блокировками

Практический пример защиты от гонки данных

// Классическая гонка данных БЕЗ актора
class UnsafeCounter {
    var value = 0
    
    func increment() {
        // МЕЖДУ чтением и записью может влезть другой поток
        let current = value
        Thread.sleep(forTimeInterval: 0.001)  // Имитация работы
        value = current + 1
    }
}

// С актором эта проблема исчезает
actor SafeCounter {
    private var value = 0
    
    func increment() async {
        let current = value
        try? await Task.sleep(nanoseconds: 1_000_000)  // Асинхронная задержка
        value = current + 1  // Гарантированно атомарно относительно других вызовов
    }
}

Вывод

Actor в Swift обеспечивает потокобезопасность через изоляцию состояния и автоматическую сериализацию доступа, что устраняет целый класс ошибок параллелизма на уровне системы типов. Это элегантное решение, которое переносит ответственность за синхронизацию с разработчика на компилятор, делая параллельное программирование более безопасным и предсказуемым. Однако важно понимать, что акторы — это не серебряная пуля, а часть более крупной экосистемы Swift concurrency, которая включает структурированный параллелизм, асинхронные последовательности и другие абстракции.