Différence entre dispatch_async et dispatch_sync sur la file d'attente série?

J'ai créé une file d'attente série comme celle-ci:

    dispatch_queue_t _serialQueue = dispatch_queue_create("com.example.name", DISPATCH_QUEUE_SERIAL);

Quelle est la différence entre dispatch_asyncappelé comme ça

 dispatch_async(_serialQueue, ^{ /* TASK 1 */ });
 dispatch_async(_serialQueue, ^{ /* TASK 2 */ });

Et dispatch_syncappelé comme ça sur cette file d'attente série?

 dispatch_sync(_serialQueue, ^{ /* TASK 1 */ });
 dispatch_sync(_serialQueue, ^{ /* TASK 2 */ });

Je crois comprendre que, quelle que soit la méthode d'expédition utilisée, TASK 1sera exécutée et complétée avant TASK 2, n'est-ce pas?

Oui. L'utilisation de la file d'attente série garantit l'exécution en série des tâches. La seule différence est que dispatch_syncne revient qu'après la fin du bloc alors quedispatch_async retour après avoir été ajouté à la file d'attente et peut ne pas être terminé.

pour ce code

dispatch_async(_serialQueue, ^{ printf("1"); });
printf("2");
dispatch_async(_serialQueue, ^{ printf("3"); });
printf("4");

Il peut imprimer 2413ou 2143ou 1234mais 1toujours avant3

pour ce code

dispatch_sync(_serialQueue, ^{ printf("1"); });
printf("2");
dispatch_sync(_serialQueue, ^{ printf("3"); });
printf("4");

il s'imprime toujours 1234

Remarque: pour le premier code, il ne s'imprimera pas1324 . Car printf("3")est expédié après avoir printf("2") été exécuté. Et une tâche ne peut être exécutée qu'après avoir été distribuée.

Le temps d'exécution des tâches ne change rien. Ce code s'imprime toujours12

dispatch_async(_serialQueue, ^{ sleep(1000);printf("1"); });
dispatch_async(_serialQueue, ^{ printf("2"); });

Ce qui peut arriver est

• Thread 1: dispatch_async une tâche chronophage (tâche 1) vers la file d'attente série
• Thread 2: démarrer l'exécution de la tâche 1
• Thread 1: dispatch_async une autre tâche (tâche 2) vers la file d'attente série
• Thread 2: tâche 1 terminée. démarrer l'exécution de la tâche 2
• Thread 2: tâche 2 terminée.

et tu vois toujours 12

La différence entre dispatch_syncet dispatch_asyncest simple.

Dans vos deux exemples, TASK 1sera toujours exécuté avant TASK 2car il a été distribué avant lui.

Dans l' dispatch_syncexemple, cependant, vous ne distribuerez pas TASK 2avant d'avoir TASK 1été expédié et exécuté . C'est ce qu'on appelle le "blocage" . Votre code attend (ou "bloque") jusqu'à ce que la tâche s'exécute.

Dans l' dispatch_asyncexemple, votre code n'attendra pas la fin de l'exécution. Les deux blocs seront envoyés (et mis en file d'attente) dans la file d'attente et le reste de votre code continuera à s'exécuter sur ce thread. Ensuite, à un moment donné dans le futur (selon ce qui a été envoyé à votre file d'attente), Task 1s'exécutera puis Task 2s'exécutera.

Tout est lié à la file d'attente principale. Il y a 4 permutations.

i) File d'attente série, répartition asynchrone: Ici les tâches s'exécuteront l'une après l'autre, mais le thread principal (effet sur l'interface utilisateur) n'attendra pas le retour

ii) File d'attente série, synchronisation de répartition: Ici, les tâches s'exécuteront l'une après l'autre, mais le thread principal (effet sur l'interface utilisateur) affichera un décalage

iii) File d'attente simultanée, répartition asynchrone: Ici, les tâches s'exécuteront en parallèle et le thread principal (effet sur l'interface utilisateur) n'attendra pas le retour et sera fluide.

iv) File d'attente simultanée, synchronisation de distribution: Ici, les tâches s'exécuteront en parallèle, mais le thread principal (effet sur l'interface utilisateur) affichera un décalage

Votre choix de file d'attente simultanée ou série dépend de si vous avez besoin d'une sortie d'une tâche précédente pour la suivante. Si vous dépendez de la tâche précédente, adoptez la file d'attente série sinon prenez la file d'attente simultanée.

Et enfin, c'est une façon de revenir au fil conducteur lorsque nous en avons terminé avec notre entreprise:

DispatchQueue.main.async {
     // Do something here
}