dispatch_after - GCD в быстром?

Question

dispatch_after - GCD в быстром?

Я прошел iBook от Apple, и не мог найти его определение:

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

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

585

ios swift objective-c grand-central-dispatch

Источник

user1127619 04 июн '14 в 10:05

26 ответов

Решение

Я использую 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)
}

1115

Источник

user341994 20 июн '14 в 01:57

Чтобы расширить ответ Цезария, который будет выполнен через 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) {
    // ...
}

157

Источник

user73479 04 июн '14 в 20:59

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

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

85

Источник

user3836067 04 авг '14 в 13:55

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

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

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

delayWithSeconds(1) {
   //Do something
}

32

Источник

user3627468 24 окт '16 в 06:00

У 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#>
}

24

Источник

user35690 12 ноя '15 в 00:45

Другой способ - расширить 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)
    })

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

15

Источник

user698967 11 ноя '14 в 05:23

В 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")
    }

9

Источник

user1547529 14 июл '16 в 05:33

В Swift 5 используйте следующее:

 DispatchQueue.main.asyncAfter(deadline: .now() + 0.2, execute: closure) 

// time gap, specify unit is second
DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(2)) {
            Singleton.shared().printDate()
        }
// default time gap is second, you can reduce it
    DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
          // just do it!
    }

5

Источник

user5196286 25 дек '19 в 13:45

1) Добавьте этот метод как часть UIViewController Extension.

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) executeSelector("имя вашего метода", 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
}

}

5

Источник

user5259891 16 фев '16 в 09:18

Версия 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")
}

5

Источник

user1624283 03 ноя '16 в 10:50

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

`NSTimer` против `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) 
```
Смотрите мой более полный ответ здесь.

5

Источник

user3681880 16 май '16 в 06:24

Для нескольких функций используйте это. Это очень полезно для использования анимации или загрузчика активности для статических функций или любого обновления пользовательского интерфейса.

DispatchQueue.main.asyncAfter(deadline: .now() + 0.9) {
            // Call your function 1
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                // Call your function 2
            }
        }

Например, используйте анимацию перед перезагрузкой tableView. Или любое другое обновление интерфейса после анимации.

*// Start your amination* 
self.startAnimation()
DispatchQueue.main.asyncAfter(deadline: .now() + 0.9) {
                *// The animation will execute depending on the delay time*
                self.stopAnimation()
                DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                    *// Now update your view*
                     self.fetchData()
                     self.updateUI()
                }
            }

3

Источник

user9557153 11 июл '18 в 09:56

Свифт 3 и 4:

Вы можете создать расширение в DispatchQueue и добавить функцию delay, которая использует функцию DispatchQueue asyncAfter для внутреннего использования.

extension DispatchQueue {
    static func delay(_ delay: DispatchTimeInterval, closure: @escaping () -> ()) {
        let timeInterval = DispatchTime.now() + delay
        DispatchQueue.main.asyncAfter(deadline: timeInterval, execute: closure)
    }
}

использовать:

DispatchQueue.delay(.seconds(1)) {
    print("This is after delay")
}

2

Источник

user1570808 12 апр '18 в 10:17

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

Свифт 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);
});

2

Источник

user5956568 30 мар '17 в 10:38

Задержка вызова GCD с использованием asyncAfter в swift

let delayQueue = DispatchQueue(label: "com.theappmaker.in", qos: .userInitiated)
let additionalTime: DispatchTimeInterval = .seconds(2)

Мы можем задержать как ** микросекунды,миллисекунды,наносекунды

delayQueue.asyncAfter(deadline: .now() + 0.60) {
    print(Date())
}

delayQueue.asyncAfter(deadline: .now() + additionalTime) {
    print(Date())
}

1

Источник

user4365734 13 апр '18 в 10:01

В Swift 4

Используйте этот фрагмент:

    let delayInSec = 1.0
    DispatchQueue.main.asyncAfter(deadline: .now() + delayInSec) {
       // code here
       print("It works")
    }

1

Источник

user1779988 10 сен '18 в 14:29

Сохранить `current queue`!

Помимо хороших ответов на этот вопрос, вы также можете рассмотреть возможность сохранения текущей очереди для предотвращения излишних операций с основной очередью (например, когда вы пытаетесь отложить некоторые асинхронные операции).

      func after(_ delay: TimeInterval,
           perform block: @escaping ()->(),
           on queue: DispatchQueue = OperationQueue.current?.underlyingQueue ?? .main) { // So this `queue` preserves the current queue and defaulted to the `main`. Also the caller can pass in the desired queue explicitly
    queue.asyncAfter(deadline: .now() + delay, execute: block)
}

