Quelle est la différence entre les appels Asynchrones et les Rappels

Très simplement, un rappel n'a pas besoin d'être asynchrone.

http://docs.apigee.com/api-baas/asynchronous-vs-synchronous-calls

1. Synchrone:

   Si les appels aux API synchrone, cela signifie que l'exécution de code sera
   bloc (ou d'attente) pour l'appel d'API pour retourner avant de continuer. Cette
   signifie que jusqu'à ce qu'une réponse est retournée par l'API, votre application
   n'exécutera pas plus loin, ce qui pourrait être perçu par l'utilisateur comme
   la latence ou la performance de latence dans votre application. Faire un appel d'API
   de façon synchrone peut être bénéfique, toutefois, si le si le code de votre application
   qui ne fera que s'exécuter correctement une fois l'API réponse est reçue.

2. Asynchrone:

   Des appels asynchrones ne pas bloquer (ou d'attente) pour l'appel d'API pour le retour
   à partir du serveur. L'exécution se poursuit dans votre programme, et lorsque la
   retours d'appel à partir du serveur, un "rappel" de la fonction est exécutée.

En Java, C et C#, "rappels" sont généralement synchrones (par rapport à un "main event loop").

En Javascript, d'autre part, des rappels sont généralement asynchrone - vous de passer une fonction qui sera appelé ... mais d'autres événements continueront à être traitées jusqu'à ce que le callback n'est appelé.

Si vous ne vous souciez pas de ce que Javascript événements se produisent dans l'ordre - grand. Sinon, un mécanisme très puissant pour la gestion du comportement asynchrone en Javascript est d'utiliser des "promesses":

http://www.html5rocks.com/en/tutorials/es6/promises/

PS:
Pour répondre à vos autres questions:

1. Oui, un rappel peut être un lambda - mais ce n'est pas une exigence.

   En Javascript, juste au sujet de chaque rappel sera une "fonction anonyme" (en fait un "lambda expression").

2. Oui, rappels, peut être invoqué à partir d'un autre thread, mais c'est certainement pas une exigence.

3. Rappels peuvent aussi (et souvent) frayer un thread (et donc de faire eux-mêmes "asynchrone").

'Espère que ça aide

====================================================================

Salut, Encore Une Fois:

Q: @paulsm4 pouvez-vous veuillez expliquer avec un exemple comment la fonction de rappel
et appel asynchrone fonctionne dans le flux d'exécution? Qui sera
très utile

1. Nous avons besoin d'abord de s'entendre sur une définition de "rappel". Voici une bonne:

   https://en.wikipedia.org/wiki/Callback_%28computer_programming%29

   En programmation informatique, un rappel est un morceau de code exécutable
   est passé comme argument à un autre code, qui est prévu pour le rappel
   (exécuter) l'argument à un certain moment opportun. L'invocation peut être
   immédiat comme dans un synchrone de rappel, ou cela peut se produire plus tard
   temps comme dans une rappel asynchrone.

2. Nous devons également définir "synchrone" et "asynchrone". Bref, si un rappel fait tout le travail avant de retourner à l'appelant, c'est "synchrone". Si l'on peut retourner à l'appelant immédiatement après il est invoqué - et que l'appelant et le rappel peuvent travailler en parallèle, c'est "asynchrone".

3. Le problème avec synchrone rappels, c'est qu'ils peuvent apparaître à "accrocher". Le problème avec les rappels asynchrones est que vous pouvez perdre le contrôle de la "commande" - vous ne pouvez pas garantir que "Un" avant "B".

4. Commune des exemples de rappels comprennent:

   a) d'appuyer sur un bouton gestionnaire (chaque "bouton" est différent de "réaction"). Ce sont généralement invoqués "asynchronousy" (par l'interface graphique de la boucle principale).

   b) une sorte de "comparer" fonction (ainsi, une commune "trier()" fonction peut gérer différents types de données). Ce sont généralement invoqués "synchrone" (appelé directement par votre programme).

5. UN EXEMPLE CONCRET:

   a) j'ai un "C" programme de langue avec un "print()" fonction.

   b) "print()" est conçu pour utiliser l'un des trois rappels: "PrintHP()", "PrintCanon()" et "PrintPDF()".

   c) "PrintPDF()" appelle une bibliothèque pour rendre mes données au format PDF. Il est synchrone, le programme n'a pas de retour en arrière à partir de "print()" jusqu'à ce que l' .pdf le rendu est terminé. Il va généralement assez rapidement, donc il n'y a pas de problème.

   d) j'ai codé "PrintHP()" et "PrintCanon()" pour frayer threads pour faire les e/S de l'imprimante physique. "Print()" quitte dès que le thread est créé; le "impression" va en parallèle avec l'exécution du programme. Ces deux rappels sont "asynchrone".

Q: un sens? Est-ce que c'?

OriginalL'auteur paulsm4