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

J'ai créé une série de file d'attente comme ceci:

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

Quelle est la différence entre dispatch_async appelle

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

Et dispatch_sync appelé comme ça sur cette série de file d'attente?

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

Ma compréhension est que, indépendamment de la méthode dispatch est utilisé, TASK 1 seront exécutées et achevées avant TASK 2, correct?

InformationsquelleAutor JRG-Developer | 2013-11-06

403

Oui. À l'aide de file série d'assurer l'exécution en série de tâches. La seule différence est que dispatch_sync seulement de retour après le bloc est terminé alors que dispatch_async de retour après est ajoutée à la file d'attente et ne peuvent pas fini.

pour ce code
```
dispatch_async(_serialQueue, ^{ printf("1"); });
printf("2");
dispatch_async(_serialQueue, ^{ printf("3"); });
printf("4");
```
Il peut imprimer 2413 ou 2143 ou 1234 mais 1 toujours avant 3

pour ce code
```
dispatch_sync(_serialQueue, ^{ printf("1"); });
printf("2");
dispatch_sync(_serialQueue, ^{ printf("3"); });
printf("4");
```
il a toujours l'impression 1234

Remarque: Pour le premier code, il ne impression 1324. Parce que printf("3") est distribué après printf("2") est exécutée. Et une tâche ne peut être exécutée après il est distribué.

