dispatch_after - GCD no Swift?


558

Examinei o iBook da Apple e não consegui encontrar nenhuma definição dele:

Alguém pode explicar a estrutura de dispatch_after?

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

1
A Apple não publicou este livro em 2018. O arquivo mais recente que encontrei é de dezembro de 2017 . Agora, os links antigos para o iBook simplesmente redirecionam para developer.apple.com/documentation/swift .
Cœur

Respostas:


742

Uma ideia mais clara da estrutura:

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

dispatch_time_té um UInt64. Na dispatch_queue_tverdade, o tipo é aliasizado a um NSObject, mas você deve apenas usar seus métodos GCD familiares para obter filas. O bloco é um fechamento rápido. Especificamente, dispatch_block_té definido como () -> Void, o que é equivalente a () -> ().

Exemplo de uso:

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

EDITAR:

Eu recomendo usar a delayfunção realmente agradável de @ matt .

EDIT 2:

No Swift 3, haverá novos wrappers para o GCD. Veja aqui: https://github.com/apple/swift-evolution/blob/master/proposals/0088-libdispatch-for-swift3.md

O exemplo original seria escrito da seguinte forma no Swift 3:

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

Observe que você pode escrever a deadlineTimedeclaração como DispatchTime.now() + 1.0e obter o mesmo resultado porque o +operador é substituído da seguinte maneira (da mesma forma para -):

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

Isso significa que, se você não usar o DispatchTimeInterval enume apenas escrever um número, presume-se que você esteja usando segundos.


17
Dica: Como o bloco é o parâmetro final da função, você pode usar a sintaxe "trailing encerramento" do Swift para facilitar a leitura:dispatch_after(1, dispatch_get_main_queue()) { println("test") }
Bill

8
Eu acho que usar o número 1em dispatch_after(1, ...pode causar muita confusão aqui. As pessoas vão pensar que é um número de segundos, quando na verdade é nano-segundo . Sugiro ver a resposta de @brindy sobre como criar esse número corretamente.
Hlung

3
Mude 1para dispatch_time(DISPATCH_TIME_NOW, Int64(1 * Double(NSEC_PER_SEC)))porque leva a confusão. As pessoas podem pensar que você não precisa criar um dispatch_time_t no Swift
#:

4
A versão Swift 3 não parece estar funcionando. Alega que Binary operator '+' cannot be applied to operands of type DispatchTime and '_'na linha #let delayTime = DispatchTime.now() + .seconds(1.0)
Andy Ibanez

9
Reescrevê-la como DispatchTime.now() + 1.0parece ser a única maneira de fazê-lo funcionar (sem necessidade de .seconds)
Andy Ibanez

1093

Uso dispatch_aftertantas vezes que escrevi uma função de utilitário de nível superior para simplificar a sintaxe:

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

E agora você pode falar assim:

delay(0.4) {
    // do stuff
}

Uau, um idioma onde você pode melhorar o idioma. O que poderia ser melhor?


Atualização para Swift 3, Xcode 8 Seed 6

Parece que quase não vale a pena se preocupar, agora que eles melhoraram a sintaxe de chamada:

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

2
Eu só precisava de atalho para o cálculo de atraso, acabou com:func delayInSec(delay: Double) -> dispatch_time_t { return dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC))) }
Aviel Gross

4
@ agf119105 Se você tiver apenas uma linha de código no fechamento, adicione outra linha de código (por exemplo return).
Matt

2
@GastonM Irrelevant. Passando uma função tem de si mesma sem problemas de gerenciamento de memória.
Matt

7
"Um idioma onde você pode melhorar o idioma". Não entendo como a definição de uma função global está melhorando a linguagem ou por que isso não é possível em C mesmo. Talvez se você sobrecarregar um operador;)1.0 ~~ { code...}
Yerk

8
Não questionando a exatidão de sua resposta - mas não é "eu uso o dispatch_after tantas vezes" um cheiro de código que seria melhor combatido por não fornecer uma função de conveniência?
Nikolai Ruhe

