Attendre que la tâche se termine

Question

Comment puis-je faire en sorte que mon code attende que la tâche dans DispatchQueue se termine ? Faut-il un CompletionHandler ou autre ?

func myFunction() {
    var a: Int?

    DispatchQueue.main.async {
        var b: Int = 3
        a = b
    }

    // wait until the task finishes, then print 

    print(a) // - this will contain nil, of course, because it
             // will execute before the code above

}

J'utilise Xcode 8.2 et j'écris en Swift 3.

Answer 1

Utilisez DispatchGroup pour y parvenir. Vous pouvez soit recevoir une notification lorsque le groupe enter() et leave() les appels sont équilibrés :

func myFunction() {
    var a: Int?

    let group = DispatchGroup()
    group.enter()

    DispatchQueue.main.async {
        a = 1
        group.leave()
    }

    // does not wait. But the code in notify() gets run 
    // after enter() and leave() calls are balanced

    group.notify(queue: .main) {
        print(a)
    }
}

ou vous pouvez attendre :

func myFunction() {
    var a: Int?

    let group = DispatchGroup()
    group.enter()

    // avoid deadlocks by not using .main queue here
    DispatchQueue.global(attributes: .qosDefault).async {
        a = 1
        group.leave()
    }

    // wait ...
    group.wait()

    print(a) // you could also `return a` here
}

Note : group.wait() bloque la file d'attente actuelle (probablement la file principale dans votre cas), vous devez donc dispatch.async sur une autre file d'attente (comme dans l'exemple de code ci-dessus) pour éviter une impasse .

Answer 2

Dans Swift 3, il n'y a pas besoin de gestionnaire de complétion lorsque DispatchQueue termine une tâche. En outre, vous pouvez atteindre votre objectif de différentes manières

Voici une façon de le faire :

    var a: Int?

    let queue = DispatchQueue(label: "com.app.queue")
    queue.sync {

        for  i in 0..<10 {

            print("" , i)
            a = i
        }
    }

    print("After Queue \(a)")

Il attendra que la boucle se termine, mais dans ce cas, votre fil principal se bloquera.

Vous pouvez aussi faire la même chose comme ceci :

    let myGroup = DispatchGroup()
    myGroup.enter()
    //// Do your task

    myGroup.leave() //// When your task completes
     myGroup.notify(queue: DispatchQueue.main) {

        ////// do your remaining work
    }

Une dernière chose : si vous voulez utiliser completionHandler lorsque votre tâche se termine en utilisant DispatchQueue, vous pouvez utiliser DispatchWorkItem .

Voici un exemple d'utilisation DispatchWorkItem :

let workItem = DispatchWorkItem {
    // Do something
}

let queue = DispatchQueue.global()
queue.async {
    workItem.perform()
}
workItem.notify(queue: DispatchQueue.main) {
    // Here you can notify you Main thread
}

Answer 3

Version Swift 5 de la solution

func myCriticalFunction() {
    var value1: String?
    var value2: String?

    let group = DispatchGroup()

    group.enter()
    //async operation 1
    DispatchQueue.global(qos: .default).async { 
        // Network calls or some other async task
        value1 = //out of async task
        group.leave()
    }

    group.enter()
    //async operation 2
    DispatchQueue.global(qos: .default).async {
        // Network calls or some other async task
        value2 = //out of async task
        group.leave()
    }

    group.wait()

    print("Value1 \(value1) , Value2 \(value2)") 
}

Answer 4

Utiliser le groupe d'envoi

dispatchGroup.enter()
FirstOperation(completion: { _ in
    dispatchGroup.leave()
})
dispatchGroup.enter()
SecondOperation(completion: { _ in
    dispatchGroup.leave()
})
dispatchGroup.wait() // Waits here on this thread until the two operations complete executing.

Answer 5

Swift 4

Vous pouvez utiliser la fonction Async pour ces situations. Lorsque vous utilisez DispatchGroup() Parfois impasse peut se produire.

var a: Int?
@objc func myFunction(completion:@escaping (Bool) -> () ) {

    DispatchQueue.main.async {
        let b: Int = 3
        a = b
        completion(true)
    }

}

override func viewDidLoad() {
    super.viewDidLoad()

    myFunction { (status) in
        if status {
            print(self.a!)
        }
    }
}