Central pós-GCD em Swift?
eu passei pelo livroda Apple, e não encontrei nenhuma definição dele:
Alguém pode explicar a estrutura dedispatch_after
?
dispatch_after(<#when: dispatch_time_t#>, <#queue: dispatch_queue_t?#>, <#block: dispatch_block_t?#>)
25 answers
Uma ideia mais clara da estrutura:
dispatch_after(when: dispatch_time_t, queue: dispatch_queue_t, block: dispatch_block_t?)
dispatch_time_t
to a UInt64
. O dispatch_queue_t
é, na verdade, digitar aliased para um NSObject
, mas você deve apenas usar os seus métodos de GCD familiares para obter filas. O quarteirão é um encerramento rápido. Especificamente, dispatch_block_t
é definido como () -> Void
, que é equivalente a () -> ()
.
Uso de exemplo:
let delayTime = dispatch_time(DISPATCH_TIME_NOW, Int64(1 * Double(NSEC_PER_SEC)))
dispatch_after(delayTime, dispatch_get_main_queue()) {
print("test")
}
Editar:
Recomendo a utilização da função @matt's really nice delay
.
Editar 2:
Em Swift 3, haverá novas embalagens 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 em Swift 3:
let deadlineTime = DispatchTime.now() + .seconds(1)
DispatchQueue.main.asyncAfter(deadline: deadlineTime) {
print("test")
}
Lembre-se que pode escrever a declaração deadlineTime
como DispatchTime.now() + 1.0
e obter o mesmo resultado porque o operador +
é substituído do seguinte modo (da mesma forma para -
):
func +(time: DispatchTime, seconds: Double) -> DispatchTime
func +(time: DispatchWalltime, interval: DispatchTimeInterval) -> DispatchWalltime
DispatchTimeInterval
enum
e basta escrever um número, assume-se que você está usando segundos.
Uso dispatch_after
tantas vezes que escrevi uma função de utilidade de topo para tornar a sintaxe mais simples:
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 podes falar assim:
delay(0.4) {
// do stuff
}
Uma língua onde se pode melhorar a língua. O que poderia ser melhor?
Actualização para Swift 3, Xcode 8 Seed 6
Parece que não vale a pena incomodar, agora que melhoraram a sintaxe de chamadas:func delay(_ delay:Double, closure:@escaping ()->()) {
let when = DispatchTime.now() + delay
DispatchQueue.main.asyncAfter(deadline: when, execute: closure)
}
Swift 3+
Isto é super fácil e elegante no Swift 3+:DispatchQueue.main.asyncAfter(deadline: .now() + 4.5) {
// ...
}
Resposta Mais Antiga:
Para expandir a resposta do Cezary, que será executada após 1 nanossegundo, eu 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: descobri que o meu código original estava ligeiramente errado. A digitação implícita causa um erro de compilação se você não lançar o NSEC_PER_SEC para um duplo.
Se alguém puder sugerir uma solução melhor, eu ... gostava de ouvir.A sintaxe do Matt é muito boa e se precisar de invalidar o bloco, poderá querer usar isto:
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)
}
}
Utilizar como se segue
let retVal = delay(2.0) {
println("Later")
}
delay(1.0) {
cancel_delay(retVal)
}
o Link acima parece estar em baixo. código Objc Original do Github.
Simplest solution in Swift 3.0 & Swift 4.0 & Swift 5.0
func delayWithSeconds(_ seconds: Double, completion: @escaping () -> ()) {
DispatchQueue.main.asyncAfter(deadline: .now() + seconds) {
completion()
}
}
Utilização
delayWithSeconds(1) {
//Do something
}
A Apple tem um despacho após o excerto 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 portado para Swift 3:
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + <#delayInSeconds#>) {
<#code to be executed after a specified delay#>
}
Outra maneira é estender o dobro desta maneira:
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)
})
Gosto da função de atraso do matt, mas, por preferência, Prefiro limitar os encerramentos.
Em 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")
})
}
Expedição após 5 segundos
DispatchQueue.main.after(when: DispatchTime.now() + 5) {
print("Dispatch after 5 sec")
}
Swift 3.0 version
Após a função de encerramento, execute alguma tarefa após atraso no tópico principal.
func performAfterDelay(delay : Double, onCompletion: @escaping() -> Void){
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + delay, execute: {
onCompletion()
})
}
Chama esta função como:
performAfterDelay(delay: 4.0) {
print("test")
}
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)
}
}
Chama este método em 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
})
//Compact Form
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2), dispatch_get_main_queue()) {
//Code here
}
}
Embora não seja a pergunta original do OP, certas perguntas relacionadas {[[4]} foram marcadas como duplicatas desta pergunta, por isso vale a pena incluir uma resposta NSTimer
aqui.
NSTimer
vs dispatch_after
-
NSTimer
é mais alto, enquanto {[7] } é mais baixo. - É mais fácil cancelar. O cancelamento {[[7]} requer a gravação de mais código .
Atrasar uma tarefa com NSTimer
Cria um NSTimer
instancia.
var timer = NSTimer()
Liga o temporizador com o atraso de que precisas.
// 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 qualquer nome que tenha usado para o parâmetro selector
acima).
func delayedAction() {
print("Delayed action has now started."
}
Notas
- Se precisar de cancelar a acção antes de acontecer, basta ligar para
timer.invalidate()
. - para uma acção repetida
repeats: true
. -
Se você tem um evento único sem necessidade de cancelar, então não há necessidade de criar a instância
timer
variavel. Bastará o seguinte:NSTimer.scheduledTimerWithTimeInterval(2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false)
Veja a minha resposta mais completa.
Para várias funções use isto. Isto é muito útil para usar animações ou carregador de atividade para funções estáticas ou qualquer atualização UI.
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 de uma revisão de páginas. Ou qualquer outra atualização UI 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()
}
}
In Swift 5, use in the below:
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!
}
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)")
}
Objectivo-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);
});
Swift 3 & 4:
Você pode criar uma extensão no DispatchQueue e adicionar um 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)
}
}
Utilizar:
DispatchQueue.delay(.seconds(1)) {
print("This is after delay")
}
Outro auxiliar para atrasar o seu código que é 100% Swift no uso e opcionalmente permite que Escolha um tópico diferente para executar o seu código atrasado de:
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 atrasa o seu código na linha principal Assim:
delay(bySeconds: 1.5) {
// delayed code
}
Se quiser adiar o seu código para um tópico diferente:
delay(bySeconds: 1.5, dispatchLevel: .background) {
// delayed code that will run on background thread
}
Se preferir um Framework que também tenha algumas funcionalidades mais úteis, então faça o check-out desvio manual. Você pode adicioná-lo ao seu projeto via Cartago e usá - lo exatamente como nos exemplos acima, por exemplo:
import HandySwift
delay(bySeconds: 1.5) {
// delayed code
}
Eu sempre prefiro usar extensão em vez de funções livres.
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()
}
}
}
Utilizar como se segue.
DispatchQueue.performAction(after: 0.3) {
// Code Here
}
Atrasar a chamada do GCD usando o asyncAfter no swift
let delayQueue = DispatchQueue(label: "com.theappmaker.in", qos: .userInitiated)
let additionalTime: DispatchTimeInterval = .seconds(2)
Podemos atrasar como microssegundos., milisegundos,nanossegundos
delayQueue.asyncAfter(deadline: .now() + 0.60) {
print(Date())
}
delayQueue.asyncAfter(deadline: .now() + additionalTime) {
print(Date())
}
In Swift 4
Use este excerto:
let delayInSec = 1.0
DispatchQueue.main.asyncAfter(deadline: .now() + delayInSec) {
// code here
print("It works")
}
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// ...
});
A função dispatch_after(_:_:_:)
toma três parâmetros:
Um atraso
uma fila de envio
um bloco ou encerramento
A função dispatch_after(_:_:_:)
invoca o bloco ou o fecho na fila de envio que é passada para a função após um dado atraso. Note que o atraso é criado usando a função dispatch_time(_:_:)
. Lembre-se disso porque nós também usamos esta função no Swift.
Use este código para executar alguma tarefa relacionada com a IU 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")
})
Swift 3.0 version
Após a função de encerramento, execute alguma tarefa após atraso no tópico principal.
func performAfterDelay(delay : Double, onCompletion: @escaping() -> Void){
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + delay, execute: {
onCompletion()
})
}
Chama esta função como:
performAfterDelay(delay: 4.0) {
print("test")
}
Adicionar Podfile
pod 'AsyncSwift'
Então, podes 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")
}
Timer.scheduledTimer(withTimeInterval: 2, repeats: false) { (timer) in
// Your stuff here
print("hello")
}
Aqui está a versão sincronizada 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 um assíncrono:
let deadline = DispatchTime.now() + .seconds(3)
DispatchQueue.main.asyncAfter(deadline: deadline) {
dispatchPrecondition(condition: .onQueue(DispatchQueue.global()))
}
Para executar um function ou código após um atraso, use o método seguinte
DispatchQueue.main.asyncAfter(deadline: .now() + 'secondsOfDelay') {
your code here...
}
Exemplo - Neste exemplo a função getShowMovies
será executada após 1 segundo
DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
self.getShowMovies()
}