Le temps d'exécution des tâches n'a pas changer quoi que ce soit. Ce code toujours l'impression 12
```
dispatch_async(_serialQueue, ^{ sleep(1000);printf("1"); });
dispatch_async(_serialQueue, ^{ printf("2"); });
```
Ce qui peut arrivé est
- Thread 1: dispatch_async une tâche qui prend du temps (tâche 1) série de file d'attente
- Filetage 2: lancer l'exécution de la tâche 1
- Thread 1: dispatch_async une autre tâche (tâche 2) série de file d'attente
- Filetage 2: tâche 1 fini. début de l'exécution de la tâche 2
- Filetage 2: tâche 2 terminé.
et vous voyez toujours 12
- il permet également d'imprimer 2134 et 1243
- ma question est pourquoi ne pas nous ne nous sommes pas fait, comme "normal"? printf("1");printf("2") ;printf("3") ;printf("4") - par rapport à dispatch_sync
- pour le deuxième exemple? parce qu'un autre thread peut courir dispatch_sync(_serialQueue, ^{ /*change shared data*/ }); en même temps.
- serait-single-threaded application bénéficier de dispatch_sync?
- Je ne le pense pas. Il est également susceptible de causer la mort de verrouillage.
- u oublié 1324, pas bon en essayant d'être un besserwisser comme ça;)
- Pourquoi en serait-il d'impression 1324?
- il ne serait probablement pas, mais il est possible
- Si je ne me trompe printf("2") est toujours exécuté avant que le " printf("3"). De sa première ligne de code a frappé lors de la première expédition retours. Sauf si quelqu'un peut expliquer autrement, je suis positif 2 sera imprimé avant le 3
- Bon point en effet, je suis en train d'essayer de comprendre l'envoi, et jusqu'à présent, je suis d'accord que le 2 sera imprimé avant le 3. Si il ya une chance pour les 3 à être imprimé avant le 2 veuillez expliquer, je ne veux pas être confus à ce point.
- Disons que nous avons été dispatch_sync(_serialQueue, ^{ printf(timeConsuimingSomething); }); puis dispatch_sync(_serialQueue, ^{ printf(notTimeConsumingSomething); }); encore timeConsumingSomething est imprimé la première à droite? Comment et qu'est-ce qui est holding notTimeConsumingSomething d'être imprimée pour la première fois, while c'est le code est déjà fini avant timeConsumingSomething !?
- Veuillez noter la différence entre mettre en file d'attente de la tâche et à exécuter la tâche. Parce que les deux dispatch_sync est appelée sur un même thread, c'est la garantie que les deux tâches seront mis en file d'attente avec l'ordre correct. Puis l'expédition de série de la file d'attente s'assurer que les tâches sont exécutées dans l'ordre correct.
- Merci. Je suis désolé signifie async , je comprends la sync situation disons que nous avons été dispatch_sync(_serialQueue, ^{ printf(timeConsuimingSomething); }); puis dispatch_sync(_serialQueue, ^{ printf(notTimeConsumingSomething); }); encore timeConsumingSomething est imprimé la première à droite? Comment et qu'est-ce qui est holding notTimeConsumingSomething d'être imprimée pour la première fois, while c'est le code est déjà fini avant timeConsumingSomething !? *si possible, pouvez-vous s'il vous plaît ajouter un cas où le passage des éléments très différents de timing, comme ma question?
- Super Merci, j' pense - je l'obtenir maintenant. Je ne vois pas quel est l'avantage/ cas d'usage de le faire de cette façon ou de l'autre. Je veux dire si le code est exécuté dans une série façon ET qu'aucune tâche serait de commencer, à moins que sa précédente tâche est terminée, puis c'est juste comme une série de performances file-sage-Sauf si vous êtes à comparer avec quelque chose de dispatchs effet similaire à ce que vous ne l'avez fait avec printf("2"); & printf("4");
- Il est très utile pour partager un non thread-safe objet entre plusieurs threads/de la répartition des files d'attente. Si vous avez seulement accès à l'objet dans une série de file d'attente, vous savez vous y accédez en toute sécurité.
- Laissez-nous continuer cette discussion dans le chat.
- Ne pas les premiers à être "à l'Aide de série de la file d'attente s'assurer de la série enqueueing de tâches"?
- Vous pouvez mettre en file d'attente des tâches de file série simultanément à partir de plusieurs threads.
- voir this le point de l'ensemble d'un envoi asynchrone est de file le bloc et les retourner immédiatement. Si le bloc a été mis en file d'attente sur une série de file d'attente, il peut être beaucoup de minutes avant qu'il soit exécuté. Asynchrone expédition spécifiquement découple enqueueing de l'exécution. –
- Mon Problème est que je pense que votre formulation est incorrecte. Vous devriez corriger votre première ligne: "à l'Aide de série de la file d'attente s'assurer de la série enqueueing de tâches" . File série assure le numéro de série de replacement si la tâche est sync puis attend son exécution, et si ses async il n'a pas d'attente pour l'exécution. Vous avez dit numéro de série de l'exécution, ce qui n'est pas le cas asynchrone. La série-ness de de une file série est sur les tâches de la file d'attente depuis sa encore simultanée à d'autres files d'attente.
- Je ne veux dire numéro de série de l'exécution. Au point de vue que toutes les tâches sont exécutées en série ce qui concerne d'autres tâches dans la même file d'attente. De cause il peut encore être simultanées ce qui concerne les autres files d'attente. Il est le point de l'ensemble de PGCD que les tâches peuvent être expédiés à et exécutées simultanément.
- Clean & Explication Soignée. Merci pour me sauver des millions de fois.
- encore en apprentissage et en revenir à ce post, après 7 mois... Il est très utile pour partager un non thread-safe objet entre plusieurs threads/de la répartition des files d'attente. Si vous avez seulement accès à l'objet dans une série de file d'attente, vous savez vous y accédez en toute sécurité <-- l'accès vous seul moyen pour écrire-lire, sinon, continuez à lire-lire est non problématique et de la bonne solution est d'utiliser dispatch_barrier_async comme indiqué ici droit?
- Oui j'ai accès moyen en lecture/écriture. La réponse vous est lié à une optimisation similaire à lecteurs-verrou en écriture. Donc si la plupart des opérations sont en lecture seule, il permettra d'améliorer les performances.
InformationsquelleAutor Bryan Chen
18

La différence entre dispatch_sync et dispatch_async est simple.

Dans vos deux exemples, TASK 1 sera toujours exécuté avant TASK 2 parce qu'il a été distribué avant elle.

Dans le dispatch_sync exemple, cependant, vous n'aurez pas d'expédition TASK 2 jusqu'à ce que après TASK 1 a été distribué et exécuté. Ceci est appelé "blocage". Votre code attend (ou "blocs") jusqu'à ce que la tâche s'exécute.

