Что будет, если на главном потоке вызвать синхронно главный поток?

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

Если на главном потоке вызвать синхронную (sync) операцию, нацеленную на тот же самый главный поток, то это приведёт к взаимной блокировке (deadlock) и приложение "зависнет". В консоли отладчика вы увидите warning, указывающий на эту ошибку. Это классический случай deadlock'а, который iOS не допускает для очереди main.

---

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

Давайте разберёмся по порядку.

1. Главный поток (Main Thread) и очередь Main Queue

    Главный поток в iOS-приложении напрямую связан с очередью **`DispatchQueue.main`**. Это **сериальная (serial) очередь**, связанная с потоком UI, и именно на ней выполняются все операции с интерфейсом и обработкой пользовательских событий.

1. Синхронный вызов (sync)

    Особенность вызова `DispatchQueue.sync` заключается в следующем:
    *   Он **блокирует текущий поток** до тех пор, пока переданный в него блок кода не будет выполнен.
    *   Он ожидает, чтобы поместить и выполнить задачу на целевой очереди **немедленно**, не возвращая управление.

1. Что происходит при вызове sync на главном потоке на самого себя?

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

```swift
DispatchQueue.main.sync {
    print("Этот код никогда не выполнится")
}
```

    Шаги, которые приводят к deadlock:
    *   Главный поток (`Thread 1`) начинает выполнять `viewDidLoad`.
    *   Он достигает строки с `DispatchQueue.main.sync`.
    *   **Шаг 1 (блокировка):** Вызов `sync` блокирует **главный поток** и говорит: "Я не продолжу, пока блок кода, который я передал, не будет выполнен".
    *   **Шаг 2 (постановка в очередь):** Блок кода `{ print("...") }` ставится в очередь `DispatchQueue.main`. Однако это сериальная очередь, и она может выполнять только **одну задачу за раз**.
    *   **Шаг 3 (взаимное ожидание):**
        *   **Задача A:** Текущее выполнение метода `viewDidLoad` (которое включает в себя сам вызов `sync`) — это **текущая активная задача** на главной очереди.
        *   **Задача B:** Блок `print`, который мы передали в `sync`, — это **новая задача**, стоящая в очереди *следующей*.
        *   Ситуация патовая:
            *   Задача B (**блок `print`**) не может начаться, пока не завершится Задача A (`viewDidLoad`), потому что очередь сериальная.
            *   Задача A (`viewDidLoad`) не может завершиться, пока не завершится Задача B (**блок `print`**), потому что мы использовали `sync`.

    **Результат:** Полная взаимная блокировка. Главный поток застывает, интерфейс перестаёт откликаться, event loop останавливается. Приложение зависает.

1. Чем это отличается от асинхронного вызова (async)?

    Если использовать `DispatchQueue.main.async` на главном потоке, deadlock не произойдёт.

```swift
DispatchQueue.main.async {
    print("Этот код выполнится в следующем цикле выполнения (run loop)")
}
```

    Ключевое отличие:
    *   `async` **не блокирует** текущий поток. Он ставит блок в очередь и **немедленно возвращает управление**, позволяя методу `viewDidLoad` продолжить и завершиться.
    *   После того как `viewDidLoad` завершится (текущая задача на очереди `main` освободится), система возьмёт из очереди наш блок `print` и выполнит его. Всё работает корректно.

---

Практические последствия и диагностика

• Зависание UI: Экран перестанет реагировать на касания, анимации замрут.
• В консоли Xcode вы, скорее всего, увидите сообщение вида:

  [Foundation] +[NSRunLoop(NSRunLoop) runMode:beforeDate:]: wakeup port is nil. This is likely a result of calling -[NSRunLoop(NSRunLoop) runMode:beforeDate:] too many times. This will throw an exception in the future.
  

    Или более прямое предупреждение о взаимоблокировке.

• Отладка: Если вы попали в такую ситуацию во время отладки, остановив выполнение (Pause), вы увидите в Backtrace (стеке вызовов), что главный поток заблокирован на вызове dispatch_sync.

Типичный случай использования и безопасная альтернатива

Частой причиной этой ошибки является попытка обновить UI из фонового потока. Правильный паттерн — использовать DispatchQueue.main.async:

// ВНИМАНИЕ: ЭТО ВЫЗОВЕТ DEADLOCK, если выполняется на главном потоке!
func updateLabel1(newText: String) {
    DispatchQueue.main.sync { // ОШИБКА! Используйте .async
        label.text = newText
    }
}

// ПРАВИЛЬНЫЙ ВАРИАНТ:
func updateLabel2(newText: String) {
    DispatchQueue.main.async { // Безопасно с любого потока
        label.text = newText
    }
}

Вывод: Никогда не используйте DispatchQueue.main.sync. Если вам нужно выполнить что-то на главной очереди, всегда используйте async. Если вам критично дождаться результата (что бывает крайне редко для UI), перестройте логику так, чтобы это ожидание происходило не на главном потоке. Современные фреймворки, такие как Combine или async/await в Swift Concurrency, предоставляют более безопасные и элегантные абстракции (MainActor) для работы с главным потоком, которые помогают избежать подобных ошибок на уровне архитектуры.