Как реализовать многопоточность с использованием очередей в iOS?

Multi-threading в iOS с использованием очередей реализуется с помощью Grand Central Dispatch (GCD) и Operation Queues.

GCD — это низкоуровневый API, основанный на управлении задачами (task management) и очередями (DispatchQueue). Основные концепции GCD:

• Dispatch Queues: Управляют выполнением задач (closures или функций). Существуют последовательные (Serial Queues) и параллельные (Concurrent Queues).

  • Serial Queues: Задачи выполняются строго последовательно, по одной. Гарантируют порядок выполнения и предотвращают состояния гонки при доступе к общим ресурсам.

    let serialQueue = DispatchQueue(label: "com.example.mySerialQueue")
    serialQueue.async {
        // Задача 1
    }
    serialQueue.async {
        // Задача 2 (начнет выполняться только после завершения Задачи 1)
    }
    

  • Concurrent Queues: Задачи выполняются параллельно, насколько это возможно.

    let concurrentQueue = DispatchQueue(label: "com.example.myConcurrentQueue", attributes: .concurrent)
    concurrentQueue.async {
        // Задача 1 (может выполняться одновременно с Задачей 2)
    }
    concurrentQueue.async {
        // Задача 2
    }
    

• Главная очередь (Main Queue): Специальная последовательная очередь, связанная с основным потоком приложения. Все обновления UI должны выполняться в этой очереди.

  DispatchQueue.main.async {
      // Обновление UI
  }
  

• Глобальные параллельные очереди (Global Concurrent Queues): Предоставляются системой и используются для выполнения задач в фоновом режиме с различным приоритетом QoS (Quality of Service): .userInteractive, .userInitiated, .default, .utility, .background.

  DispatchQueue.global(qos: .userInitiated).async {
      // Выполнение задачи, инициированной пользователем
  }
  

• Синхронное vs Асинхронное выполнение:

  • async: Задача ставится в очередь и выполняется в фоновом потоке, текущий поток не блокируется.
  • sync: Задача ставится в очередь, и текущий поток блокируется до тех пор, пока эта задача не завершится. Использование sync на той же очереди, что и текущий поток, может привести к дедлоку.

Operation Queues — это более высокоуровневый API, построенный поверх GCD. Используют объекты Operation (или его подклассы BlockOperation, ClosureOperation в Swift, NSBlockOperation, NSOperation в Objective-C) для инкапсуляции задач.

Основные преимущества Operation Queues:

• Зависимости (Dependencies): Можно указать, что одна операция не может начаться, пока другая не завершится.

  let operation1 = BlockOperation { /* Задача 1 */ }
  let operation2 = BlockOperation { /* Задача 2 */ }
  operation2.addDependency(operation1) // task2 выполнится после task1
  let operationQueue = OperationQueue()
  operationQueue.addOperation(operation1)
  operationQueue.addOperation(operation2)
  

• Приоритеты (Priorities): Можно задать приоритет отдельно для каждой операции.

• Отмена (Cancellation): Операции могут быть отменены.

• Состояния (States): Операции имеют состояния (isReady, isExecuting, isFinished, isCancelled).

• Наблюдатели KVO (KVO Observers): Можно наблюдать за состоянием операций.

• Максимальное количество одновременных операций (Max Concurrent Operation Count): У Operation Queue можно ограничить количество одновременно выполняемых операций. Установка maxConcurrentOperationCount = 1 делает Operation Queue последовательной (похоже на Serial Queue в GCD).

  let opQueue = OperationQueue()
  opQueue.maxConcurrentOperationCount = 4 // Ограничение на 4 одновременно выполняемые операции
  

Выбор между GCD и Operation Queues:

• GCD: Предпочтительно для простых фоновых задач, выполнения кода на главной очереди, создания кастомных последовательных очередей. Более легковесный.
• Operation Queues: Лучше подходит для сложных сценариев: задачи с зависимостями, отменяемые задачи, контроль над количеством одновременно выполняемых задач, более структурированное управление операциями.

Пример синхронизации доступа к данным с использованием Serial Queue:

class DataManager {
    private var data: [String] = []
    private let queue = DispatchQueue(label: "com.example.dataQueue")

    func addData(_ item: String) {
        queue.sync {
            // Доступ к data безопасен, т.к. происходит внутри последовательной очереди
            data.append(item)
        }
    }

    func getData() -> [String] {
        var result: [String] = []
        queue.sync {
            // Безопасное чтение data
            result = data
        }
        return result
    }
}