Применение:

      after(3) {
    // will be executed on the caller's queue
    print(Date())
}

1

Источник

user5623035 08 май '21 в 01:39

Еще один помощник для задержки вашего кода, который используется на 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
}

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

import HandySwift    

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

1

Источник

user3451975 09 июн '16 в 17:23

Вот синхронная версия asyncAfter в Swift:

let deadline = DispatchTime.now() + .seconds(3)
let semaphore = DispatchSemaphore.init(value: 0)
DispatchQueue.global().asyncAfter(deadline: deadline) {
    dispatchPrecondition(condition: .onQueue(DispatchQueue.global()))
    semaphore.signal()
}

semaphore.wait()

Наряду с асинхронным:

let deadline = DispatchTime.now() + .seconds(3)
DispatchQueue.main.asyncAfter(deadline: deadline) {
    dispatchPrecondition(condition: .onQueue(DispatchQueue.global()))
}

1

Источник

user2340064 29 июн '19 в 23:56

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ // ... });

Функция dispatch_after (:: _:) принимает три параметра:

задержка очередь диспетчеризации блок или замыкание Функция dispatch_after (:: _:) вызывает блок или замыкание в очереди диспетчеризации, которое передается функции после заданной задержки. Обратите внимание, что задержка создается с помощью функции dispatch_time (::). Запомните это, потому что мы также используем эту функцию в Swift.

Я рекомендую пройти курс обучения Raywenderlich Dispatch.

1

Источник

user6672019 19 май '18 в 16:35

Я всегда предпочитаю использовать расширение вместо бесплатных функций.

Swift 4

public extension DispatchQueue {

  private class func delay(delay: TimeInterval, closure: @escaping () -> Void) {
    let when = DispatchTime.now() + delay
    DispatchQueue.main.asyncAfter(deadline: when, execute: closure)
  }

  class func performAction(after seconds: TimeInterval, callBack: @escaping (() -> Void) ) {
    DispatchQueue.delay(delay: seconds) {
      callBack()
    }
  }

}

Используйте как следовать.

DispatchQueue.performAction(after: 0.3) {
  // Code Here
}

1

Источник

user1564990 21 фев '18 в 06:31

Используйте этот код для выполнения некоторой связанной с пользовательским интерфейсом задачи через 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")
}

0

Источник

user1624283 21 янв '16 в 16:24

Теперь больше, чем синтаксический сахар для асинхронных рассылок в Grand Central Dispatch (GCD) в Swift.

добавить подфайл

pod 'AsyncSwift'

Затем вы можете использовать это так.

let seconds = 3.0
Async.main(after: seconds) {
print("Is called after 3 seconds")
}.background(after: 6.0) {
print("At least 3.0 seconds after previous block, and 6.0 after Async code is called")
}

0

Источник

user6608152 03 янв '18 в 07:12

Swift 4 имеет довольно короткий способ сделать это:

Timer.scheduledTimer(withTimeInterval: 2, repeats: false) { (timer) in
    // Your stuff here
    print("hello")
}

0

Источник

user4957288 17 мар '18 в 01:48

Чтобы выполнить функцию или код после задержки, используйте следующий метод

DispatchQueue.main.asyncAfter(deadline: .now() + 'secondsOfDelay') {
        your code here...
    }

Пример - В этом примере функция getShowMovies будет выполнено через 1 секунду

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
        self.getShowMovies()
    }

-1

Источник

user13405909 09 окт '20 в 15:42

Другие вопросы по тегам ios swift objective-c grand-central-dispatch

user1701975 04 июн '14 в 10:19 2014-06-04 10:19 · Accepted Answer · 2014-06-04 10:19

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

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

dispatch_time_t это UInt64, dispatch_queue_t на самом деле типа псевдоним к NSObject, но вы должны просто использовать ваши знакомые методы GCD, чтобы получить очереди. Блок Swift закрывается. В частности, 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")
}

РЕДАКТИРОВАТЬ:

Я рекомендую использовать @ Matt's действительно приятно 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

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

dispatch_after - GCD в быстром?

26 ответов

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

NSTimer против dispatch_after

Задержка задачи с NSTimer

Заметки

Сохранить current queue!

Применение:

`NSTimer` против `dispatch_after`

Задержка задачи с `NSTimer`

Сохранить `current queue`!