dispatch_after - GCD в Swift?

446

Я прошел через iBook от Apple и не смог найти никакого определения:

Может кто-нибудь объяснить структуру dispatch_after?

dispatch_after(<#when: dispatch_time_t#>, <#queue: dispatch_queue_t?#>, <#block: dispatch_block_t?#>)
Теги:
grand-central-dispatch

14 ответов

594
Лучший ответ

Более четкое представление о структуре:

dispatch_after(when: dispatch_time_t, queue: dispatch_queue_t, block: dispatch_block_t?)

dispatch_time_t является UInt64. dispatch_queue_t на самом деле имеет тип с псевдонимом NSObject, но вы должны просто использовать свои привычные методы GCD для получения очередей. Блок - это быстрое закрытие. В частности, dispatch_block_t определяется как () -> Void, что эквивалентно () -> ().

Пример использования:

let delayTime = dispatch_time(DISPATCH_TIME_NOW, Int64(1 * Double(NSEC_PER_SEC)))
dispatch_after(delayTime, dispatch_get_main_queue()) {
    print("test")
}

EDIT:

Я рекомендую использовать @matt действительно приятную delay функцию.

ИЗМЕНИТЬ 2:

В Swift 3 появятся новые обертки для GCD. См. Здесь: https://github.com/apple/swift-evolution/blob/master/proposals/0088-libdispatch-for-swift3.md

В Swift 3 исходный пример будет записан следующим образом:

let deadlineTime = DispatchTime.now() + .seconds(1)
DispatchQueue.main.asyncAfter(deadline: deadlineTime) {
    print("test")
}

Обратите внимание, что вы можете написать объявление deadlineTime как DispatchTime.now() + 1.0 и получить тот же результат, потому что оператор + переопределяется следующим образом (аналогично для -):

  • func +(time: DispatchTime, seconds: Double) -> DispatchTime
  • func +(time: DispatchWalltime, interval: DispatchTimeInterval) -> DispatchWalltime

Это означает, что если вы не используете DispatchTimeInterval enum и просто записываете номер, предполагается, что вы используете секунды.

  • 15
    Совет: поскольку блок является последним параметром для функции, вы можете использовать синтаксис Swift «замыкающее замыкание» для дополнительной читаемости: dispatch_after(1, dispatch_get_main_queue()) { println("test") }
  • 8
    Я думаю, что использование числа 1 в dispatch_after(1, ... может вызвать здесь много путаницы. Люди подумают, что это число секунд, когда на самом деле это нано-секунда . Я предлагаю посмотреть ответ @brindy о том, как правильно создать этот номер.
Показать ещё 8 комментариев
982

Я часто использую dispatch_after, что я написал функцию полезности верхнего уровня, чтобы упростить синтаксис:

func delay(delay:Double, closure:()->()) {
    dispatch_after(
        dispatch_time(
            DISPATCH_TIME_NOW,
            Int64(delay * Double(NSEC_PER_SEC))
        ),
        dispatch_get_main_queue(), closure)
}

И теперь вы можете говорить так:

delay(0.4) {
    // do stuff
}

Вау, язык, на котором вы можете улучшить язык. Что может быть лучше?


Обновление для Swift 3, Xcode 8 Seed 6

Кажется, почти не стоит беспокоиться, теперь, когда они улучшили синтаксис вызова:

func delay(_ delay:Double, closure:@escaping ()->()) {
    let when = DispatchTime.now() + delay
    DispatchQueue.main.asyncAfter(deadline: when, execute: closure)
}
  • 2
    Мне просто нужен был ярлык для расчета задержки, заканчивающийся: func delayInSec(delay: Double) -> dispatch_time_t { return dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC))) }
  • 0
    Будет ли delay(0.0) { /*stuff*/ } (вставлять соответствующие разрывы строк) допустимой командой, если я хочу без промедления что-то сделать в главном потоке (например, изменить GUI)?
Показать ещё 26 комментариев
86

матовый синтаксис очень хорош, и если вам нужно сделать недействительным блок, вы можете использовать это:

typealias dispatch_cancelable_closure = (cancel : Bool) -> Void

func delay(time:NSTimeInterval, closure:()->Void) ->  dispatch_cancelable_closure? {

    func dispatch_later(clsr:()->Void) {
        dispatch_after(
            dispatch_time(
                DISPATCH_TIME_NOW,
                Int64(time * Double(NSEC_PER_SEC))
            ),
            dispatch_get_main_queue(), clsr)
    }

    var closure:dispatch_block_t? = closure
    var cancelableClosure:dispatch_cancelable_closure?

    let delayedClosure:dispatch_cancelable_closure = { cancel in
        if closure != nil {
            if (cancel == false) {
                dispatch_async(dispatch_get_main_queue(), closure!);
            }
        }
        closure = nil
        cancelableClosure = nil
    }

    cancelableClosure = delayedClosure

    dispatch_later {
        if let delayedClosure = cancelableClosure {
            delayedClosure(cancel: false)
        }
    }

    return cancelableClosure;
}

