Премиум

Что такое многопоточность (multithreading) в iOS и какие инструменты для нее используются?

Тип вопроса: Многопоточность Вероятность: 28% Категория: IOS Разработчик

Ответ

Многопоточность — это техника, позволяющая приложению выполнять несколько задач (потоков) параллельно или псевдопараллельно (через быстрое переключение контекста). Это необходимо для:

  1. Отзывчивого UI (главный поток не блокируется долгими операциями).
  2. Эффективного использования многоядерных процессоров.
  3. Выполнения фоновых задач (сеть, вычисления, I/O).

Основные инструменты в iOS/macOS:

Инструмент Уровень Основная концепция Когда использовать
Grand Central Dispatch (GCD) Низкоуровневый C API Очереди (DispatchQueue) задач (closures). Большинство задач: фоновая работа, синхронизация, таймеры.
OperationQueue Высокоуровневый Objective-C/Swift API Операции (Operation) — абстракция задачи с зависимостями, отменой, приоритетом. Сложные задачи с зависимостями, требующие отмены или наблюдения за состоянием.
Thread (NSThread) Самый низкий уровень Напрямую управляемые потоки POSIX. Редко. Только для специфичных, долгих задач, где нужен полный контроль над жизненным циклом потока.

Базовый пример с GCD:

// 1. Выполнение задачи в фоне
DispatchQueue.global(qos: .userInitiated).async {
    // Эта closure выполняется в фоновом потоке
    let processedData = performIntensiveCalculation()

    // 2. Возврат результата в главный поток для обновления UI
    DispatchQueue.main.async {
        self.updateUI(with: processedData)
    }
}

Ключевые понятия и проблемы:

  • Гонка данных (Race Condition): Несколько потоков одновременно обращаются и изменяют общие данные без синхронизации, приводя к неопределенному поведению.
    • Решение: Использовать очереди (серийные или с барьерами), семафоры (DispatchSemaphore), замки или акторы (Actor).
  • Взаимная блокировка (Deadlock): Два или более потока бесконечно ждут друг друга, освобождая ресурсы.
    • Пример: Вызов sync на текущей очереди.
  • Главный поток (Main Thread): Весь пользовательский интерфейс (UI) должен обновляться только на главном потоке. Блокировка этого потока приводит к "зависанию" интерфейса.

Современный подход (Swift Concurrency): Начиная со Swift 5.5, рекомендуется использовать async/await, акторы (Actor) и структурированный параллелизм (Task, TaskGroup). Эти инструменты безопаснее и выразительнее, чем ручное управление потоками через GCD.

// Пример современного подхода
func fetchData() async throws -> Data {
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

Task { // Запускает асинхронную задачу
    let data = try await fetchData() // Не блокирует поток
    await MainActor.run { // Безопасный переход на главный актор
        self.updateUI(with: data)
    }
}

Ответ 18+ 🔞

О, многопоточность! Ну это ж классика, блядь, вечная тема, где все думают, что они умные, а потом приложение виснет, как сука на заборе. Слушай, давай разберём эту пиздопроебибну по полочкам, чтобы не было потом мучительно больно.

Многопоточность — это, грубо говоря, когда твоё приложение пытается делать несколько дел одновременно, как та мартышлюшка, которая и на дереве качается, и банан жрёт. Нужно это, чтобы:

  1. Интерфейс не вис, пока там что-то тяжёлое грузится. Пользователь тычет в экран, а ему в ответ — хуй с горы.
  2. Процессор, у которого ядер овердохуища, не простаивал, а пахал, как Герасим в огороде.
  3. Фоновые штуки (типа скачивания котиков из интернета) шли себе тихонько, не мешая главному.

Чем тут можно ебашить? Инструментов дохуя, но основные вот эти:

Инструмент Уровень Суть Когда юзать
Grand Central Dispatch (GCD) Низкий, под капотом Очереди (DispatchQueue), куда ты кидаешь куски кода (closures), как мусор в ведро. Система сама решает, когда и в каком потоке их выполнять. Для 90% задач. Фоновая работа, синхронизация, таймеры — всё туда.
OperationQueue Повыше, поумнее Операции (Operation) — это уже не просто кусок кода, а целая задачка, у которой могут быть зависимости (сделай А перед Б), её можно отменить или посмотреть, как она там поживает. Когда задачи сложные, связанные друг с другом, или надо иметь возможность их отменить, не вынося себе мозг.
Thread (NSThread) Самый низкий, голые руки Потоки, которыми ты управляешь вручную, как какой-нибудь пастух овец. Очень редко. Только если ты реально знаешь, зачем тебе эта головная боль, и готов за неё отвечать.

Самый простой пример на GCD, чтобы понять логику:

// 1. Кидаем тяжёлую работу в фон
DispatchQueue.global(qos: .userInitiated).async {
    // Всё, что здесь — выполняется НЕ в главном потоке. Можешь считать пи до миллионного знака.
    let processedData = performIntensiveCalculation()

    // 2. Как посчитал — ОБЯЗАТЕЛЬНО возвращаемся на главный, чтобы UI обновить!
    DispatchQueue.main.async {
        self.updateUI(with: processedData) // А вот тут уже трогаем интерфейс.
    }
}

Запомни, как "Отче наш": с UI работаем ТОЛЬКО из DispatchQueue.main.async. Иначе будет пиздец и краш.

А теперь про подводные ебланы, на которых все и спотыкаются:

  • Гонка данных (Race Condition): Представь, два потока одновременно лезут в одну переменную, один пишет, другой читает. Итог — неопределённое поведение, или, как говорят у нас, хуйня полная. Данные могут быть битыми, приложение — упасть.
    • Как не обосраться: Использовать серийные очереди, барьеры в concurrent очередях, семафоры или новые акторы.
  • Взаимная блокировка (Deadlock): Это когда два потока ждут друг друга, как два упрямых осла. Например, вызвал sync на текущей очереди — и всё, приехали. Система встала колом.
  • Главный поток: Это святое. Его блокировать — всё равно что засрать алтарь в церкви. Интерфейс замрёт, пользователь полезет перезагружать телефон.

Но есть же и свет в конце тоннеля! Swift 5.5 принёс новую модель concurrency (async/await). Это, блядь, просто песня! Всё стало чище и безопаснее.

// Современный способ, без этих ваших костылей с очередями
func fetchData() async throws -> Data {
    let (data, _) = try await URLSession.shared.data(from: url) // Ждём, не блокируя поток!
    return data
}

Task { // Запускаем асинхронную таску
    let data = try await fetchData() // Красота, а не код
    await MainActor.run { // Автоматически и безопасно на главный поток
        self.updateUI(with: data)
    }
}

Вот так вот. Старое (GCD) надо знать, потому что его дохуя в легаси-коде. Но новое (async/await) — это наш будущий царь и бог, учить обязательно, чтобы не остаться в прошлом, как этот Герасим со своей Муму.

© ХакСобесов, 2026
support@hacksobesov.com