Что будет если вызвать main.sync?

Что произойдет при вызове DispatchQueue.main.sync()?

Вызов DispatchQueue.main.sync() — это попытка синхронного выполнения задачи на главной очереди (main queue), которая связана с главным потоком (main thread) в iOS/macOS приложениях. Главный поток отвечает за обработку пользовательского интерфейса (UI), включая отрисовку элементов и обработку событий (таких как нажатия кнопок).

Основные риски и возможные результаты

1. Немедленная блокировка главного потока:

   DispatchQueue.main.sync {
       print("Эта задача выполняется синхронно на главной очереди")
   }
   

   При вызове из не главного потока (например, из background queue), код выполняется без проблем: текущий background thread будет заблокирован до завершения задачи на главном потоке, после чего продолжит работу.

2. Смертельная ситуация: вызов из главного потока:

   // Этот код выполняется уже на главном потоке (например, в обработчике нажатия кнопки)
   DispatchQueue.main.sync {
       // Эта задача никогда не будет выполнена!
   }
   

   Здесь возникает deadlock (взаимная блокировка). Главный поток пытается синхронно выполнить новую задачу на той же самой главной очереди, но:

   • Синхронная операция требует, чтобы текущий поток заблокировался и ожидал завершения задачи.
   • Однако задача не может начать выполнение, потому что главный поток уже заблокирован и не может обрабатывать задачи из своей очереди.
   • Система ожидает, что главный поток обработает задачу, но он сам себя заблокировал.

Почему происходит deadlock?

• Синхронные операции (sync) блокируют текущий поток до завершения выполнения блока кода.
• Очереди (queues) выполняют задачи последовательно (serial) или параллельно (concurrent). Главная очередь (main) — это serial queue, где задачи выполняются строго по очереди.
• Если вы находитесь уже на главном потоке и вызываете main.sync, вы добавляете новую задачу в очередь, но текущая задача (которая вызвала sync) должна завершиться прежде, чем очередь сможет начать следующую. Однако текущая задача не может завершиться, потому что она заблокирована ожиданием новой задачи — классический circular wait.

Практический пример

import Dispatch

// Пример 1: Безопасный вызов из background потока
DispatchQueue.global().async {
    // Мы находимся в background потоке
    DispatchQueue.main.sync {
        // Безопасно: обновляем UI из background потока синхронно
        self.label.text = "Обновлено"
    }
    // Background поток продолжит работу после завершения задачи на main
}

// Пример 2: Опасный вызов из главного потока (deadlock)
@IBAction func buttonTapped(_ sender: UIButton) {
    // Этот код уже выполняется на главном потоке
    DispatchQueue.main.sync {
        // DEADLOCK! Приложение может зависнуть или упасть
        self.label.text = "Эта строка никогда не выполнится"
    }
}

Как избежать проблемы?

• Всегда используйте DispatchQueue.main.async для обновления UI из background потоков:

  DispatchQueue.global().async {
      // Выполняем тяжелые вычисления
      let result = heavyCalculation()
      
      DispatchQueue.main.async {
          // Обновляем UI безопасно
          self.label.text = "Результат: \(result)"
      }
  }
  

• Проверяйте, находитесь ли вы уже на главном потоке, перед использованием sync:

  if Thread.isMainThread {
      // Выполняем код непосредственно
      updateUI()
  } else {
      DispatchQueue.main.sync {
          updateUI()
      }
  }
  

Итог

Вызов DispatchQueue.main.sync() не является абсолютно запрещенным, но требует крайней осторожности. Он безопасен только при вызове из не главного потока, но в большинстве случаев для обновления UI лучше использовать async, чтобы не блокировать background потоки. Вызов main.sync из главного потока приведет к deadlock, который может вызвать зависание UI или даже крах приложения в зависимости от контекста и настроек системы.