Quelle est la différence entre les appels asynchrones et les rappels
Je suis un peu confus de comprendre la différence entre appels asynchrones _ et rappels.
J'ai lu ces articles qui enseignent sur les CallBacks mais aucune des réponses ne traite en quoi cela diffère des appels asynchrones.
S'agit-il de rappels = expressions lambda?
Les callbacks s'exécutent dans un autre thread?
Quelqu'un peut-il expliquer cela avec un anglais simple et clair?
Très simplement, un rappel ne doit pas nécessairement être asynchrone.
http://docs.apigee.com/api-baas/asynchronous-vs-synchronous-calls
Synchrone:
Si un appel d'API est synchrone, cela signifie que l'exécution du code sera bloquer (ou attendre) le retour de l'appel API avant de continuer. Ce signifie que, jusqu'à ce qu'une réponse soit renvoyée par l'API, votre application n'exécutera plus, ce qui pourrait être perçu par l'utilisateur comme latence ou retard de performance dans votre application. Passer un appel API De manière synchrone peut être bénéfique, cependant, s'il y a du code dans votre application cela ne fonctionnera correctement qu'une fois la réponse de l'API reçue.
Asynchrone:
Les appels asynchrones ne bloquent pas (ni n'attendent) le renvoi de l'appel API du serveur. L'exécution continue dans votre programme et quand le L'appel revient du serveur, une fonction "callback" est exécutée.
En Java, C et C #, les "rappels" sont généralement synchrones (par rapport à une "boucle d'événement principale").
En revanche, en Javascript, les rappels sont asynchrones - vous transmettez une fonction qui sera appelée ... mais d'autres événements continueront d'être traités jusqu'à ce que le rappel soit appelé.
Si vous ne vous souciez pas de savoir quels événements Javascript se produisent dans quel ordre - génial. Sinon, un mécanisme très puissant pour la gestion du comportement asynchrone en Javascript consiste à utiliser des "promesses":
http://www.html5rocks.com/en/tutorials/es6/promises/
PS: Pour répondre à vos questions supplémentaires:
Oui, un rappel peut être un lambda - mais ce n'est pas une obligation.
En Javascript, à peu près tous les rappels seront une "fonction anonyme" (essentiellement une "expression lambda").
Oui, les rappels peuvent être appelés à partir d'un autre thread - mais ce n'est certainement pas une obligation.
Les callbacks peuvent aussi (et font souvent) spawn un thread (se rendant ainsi "asynchrones").
'J'espère que cela pourra aider
=============================================== ===================
Re-bonjour:
Q: @ paulsm4 pouvez-vous s'il vous plaît élaborer avec un exemple comment le rappel et appel asynchrone fonctionne dans le flux d'exécution? Ce sera très utile
Nous devons d’abord nous mettre d’accord sur une définition du "rappel". En voici un bon:
https://en.wikipedia.org/wiki/Callback_%28computer_programming%29
En programmation informatique, un callback est un morceau de code exécutable que est passé en tant qu'argument à un autre code, qui est appelé à rappeler (exécutez) l'argument à un moment opportun. L'invocation peut être immédiat comme dans un rappel synchrone, ou cela pourrait se produire ultérieurement comme dans un rappel asynchrone.
Nous devons également définir "synchrone" et "asynchrone". Fondamentalement - si un rappel fait tout son travail avant de retourner à l'appelant, c'est "synchrone". S'il peut retourner à l'appelant immédiatement après son appel (et l'appelant et le rappel peuvent travailler en parallèle), alors c'est "asynchrone".
Le problème avec les rappels synchrones est qu'ils peuvent sembler "se bloquer". Le problème avec les rappels asynchrones est que vous pouvez perdre le contrôle de "commander" - vous ne pouvez pas nécessairement garantir que "A" se produira avant "B".
Voici des exemples courants de rappels:
a) un bouton permettant d’appuyer sur le bouton (chaque "bouton" différent aura une "réponse" différente). Celles-ci sont généralement appelées "asynchronousy" (par la boucle d'événement principale de l'interface graphique).
b) une fonction "compare" de tri (une fonction "sort ()" commune peut gérer différents types de données). Celles-ci sont généralement appelées "de manière synchrone" (appelées directement par votre programme).
Un exemple concret:
a) J'ai un programme en langage "C" avec une fonction "print ()".
b) "print ()" est conçu pour utiliser l'un des trois rappels suivants: "PrintHP ()", "PrintCanon ()" et "PrintPDF ()".
c) "PrintPDF ()" appelle une bibliothèque pour restituer mes données au format PDF. C'est synchrone - le programme ne retourne pas de "print ()" jusqu'à ce que le rendu .pdf soit terminé. Cela va généralement assez vite, donc il n'y a pas de problème.
d) J'ai codé "PrintHP ()" et "PrintCanon ()" pour générer des threads qui effectuent les E/S sur l'imprimante physique. "Print ()" se termine dès que le fil est créé; l'impression proprement dite se poursuit parallèlement à l'exécution du programme. Ces deux callbacks sont "asynchrones".
Q: avoir un sens? Est ce que ça aide?
Ils sont assez similaires mais c'est juste mho.
Lorsque vous utilisez des rappels, vous spécifiez la méthode à utiliser et les méthodes que vous appelez pour vous rappeler. Vous pouvez spécifier que votre appel doit se terminer n'importe où et vous n'êtes pas assuré d'être rappelé.
En programmation asynchrone, la pile d'appels doit se dérouler à la position de départ, tout comme en programmation synchrone normale.
Avertissement: je pense spécifiquement à la fonctionnalité d’attente C #, car il existe d’autres techniques asynchrones.