Dans le dispatch_async exemple, votre code ne sera pas attendre, pour que l'exécution complète. Les deux blocs de répartition (et être mis en file d'attente) à la file d'attente et le reste de votre code de poursuivre l'exécution sur ce thread. Puis à un certain moment dans l'avenir, en fonction de ce que le reste a été distribué à votre file d'attente), Task 1 va exécuter puis Task 2 à exécuter.
- Je pense que votre mal de commande. premier exemple est async qui est le non-blocage de version
- J'ai édité votre réponse à la ce que je pense que tu voulais dire. Si ce n'est pas le cas, veuillez le modifier et de le clarifier.
- Que faire si vous appelez dispatch_sync et puis dispatch_async sur la même file d'attente? (et vice versa)
- Sur une série de file d'attente, les deux tâches sont toujours exécutées l'une après l'autre. Dans le premier cas, l'appelant attend pour le premier bloc d'arrivée, mais ne pas attendre pour le deuxième bloc. Dans le second cas, l'appelant ne pas attendre pour le premier bloc à la fin, mais attend le deuxième bloc. Mais depuis la file d'attente exécute les blocs dans l'ordre, l'appelant efficacement attend à la fois à la fin.
- Un bloc peut également faire un dispatch_async sur sa propre file d'attente (ajouter d'autres blocs qui sera exécuté au plus tard); dispatch_sync sur la série de la file d'attente ou de la file d'attente principale serait de blocage. Dans cette situation, l'appelant attendre pour le bloc d'origine à la fin, mais pas pour les autres blocs. Rappelez-vous juste: dispatch_sync met le bloc à la fin de la file d'attente, la file d'attente d'exécuter du code jusqu'à ce que le bloc est terminé, et puis dispatch_sync retourne. dispatch_async ajoute juste le bloc à la fin de la file d'attente.
- quels sont les avantages de l'envoi asynchrone/enqueueing si vous avez encore attendre pour que l'exécution complète? Pouvez-vous donner un véritable cas d'utilisation pour série de file d'attente + async et file série + sync?
- Un autre comportement importants à considérer dans dispatch_sync, et dispatch_async sur la série des files d'attente est imbriqué comportement asynchrone de l'intérieur. Par exemple, si vous appelez une méthode asynchrone à partir d'un dispatch_sync ou dispatch_async sur une série de file d'attente, comment l'exécution sera transférée.
- Je vous remercie beaucoup. Son travail comme un charme. Créé une demande d'extraction de la source de la gousse. le dernier problème était celui-ci: github.com/mickeyl/LTSupportAutomotive/pull/26/commits/... Merci à vous 🙂
InformationsquelleAutor Dave DeLong
5

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

i) de Série de la file d'attente, envoi asynchrone : Ici, les tâches exécuter l'un après l'autre, mais le thread principal(effet sur l'INTERFACE utilisateur) ne sera pas attendre pour revenir

ii) de Série de la file d'attente, envoi de synchronisation: Ici, les tâches exécuter l'un après l'autre, mais le thread principal(effet sur l'INTERFACE utilisateur) afficher un décalage

iii) Simultanées de la file d'attente, envoi asynchrone : Ici, les tâches s'exécutent en parallèle et le thread principal(effet sur l'INTERFACE utilisateur ) ne sera pas attendre pour le retour et sera lisse.

iv) Simultanées de la file d'attente, envoi de synchronisation : Ici, les tâches s'exécutent en parallèle, mais le thread principal(effet sur l'INTERFACE utilisateur) afficher un décalage

De votre choix en parallèle ou en série de la file d'attente dépend de si vous avez besoin d'une sortie à partir d'une tâche précédente pour le prochain. Si vous dépendez de la tâche précédente, adopter le numéro de série de la file d'attente d'autre prendre simultanées de la file d'attente.

Et enfin c'est une façon de pénétrer au thread principal lorsque nous avons terminé avec notre entreprise :
```
DispatchQueue.main.async {
     //Do something here
}
```
InformationsquelleAutor rd_

Vous devez vous connecter pour publier un commentaire.