Какой из инструментов для работы с многопоточностью более низкоуровневый?

Инструменты многопоточности: от низкого уровня к высокому

В iOS есть иерархия инструментов для многопоточности, где каждый уровень строится на предыдущем. Низкоуровневые инструменты дают больше контроля, но требуют больше кода и более подвержены ошибкам.

Иерархия (от низкого к высокому уровню)

POSIX Threads (pthread) — самый низкий уровень
         ↓
Operations API → Thread
         ↓
Grand Central Dispatch (GCD/DispatchQueue)
         ↓
Combine / async-await — высокий уровень

1. POSIX Threads (pthread) — САМЫЙ НИЗКОУРОВНЕВЫЙ

Это базовая OS-level API для создания потоков. Практически полный контроль, но очень низкоуровневый.

import Foundation

var thread: pthread_t = 0

// Создаём POSIX поток
pthread_create(&thread, nil, { _ in
    print("Running in POSIX thread")
    return nil
}, nil)

// Ждём завершения
pthread_join(thread, nil)

// Управление приоритетом
var params = sched_param()
pthread_getschedparam(pthread_self(), nil, &params)
pthread_setschedparam(thread, SCHED_RR, &params)

Плюсы: Максимальный контроль, минимальный overhead

Минусы: Опасно, verbose, легко создать deadlock, утечки памяти

2. Threads (NSThread/Thread)

Объектно-ориентированная обёртка над pthread, всё ещё низкоуровневая.

// Создание потока
let thread = Thread {
    print("Running in thread: \(Thread.current.name)")
    sleep(1)
}
thread.name = "Worker"
thread.qualityOfService = .userInitiated
thread.start()

// Синхронизация
thread.join()  // Ждём завершения

// Проблема: нужно вручную управлять жизненным циклом
var threads: [Thread] = []
for i in 0..<10 {
    let t = Thread {
        // work
    }
    threads.append(t)
    t.start()
}
for thread in threads {
    thread.join()
}

Плюсы: Больше контроля чем GCD, объектно-ориентированный

Минусы: Всё ещё требует ручного управления, легко создать deadlock'и

3. Operations (NSOperation/Operation)

Уровень выше — abstractio over threads.

class MyOperation: Operation {
    override func main() {
        if isCancelled { return }
        // Работа
        print("Operation executing")
    }
}

let queue = OperationQueue()
queue.maxConcurrentOperationCount = 4

let op1 = MyOperation()
let op2 = MyOperation()

// Зависимости между операциями
op2.addDependency(op1)

queue.addOperation(op1)
queue.addOperation(op2)

// Отмена
queue.cancelAllOperations()

Плюсы: Более высокий уровень, поддержка зависимостей, отмены, приоритетов

Минусы: Больше памяти, медленнее GCD

4. GCD (Grand Central Dispatch / DispatchQueue) — СРЕДНИЙ УРОВЕНЬ

Автоматическое управление потоками, оптимизировано системой.

// Основные queue'ы
DispatchQueue.main.async {
    // На главном потоке
    UIView.animate(withDuration: 0.3) {
        // UI обновления
    }
}

// Background работа
DispatchQueue.global(qos: .userInitiated).async {
    let data = try? fetchData()
    DispatchQueue.main.async {
        // Update UI
    }
}

// Custom queue
let customQueue = DispatchQueue(label: "com.app.background", qos: .userInitiated)
customQueue.async {
    // work
}

// Синхронизация: Dispatch group
let group = DispatchGroup()
for i in 0..<5 {
    group.enter()
    fetchData(id: i) { result in
        group.leave()
    }
}
group.notify(queue: .main) {
    // All tasks completed
}

// Dispatch semaphore для лимитирования
let semaphore = DispatchSemaphore(value: 3)
for i in 0..<10 {
    semaphore.wait()
    DispatchQueue.global().async {
        // work
        semaphore.signal()
    }
}

Плюсы: Оптимален для производства, низкий overhead, thread pool

Минусы: Callback hell, сложнее отслеживать ошибки

5. Combine / async-await — ВЫСОКИЙ УРОВЕНЬ

Абстракции для асинхронного программирования, очень безопасны.

// Modern async-await (iOS 13.1+)
async func fetchUserData() throws -> User {
    let data = try await apiService.fetchUser()
    return data
}

Task {
    do {
        let user = try await fetchUserData()
        // Автоматически на main thread для UI обновлений
        self.displayUser(user)
    } catch {
        // Обработка ошибок
    }
}

// Combine для реактивного программирования
let publisher = URLSession.shared
    .dataTaskPublisher(for: url)
    .map(\..data)
    .decode(type: User.self, decoder: JSONDecoder())
    .replaceError(with: User.default)
    .receive(on: DispatchQueue.main)
    .eraseToAnyPublisher()

publisher.sink { user in
    print(user)
}

Плюсы: Безопасны, читаемы, обработка ошибок встроена, race condition resistant

Минусы: Абстракции скрывают детали

Вывод

Ответ на вопрос: POSIX Threads (pthread) — самый низкоуровневый. После него идут NSThread/Thread, затем GCD, а async-await/Combine — высокоуровневые.

В современной разработке используй:

• async-await для простых случаев
• Combine для реактивных потоков данных
• DispatchQueue если async-await недоступен
• Operations для сложных зависимостей
• Threads/pthread почти никогда в production коде