Аналог dispatch_after в Swift: как выполнить код с задержкой через GCD?

Правильный способ задержки в Swift: asyncAfter

Вы всё делаете верно! DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) — это прямой и рекомендуемый аналог dispatch_after в Swift. Давайте разберёмся детально.

Как работает deadline

Параметр deadline принимает значение типа DispatchTime. Выражение .now() + 2.0 означает: «текущее время + 2 секунды». Это не магия — просто перегрузка оператора + для DispatchTime и чисел с плавающей точкой. Тип Double автоматически интерпретируется как секунды.

Важно: .now() фиксируется в момент вызова asyncAfter, а не когда блок попадает в очередь. Поэтому задержка точная, но не гарантирует выполнение ровно через 2.0 секунды — зависит от загрузки очереди.

Примеры для разных очередей

// Главная очередь (UI-поток)
DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
    // Обновление UI через 0.5 секунды
    self.label.text = "Обновлено"
}

// Глобальная фоновая очередь с качеством service (background)
DispatchQueue.global(qos: .background).asyncAfter(deadline: .now() + 3.0) {
    // Тяжёлая работа через 3 секунды
    let result = performHeavyTask()
    DispatchQueue.main.async {
        // Возвращаем результат в UI
        self.updateUI(with: result)
    }
}

// Собственная последовательная очередь
let serialQueue = DispatchQueue(label: "com.example.serial")
serialQueue.asyncAfter(deadline: .now() + 1.0) {
    print("Выполнено на custom serial queue")
}

Отмена запланированной задачи

В Swift нет прямого аналога dispatch_block_cancel для asyncAfter. Но есть два рабочих подхода:

• DispatchWorkItem — объект, который можно отменить до начала выполнения:

  let workItem = DispatchWorkItem {
      print("Эта задача может быть отменена")
  }
  
  // Запланировать
  DispatchQueue.main.asyncAfter(deadline: .now() + 5.0, execute: workItem)
  
  // Отменить (если задача ещё не начала выполняться)
  workItem.cancel()

• Флаг отмены — для более сложных сценариев:

  var isCancelled = false
  
  DispatchQueue.global().asyncAfter(deadline: .now() + 2.0) { [weak self] in
      guard !isCancelled else { return }
      // Ваш код
  }

Подводные камни и советы

• Захват self — если внутри замыкания обращаетесь к self (например, к UI), используйте [weak self] или [unowned self], чтобы избежать утечек памяти.
• Точность задержки — для высокоточной задержки (менее 1 мс) используйте DispatchTime.now() + .milliseconds(500).
• Не используйте sleep() — Thread.sleep(forTimeInterval:) блокирует текущий поток, это не то же самое, что асинхронная задержка.
• Альтернативы — для простых задержек можно использовать Timer.scheduledTimer(withTimeInterval:repeats:block:), но он работает только на главном потоке.

В итоге: ваш код DispatchQueue.main.asyncAfter — это правильный современный Swift-способ. Продолжайте использовать его, а для отмены — оборачивайте в DispatchWorkItem.

// Однократный таймер с задержкой 2 секунды
Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { timer in
    print("Прошло 2 секунды (Timer)")
    // Обновление UI
    self.label.text = "Готово"
}

// Для отмены сохраните ссылку
var myTimer: Timer?

func scheduleDelayedTask() {
    myTimer?.invalidate() // Отменить предыдущий, если есть
    myTimer = Timer.scheduledTimer(withTimeInterval: 1.5, repeats: false) { _ in
        print("Задача выполнена")
    }
}

// Отмена досрочно
func cancelTask() {
    myTimer?.invalidate()
    myTimer = nil
}