Что такое барьерная задача?

Что такое барьерная задача в iOS/macOS разработке?

Барьерная задача (barrier task) — это специальный тип задачи в асинхронном программировании, который гарантирует, что все задачи, добавленные до барьера в определенную очередь или актор, будут выполнены до него, а задачи, добавленные после барьера, начнут выполняться только после завершения барьерной задачи. Это фундаментальный механизм для обеспечения безопасности потоков (thread safety) при работе с изменяемыми разделяемыми ресурсами в конкурентной среде.

Ключевые аспекты барьерных задач:

1. Изоляция доступа к ресурсам: Барьер действует как "точка синхронизации" в очереди. Он позволяет выполнять чтение данных конкурентно (параллельно), но запись — эксклюзивно.
2. Применимость: Нативно поддерживается для DispatchQueue с атрибутом .concurrent и является неотъемлемой частью модели Actor в Swift Concurrency.
3. Решаемая проблема: Предотвращение состояния гонки (race condition), когда несколько потоков одновременно читают и изменяют общие данные (например, словарь, массив), что ведет к неопределенному поведению и крешам.

Реализация через Grand Central Dispatch (GCD)

В GCD вы создаете барьерную задачу, отправив блок кода с флагом .barrier.

import Foundation

class ThreadSafeCache<Key: Hashable, Value> {
    private var cache: [Key: Value] = [:]
    // 1. Создаем приватную CONCURRENT очередь
    private let queue = DispatchQueue(label: "com.example.cacheQueue",
                                      attributes: .concurrent)

    // 2. Чтение — конкурентно и синхронно
    func getValue(for key: Key) -> Value? {
        queue.sync { // Барьер НЕ используется, чтение параллельно
            cache[key]
        }
    }

    // 3. Запись — эксклюзивно через барьер
    func setValue(_ value: Value, for key: Key) {
        // .barrier гарантирует, что эта задача выполнится одна на всей очереди
        queue.async(flags: .barrier) {
            self.cache[key] = value
        }
    }

    // 4. Удаление — также эксклюзивно
    func removeValue(for key: Key) {
        queue.async(flags: .barrier) {
            self.cache.removeValue(forKey: key)
        }
    }
}

Как это работает:

• Когда вы вызываете setValue, задача с флагом .barrier добавляется в очередь.
• GCD дожидается завершения ВСЕХ уже запущенных задач в этой очереди (чтений или предыдущих записей).
• Затем барьерная задача выполняется в одиночку — никакие другие задачи из этой очереди не выполняются параллельно с ней.
• После завершения барьерной задачи очередь возобновляет обычное конкурентное выполнение следующих задач.

Реализация через Swift Concurrency и Actor

В современном Swift (5.5+) концепция барьера инкапсулирована в Actor. Актор по умолчанию гарантирует, что к его изолированным (isolated) свойствам и методам доступ осуществляется последовательно.

actor ActorCache<Key: Hashable, Value> {
    private var cache: [Key: Value] = [:]

    // Все методы actor изолированы. Компилятор гарантирует,
    // что они не выполняются параллельно — это и есть встроенный "барьер".
    func getValue(for key: Key) -> Value? {
        cache[key]
    }

    func setValue(_ value: Value, for key: Key) {
        cache[key] = value
    }

    func removeValue(for key: Key) {
        cache.removeValue(forKey: key)
    }
}

// Использование
Task {
    let cache = ActorCache<String, Int>()
    await cache.setValue(42, forKey: "answer") // Вход в актор, другие задачи ждут
    let value = await cache.getValue(forKey: "answer") // Следующий вход после завершения setValue
    print(value) // 42
}

Важное отличие: Актор сериализует доступ ко всем своим методам. GCD с барьерами дает более гибкий контроль, позволяя выполнять чтение (.sync без барьера) конкурентно, что может быть эффективнее для частых операций чтения.

Итог и основные выводы

• Назначение: Барьерная задача — это паттерн синхронизации для безопасной записи в разделяемые ресурсы в конкурентных очередях.
• Механизм в GCD: Задача, отправленная с флагом .barrier на DispatchQueue.concurrent, выполняется эксклюзивно, создавая точку синхронизации.
• Механизм в Swift Concurrency: Роль барьера выполняет actor, который сериализует доступ к своему изменяемому состоянию, обеспечивая ту же безопасность на уровне языка.
• Когда использовать: Всегда, когда вам нужен потокобезопасный изменяемый кэш, конфигурация или любой другой разделяемый mutable-объект в многопоточной среде. Используйте GCD с барьерами для легаси-кода или тонкой оптимизации (read-concurrent), и actor — для нового кода на Swift Concurrency из-за его безопасности, выразительности и интеграции с остальными возможностями языка.