func cancel_delay(closure:dispatch_cancelable_closure?) {

    if closure != nil {
        closure!(cancel: true)
    }
}

Использовать следующим образом

let retVal = delay(2.0) {
    println("Later")
}
delay(1.0) {
    cancel_delay(retVal)
}

кредиты

Ссылка выше, похоже, не работает. Оригинальный код Objc от Github

  • 1
    Единственная функция производительности, которая имеет executeSelector: afterDelay - это возможность отменить его. Только это решение покрывает проблему. Спасибо
  • 0
    @HotJard Обратите внимание, что performSelector:afterDelay: теперь доступен в Swift 2, поэтому вы можете отменить его.
Показать ещё 4 комментария
78

Чтобы расширить ответ на Cezary, который будет выполняться через 1 наносекунду, я должен был выполнить следующие действия через 4 с половиной секунды.

    let delay = 4.5 * Double(NSEC_PER_SEC)
    let time = dispatch_time(DISPATCH_TIME_NOW, Int64(delay))
    dispatch_after(time, dispatch_get_main_queue(), block)

Изменить: я обнаружил, что мой оригинальный код был немного неправильным. Неявная типизация вызывает ошибку компиляции, если вы не передали NSEC_PER_SEC в Double.

Если кто-то может предложить более оптимальное решение, я бы хотел его услышать.

== Обновление для Swift 3 ==

Это супер-легко и элегантно в Swift 3:

    DispatchQueue.main.asyncAfter(deadline: .now() + 4.5) {
        // ...
    }
  • 0
    Я получаю ошибку компилятора для устаревшего API с dispatch_get_current_queue() . Вместо этого я использовал dispatch_get_main_queue() .
  • 0
    @DavidL - спасибо, dispatch_get_main_queue() определенно то, что вы должны использовать. Буду обновлять.
Показать ещё 4 комментария
18

У Apple есть фрагмент dispatch_after для Objective-C:

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    <#code to be executed after a specified delay#>
});

Вот тот же фрагмент, портированный на Swift 3:

DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + <#delayInSeconds#>) {
  <#code to be executed after a specified delay#>
}
14

Другим способом является расширение Double следующим образом:

extension Double {
   var dispatchTime: dispatch_time_t {
       get {
           return dispatch_time(DISPATCH_TIME_NOW,Int64(self * Double(NSEC_PER_SEC)))
       }
   }
}

Затем вы можете использовать его следующим образом:

dispatch_after(Double(2.0).dispatchTime, dispatch_get_main_queue(), { () -> Void in
            self.dismissViewControllerAnimated(true, completion: nil)
    })

Мне нравится функция матовой задержки, но только из-за предпочтения я бы предпочел ограничить прохождение замыканий.

13

Самое простое решение в Swift 3.0 и Swift 4.0

func delayWithSeconds(_ seconds: Double, completion: @escaping () -> ()) {
    DispatchQueue.main.asyncAfter(deadline: .now() + seconds) { 
        completion()
    }
}

Использование

delayWithSeconds(1) {
   //Do something
}
  • 0
    не работает на детской площадке
  • 0
    Это то, что мне было нужно. Спасибо большое !
7

В Swift 3.0

Очереди отправки

  DispatchQueue(label: "test").async {
        //long running Background Task
        for obj in 0...1000 {
            print("async \(obj)")
        }

        // UI update in main queue
        DispatchQueue.main.async(execute: { 
            print("UI update on main queue")
        })

    }

    DispatchQueue(label: "m").sync {
        //long running Background Task
        for obj in 0...1000 {
            print("sync \(obj)")
        }

        // UI update in main queue
        DispatchQueue.main.sync(execute: {
            print("UI update on main queue")
        })
    }

Отправка через 5 секунд

    DispatchQueue.main.after(when: DispatchTime.now() + 5) {
        print("Dispatch after 5 sec")
    }
4

версия Swift 3.0

Следующая функция закрытия выполняет некоторую задачу после задержки в основном потоке.

func performAfterDelay(delay : Double, onCompletion: @escaping() -> Void){

    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + delay, execute: {
       onCompletion()
    })
}

Вызвать эту функцию следующим образом:

performAfterDelay(delay: 4.0) {
  print("test")
}
4

1) Добавьте этот метод как часть расширения UIViewController.

extension UIViewController{
func runAfterDelay(delay: NSTimeInterval, block: dispatch_block_t) {
        let time = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
        dispatch_after(time, dispatch_get_main_queue(), block)
    }
}

