Что произойдет если с глобального потока сделать DipatchQueue.main.sync?

Краткий ответ

Если вызвать DispatchQueue.main.sync с глобального потока (не с главного), то произойдет взаимная блокировка (deadlock), только если вызов выполняется во время работы основного цикла выполнения (RunLoop) главного потока. В противном случае, если главный поток в этот момент простаивает и ожидает события, задача выполнится синхронно и без deadlock. Однако на практике такой вызов крайне опасен и почти всегда ведет к проблемам.

Подробное объяснение

1. Понимание ключевых терминов

• Главный поток (Main Thread): Специальный поток в iOS/macOS, на котором работает весь UI (обновление интерфейса, обработка касаний) и где выполняется основной цикл RunLoop. Ему соответствует DispatchQueue.main.
• Глобальный поток (Global Thread/Background Thread): Любой поток, который не является главным. Обычно это потоки из глобальных concurrent-очередей (например, DispatchQueue.global()).
• Синхронная отправка (sync): Метод, который блокирует текущий поток до тех пор, пока переданный блок кода не будет выполнен на целевой очереди.
• Взаимная блокировка (Deadlock): Ситуация, когда два или более потока ждут друг друга, чтобы продолжить работу, создавая бесконечное ожидание.

2. Механизм возникновения Deadlock

Стандартный и самый частый сценарий, приводящий к deadlock:

1. Главный поток выполняет какую-то задачу (например, обработку события viewDidLoad).
2. Глобальный поток вызывает DispatchQueue.main.sync { ... }.
3. Глобальный поток блокируется и ждет, пока главный поток освободится и выполнит этот блок.
4. Однако главный поток не может приступить к выполнению этого блока, потому что он сам занят выполнением своей первоначальной задачи. Он не перейдет к обработке задач из своей очереди (DispatchQueue.main) до тех пор, пока не закончит текущую работу.

В результате:

• Глобальный поток ждет, пока главный поток выполнит блок.
• Главный поток ждет, пока завершится его текущая задача, но не может этого сделать, так как он "застрял".
• Оба потока ждут друг друга вечно → Deadlock. Приложение зависает.

// Пример, гарантированно вызывающий deadlock в iOS приложении
DispatchQueue.global().async {
    // Мы на фоновом потоке

    print("1: На фоновом потоке")
    DispatchQueue.main.sync {
        // Эта строка никогда не выполнится в стандартном сценарии
        print("2: На главном потоке, выполненном синхронно")
    }
    // Эта строка также никогда не достигнется
    print("3: Снова на фоновом потоке")
}
// В консоли вы увидите только "1: На фоновом потоке", после чего UI перестанет отвечать.

3. Сценарий БЕЗ Deadlock (редкий, но возможный)

Deadlock не произойдет, если на момент вызова DispatchQueue.main.sync главный поток полностью свободен и его RunLoop ожидает событий. В этом случае:

1. Глобальный поток вызывает DispatchQueue.main.sync.
2. Глобальный поток блокируется.
3. Главный поток (будучи свободным) немедленно перехватывает и выполняет переданный блок.
4. После выполнения главный поток "возвращает" управление, и глобальный поток продолжает работу.

Однако в реальном iOS/macOS приложении такой сценарий маловероятен, потому что главный поток почти всегда занят работой RunLoop (обработкой событий UI, таймеров и т.д.) или выполнением какого-либо кода. Предсказать его состояние сложно, поэтому вызов sync на главную очередь с любого другого потока считается крайне опасным анти-паттерном.

4. Почему sync на главной очереди вообще существует?

Она безопасна и полезна в единственном случае: когда вызов происходит уже с самой главной очереди (DispatchQueue.main). В этом случае sync ведет себя как обычный вызов блока — deadlock не возникает, потому что нет ожидания другого потока. Это иногда используется для гарантии порядка выполнения или для синхронизации.

// Безопасный пример: вызов с главной очереди
DispatchQueue.main.async {
    // Мы уже на главном потоке
    DispatchQueue.main.sync {
        // Этот блок будет выполнен сразу же
        updateUI()
    }
    // Эта строка выполнится после updateUI()
    print("UI обновлен")
}

5. Рекомендации и альтернативы

• Никогда не используйте DispatchQueue.main.sync с фонового потока. Это грубая архитектурная ошибка.
• Для обновления UI с фонового потока всегда используйте DispatchQueue.main.async. Это асинхронная отправка, которая не блокирует ваш рабочий поток и ставит задачу в очередь главного потока. Он выполнит ее, как только освободится.

// Правильный и безопасный подход
DispatchQueue.global().async {
    // Тяжелые вычисления на фоновом потоке
    let result = performHeavyCalculation()

    // Возвращаем результат на главный поток для обновления UI
    DispatchQueue.main.async {
        self.label.text = "Результат: \(result)"
    }
}

• Если вам критично дождаться выполнения чего-то на главном потоке с фонового (что часто указывает на проблему в дизайне кода), пересмотрите архитектуру. Возможно, вам нужны семафоры (DispatchSemaphore), комpletion-Block'и или перестройка потока данных.

Итог

Вызов DispatchQueue.main.sync с глобального потока в работающем iOS/macOS приложении практически со 100% вероятностью приведет к deadlock и зависанию приложения, потому что главный поток будет занят работой своего RunLoop. Даже в гипотетическом случае, когда deadlock не происходит, такая практика считается крайне опасной и недопустимой. Всегда используйте для взаимодействия с UI DispatchQueue.main.async.