128

Swift 3+

Isso é super fácil e elegante no Swift 3+:

DispatchQueue.main.asyncAfter(deadline: .now() + 4.5) {
    // ...
}

Resposta mais antiga:

Para expandir a resposta de Cezary, que será executada após 1 nanossegundo, tive que fazer o seguinte para executar após 4 segundos e meio.

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)

Edit: Eu descobri que meu código original estava um pouco errado. A digitação implícita causa um erro de compilação se você não converter NSEC_PER_SEC em um Double.

Se alguém puder sugerir uma solução mais ideal, eu gostaria de ouvi-la.


Eu recebo um erro do compilador para uma API preterida com dispatch_get_current_queue(). Eu usei em dispatch_get_main_queue()vez disso.
David L

@ DavidD - obrigado, dispatch_get_main_queue()é definitivamente o que você deve usar. Atualizará.
Brindy

i tentou isso em um parque infantil com rápida 3 e ele não funciona
μολὼν.λαβέ

@GAlexander Trabalha para mim. Você está permitindo que o playground seja executado indefinidamente?
Brindy

Bem, não, deixo correr por algumas horas e ainda nada impresso. aqui está o que eu usei. "importar expedição importar Darwin importar CoreGraphics 'DispatchQueue.main.asyncAfter (deadline: .now () + 4.5) {print (" got here ")}"
μολὼν.λαβέ

83

A sintaxe de matt é muito agradável e, se você precisar invalidar o bloco, poderá usar isso:

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

Use como segue

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

créditos

O link acima parece estar inoperante. Código Objc original do Github


1
O único recurso de desempenho que tem performSelector: afterDelay é a capacidade de cancelá-lo. Somente esta solução cobre o problema. Obrigado
HotJard

@ HotJard Observe que performSelector:afterDelay:agora está disponível no Swift 2, para que você possa cancelá-lo.
Matt

@matt, mas está disponível apenas para NSObject, não é?
HotJard

@ HotJard Claro, mas é melhor do que não tê-lo. Não vejo nenhum problema lá. No entanto, assim como com esta resposta, eu já havia compensado sua perda escrevendo um cronômetro cancelável baseado em GCD (usando a dispatch_source_t, porque isso é algo que você pode cancelar).
Matt

2
Muito obrigado, eu tenho usado isso até o Swift 2.3. O compilador Swift 3.0 está reclamando agora, seria ótimo se você atualizasse sua resposta!
Atontomatic 14/09

27

Solução mais simples no Swift 3.0 e Swift 4.0 e Swift 5.0

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

Uso

delayWithSeconds(1) {
   //Do something
}

22

A Apple possui um snippet de dispatch_after para o 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#>
});

Aqui está o mesmo trecho transportado para o Swift 3:

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

14

Outra maneira é estender o Double assim:

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

Então você pode usá-lo assim:

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

Eu gosto da função delay de matt, mas apenas por preferência, prefiro limitar o fechamento de passagens.


8

No Swift 3.0

Filas de expedição

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

Despacho após 5 segundos

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

4

Versão Swift 3.0

Após a função de fechamento, execute alguma tarefa após atraso no encadeamento principal.

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

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

Chame esta função como:

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

4

1) Adicione este método como parte da extensão 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)
    }
}

Chame este método no VC:

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

2)

performSelector("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
})

// Forma compacta

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

3

Embora não seja a pergunta original do OP, algumas NSTimerquestões relacionadas foram marcadas como duplicatas dessa pergunta, portanto vale a pena incluir uma NSTimerresposta aqui.

NSTimer vs dispatch_after

  • NSTimeré mais alto nível, enquanto dispatch_afteré mais baixo.
  • NSTimeré mais fácil cancelar. O cancelamento dispatch_afterrequer a criação de mais código .

Atrasando uma tarefa com NSTimer

Crie uma NSTimerinstância.

var timer = NSTimer()

Inicie o cronômetro com o atraso necessário.

