iOS
Concurrence

Introduction

Syntaxe

• dispatch_async - Exécute un bloc de code dans une file d'attente séparée et n'arrête pas la file d'attente en cours. Si la file d'attente se trouve sur un thread différent de celui sur lequel on a appelé dispatch_async, le code du bloc s'exécutera alors que le code est exécuté après l'exécution de dispatch_async
• dispatch_sync - exécute un bloc de code dans une file d' attente séparée, et ne se limite la file d' attente en cours. Si la file d'attente se trouve sur un thread différent de celui sur lequel on a appelé dispatch_async, le code du bloc s'exécutera et son exécution sur le thread où la méthode a été appelée ne reprendra qu'après la fin

Paramètres

Remarques

Exécution simultanée du code - Exécution du code lors de l'exécution d'un autre code

Supposons que vous souhaitiez effectuer une action (dans ce cas, vous connectez "Foo"), tout en faisant autre chose (en enregistrant "Bar"). Normalement, si vous n'utilisez pas la simultanéité, l'une de ces actions va être entièrement exécutée et l'autre exécution ne sera exécutée qu'après avoir été complètement terminée. Mais avec la concurrence, vous pouvez exécuter les deux actions en même temps:

dispatch_async(dispatch_queue_create("Foo", DISPATCH_QUEUE_CONCURRENT), ^{
    for (int i = 0; i < 100; i++) {
        NSLog(@"Foo");
        usleep(100000);
    }
});

for (int i = 0; i < 100; i++) {
    NSLog(@"Bar");
    usleep(50000);
}

Cela va enregistrer "Foo" 100 fois, en faisant une pause de 100 ms à chaque fois qu'il se connecte, mais il fera tout cela sur un thread séparé. Pendant que Foo est en cours de connexion, "Bar" sera également enregistré dans des intervalles de 50 ms, en même temps. Vous devriez idéalement voir une sortie avec "Foo" et "Bars" mélangés ensemble

Exécution sur le thread principal

Lors de l'exécution asynchrone de tâches, il devient généralement nécessaire de s'assurer qu'un morceau de code est exécuté sur le thread principal. Par exemple, vous voudrez peut-être frapper une API REST de manière asynchrone, mais placez le résultat dans un UILabel à l'écran. Avant de mettre à jour le UILabel, vous devez vous assurer que votre code est exécuté sur le thread principal:

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    //Perform expensive tasks
    //...

    //Now before updating the UI, ensure we are back on the main thread
    dispatch_async(dispatch_get_main_queue(), ^{
        label.text = //....
    });
}

Chaque fois que vous mettez à jour des vues à l'écran, assurez-vous toujours de le faire sur le thread principal, sinon un comportement indéfini pourrait se produire.

Dispatch group - en attente d'autres threads terminés.

dispatch_group_t preapreWaitingGroup = dispatch_group_create();

dispatch_group_enter(preapreWaitingGroup);
[self doAsynchronousTaskWithComplete:^(id someResults, NSError *error) { 
    // Notify that this task has been completed.
    dispatch_group_leave(preapreWaitingGroup);  
}]

dispatch_group_enter(preapreWaitingGroup);
[self doOtherAsynchronousTaskWithComplete:^(id someResults, NSError *error) { 
    dispatch_group_leave(preapreWaitingGroup);  
}]

dispatch_group_notify(preapreWaitingGroup, dispatch_get_main_queue(), ^{
    // This block will be executed once all above threads completed and call dispatch_group_leave
    NSLog(@"Prepare completed. I'm readyyyy");
});

Mise à jour 1. Version Swift 3.

let prepareGroup = DispatchGroup()
prepareGroup.enter()
doAsynchronousTaskWithComplete() { (someResults, error) in
    // Notify that this task has been completed.
    prepareGroup.leave()
}

prepareGroup.enter()
doOtherAsynchronousTaskWithComplete() { (someResults, error) in
    // Notify that this task has been completed.
    prepareGroup.leave()
}

prepareGroup.notify(queue: DispatchQueue.main) {
    // This block will be executed once all above threads completed and call dispatch_group_leave
    print("Prepare completed. I'm readyyyy")
}