Вызовите этот метод на VC:

    self.runAfterDelay(5.0, block: {
     //Add code to this block
        print("run After Delay Success")
    })

2) выполнитьSelector ( "yourMethod Name", withObject: nil, afterDelay: 1)

3)

override func viewWillAppear(animated: Bool) {

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2), dispatch_get_main_queue(), { () -> () in
    //Code Here
})

//Компактная форма

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2), dispatch_get_main_queue()) {
    //Code here
}

}

3

Хотя исходный вопрос OP не задан, некоторые связанные вопросы NSTimer были отмечены как дубликаты этого вопроса, поэтому здесь стоит указать ответ NSTimer.

NSTimer vs dispatch_after

  • NSTimer более высокий уровень, а dispatch_after - более низкий уровень.
  • NSTimer легче отменить. Отмена dispatch_after требует записи большего количества кода.

Задержка задачи с помощью NSTimer

Создайте экземпляр NSTimer.

var timer = NSTimer()

Запустите таймер с необходимой задержкой.

// invalidate the timer if there is any chance that it could have been called before
timer.invalidate()
// delay of 2 seconds
timer = NSTimer.scheduledTimerWithTimeInterval(2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false) 

Добавьте функцию, которая будет вызываться после задержки (используя любое имя, которое вы использовали для параметра selector выше).

func delayedAction() {
    print("Delayed action has now started."
}

Примечания

  • Если вам нужно отменить действие до его возникновения, просто вызовите timer.invalidate().
  • Для повторного использования используйте repeats: true.
  • Если у вас есть одноразовое событие без необходимости отмены, нет необходимости создавать переменную экземпляра timer. Достаточно следующего:

    NSTimer.scheduledTimerWithTimeInterval(2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false) 
    
  • Посмотрите мой более полный ответ здесь.

0

Это сработало для меня.

Swift 3:

let time1 = 8.23
let time2 = 3.42

// Delay 2 seconds

DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
    print("Sum of times: \(time1 + time2)")
}

Objective-C:

CGFloat time1 = 3.49;
CGFloat time2 = 8.13;

// Delay 2 seconds

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    CGFloat newTime = time1 + time2;
    NSLog(@"New time: %f", newTime);
});
0

Другим помощником для задержки кода 100% Swift в использовании и необязательно позволяет выбирать другой поток для запуска вашего отложенного кода с помощью

public func delay(bySeconds seconds: Double, dispatchLevel: DispatchLevel = .main, closure: @escaping () -> Void) {
    let dispatchTime = DispatchTime.now() + seconds
    dispatchLevel.dispatchQueue.asyncAfter(deadline: dispatchTime, execute: closure)
}

public enum DispatchLevel {
    case main, userInteractive, userInitiated, utility, background
    var dispatchQueue: DispatchQueue {
        switch self {
        case .main:                 return DispatchQueue.main
        case .userInteractive:      return DispatchQueue.global(qos: .userInteractive)
        case .userInitiated:        return DispatchQueue.global(qos: .userInitiated)
        case .utility:              return DispatchQueue.global(qos: .utility)
        case .background:           return DispatchQueue.global(qos: .background)
        }
    }
}

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

delay(bySeconds: 1.5) { 
    // delayed code
}

Если вы хотите задержать свой код в другом потоке:

delay(bySeconds: 1.5, dispatchLevel: .background) { 
    // delayed code that will run on background thread
}

Если вы предпочитаете Рамку, которая также имеет некоторые более удобные функции, тогда проверьте HandySwift. Вы можете добавить его в свой проект через Carthage, а затем использовать его точно так же, как в приведенных выше примерах, например:

import HandySwift    

delay(bySeconds: 1.5) { 
    // delayed code
}
-1

используйте этот код для выполнения некоторой задачи, связанной с пользовательским интерфейсом, через 2.0 секунды.

            let delay = 2.0
            let delayInNanoSeconds = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
            let mainQueue = dispatch_get_main_queue()

            dispatch_after(delayInNanoSeconds, mainQueue, {

                print("Some UI related task after delay")
            })

версия Swift 3.0

Следующая функция закрытия выполняет некоторую задачу после задержки в основном потоке.

func performAfterDelay(delay : Double, onCompletion: @escaping() -> Void){

    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + delay, execute: {
       onCompletion()
    })
}

Вызвать эту функцию следующим образом:

performAfterDelay(delay: 4.0) {
  print("test")
}
  • 1
    Это почти идентично предыдущим ответам
  • 0
    Похоже, что этот ответ был сделан в начале 2016 года, и старше, по крайней мере, 6 других ответов ..

Ещё вопросы

Сообщество Overcoder
Наверх
Меню