// 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) 

Adicione uma função a ser chamada após o atraso (usando o nome que você usou para o selectorparâmetro acima).

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

Notas

  • Se você precisar cancelar a ação antes que ela aconteça, basta ligar timer.invalidate().
  • Para uma ação repetida, use repeats: true.
  • Se você tiver um evento único sem a necessidade de cancelar, não será necessário criar a timervariável de instância. O seguinte será suficiente:

    NSTimer.scheduledTimerWithTimeInterval(2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false) 
  • Veja minha resposta mais completa aqui .


3

Para várias funções, use isso. Isso é muito útil para usar animações ou carregador de atividades para funções estáticas ou qualquer atualização da interface do usuário.

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

Por exemplo - Use uma animação antes que um tableView seja recarregado. Ou qualquer outra atualização da interface do usuário após a animação.

*// 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()
                }
            }

2

Isso funcionou para mim.

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

Objetivo-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

Swift 3 e 4:

Você pode criar uma extensão no DispatchQueue e adicionar atraso de função que usa a função DispatchQueue asyncAfter internamente

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

usar:

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

1

Outro auxiliar para atrasar seu código que é 100% Swift em uso e, opcionalmente, permite escolher um encadeamento diferente para executar seu código atrasado em:

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

Agora você simplesmente adia seu código no thread principal assim:

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

Se você deseja atrasar seu código para um thread diferente :

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

Se você preferir um Framework que também tenha alguns recursos mais úteis, consulte o HandySwift . Você pode adicioná-lo ao seu projeto via Carthage e usá-lo exatamente como nos exemplos acima, por exemplo:

import HandySwift    

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

1

Eu sempre prefiro usar extensão em vez de funções gratuitas.

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()
    }
  }

}

Use da seguinte maneira.

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

1

Atraso na chamada GCD usando asyncAfter in swift

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

Podemos atrasar como ** microssegundos , milissegundos , nanossegundos

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

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

1

Em Swift 4

Use este trecho:

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

Este já está em outras respostas (de Brindy, por exemplo, ou Rahul do) ... mesma sintaxe ...
Eric Aya

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

A dispatch_after(_:_:_:)função usa três parâmetros:

um atraso em
uma fila de expedição,
um bloco ou fechamento

A dispatch_after(_:_:_:)função chama o bloco ou fechamento na fila de despacho que é passada para a função após um determinado atraso. Observe que o atraso é criado usando a dispatch_time(_:_:)função Lembre-se disso, porque também usamos essa função no Swift.

Eu recomendo seguir o tutorial Raywenderlich Dispatch tutorial


1

No Swift 5, use o abaixo:

 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!
    }

0

use esse código para executar alguma tarefa relacionada à interface do usuário após 2,0 segundos.

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

Versão Swift 3.0

Após a função de fechamento, execute alguma tarefa após atraso no encadeamento principal.

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

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

Chame esta função como:

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

1
Isto é quase idêntico às respostas anteriores
Daniel Galasko

Parece que esta resposta foi feito no início de 2016, e é mais velho do que pelo menos outras 6 respostas ..
eharo2

0

Agora, mais do que o açúcar sintático para envios assíncronos no Grand Central Dispatch (GCD) em Swift.

adicionar Podfile

pod 'AsyncSwift'

Então, você pode usá-lo assim.

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

A Apple nos deu todo o necessário para usar o GCD em poucas linhas. Por que se preocupar com pods, espaço de trabalho e assim por diante? Basta ler os documentos sobre @escaping e captura. é o suficiente.
precisa saber é o seguinte

0

O Swift 4 tem uma maneira bastante curta de fazer isso:

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

0

Aqui está a versão síncrona do asyncAfter no 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()

Juntamente com o assíncrono:

let deadline = DispatchTime.now() + .seconds(3)
DispatchQueue.main.asyncAfter(deadline: deadline) {
    dispatchPrecondition(condition: .onQueue(DispatchQueue.global()))
}
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.