Au cours du dernier an, je travaillais sur Java et Flex. Tout en codant Flex, la plupart de mes pièces de code sont allées pour un tirage au sort depuis son asynchrone. Cela m'a fait penser aux vrais avantages et inconvénients des langues d'exécution synchrones à l'exécution asynchrone.
Quels sont les domaines où ils sont plus forts comparés à d'autres et quelles sont les domaines qu'ils tombent?
3 Réponses :
(laissant de côté la discussion de niveau sémantique I.e. "Synchronisation / langue async")
Un "cadre" construit sur une "langue" (tout ce qu'il est) devrait être en mesure de gérer de tels cas (Sync / ASYNC Difflication de programme) afin d'être utile (lire: $ sage).
Les idiomes asynchrones sont appropriés à chaque échelle.
À grande échelle, les techniques asynchrones aident à créer des systèmes fiables, car le monde réel est de toute façon asynchrone de nature. En d'autres termes, il faut penser à des "pensées asynchrones" pour faire face à des situations réelles telles que les défaillances, les pertes, les retards, etc.
Même sur une échelle plus petite (application par exemple GUI), les événements (tels que "clics de souris") ont tendance à être "asynchrones". Bien sûr, ils sont "sérialisés" à un moment donné (afin d'être traitées par une application qui exécute certains logiciels), mais cela ne change pas le fait que les événements (probablement) ont eu lieu "asynchrone" en ce qui concerne le flux du programme en question.
Vrai si vous pensez que plusieurs cas de test en parallèle. Mais autant que je puisse penser, ils ne feront qu'aider aux cas de test. Dans la vraie vie et tout le "prochain quoi" dépend purement de "ce qui se passe maintenant" ou de cela. Alors, comment peut-on devenir asynchrone devenir une réussite?
@Umesh: Le "Ce qui se passe maintenant" est un "sandbox" créé par des événements "sérialisement" artificiellement. C'est une question de "cadre de référence" (comme nous l'appellerions en physique). Quant à "Comment peut-on devenir asynchrone de devenir une réalisation", je dois dire que je ne te suive pas. Voulez-vous s'il vous plaît veillez à expliquer?
Votre explication m'a fait clairement. S'il vous plaît oublier ma question. Merci
@Umesh: Voulez-vous vraiment que les barres de menus sur votre navigateur Web ne répondent pas lorsque votre navigateur effectue une demande de réseau? Il y a beaucoup d'endroits où les choses peuvent se produire sans connaître le résultat d'un appel aléatoire.
@TLOCH - Je suis d'accord. Mais juste une pensée. Une approche asynchrone résout la question que vous avez posée. Mais pour obtenir des fonctionnalités qui doivent être synchrones, nous faisons des événements et tout dans la langue asynchrone (script Flex / Action). Donc, ma question pour Jidupont était ce qui est le taux d'occurrence pour les événements synchrones par rapport aux événements asynchrones. Signifie dans quelle méthode un langage de programmation doit être basé sur et donner à l'autre une option que vous pouvez implémenter l'utiliser. (Je pense que je suis clair)
Je pense que ce n'est pas sur la langue, mais sur le cadre.
contre-cas au point:
Lorsque vous écrivez des applications «MacOS Mac» (MacOS 9 et avant) dans C (une langue «synchrone» s'il y en avait un), vous n'avez pas de multithreading préemptif, de sorte que tous les appels de système potentiellement bloquants ont une contrepartie asynchratante, où vous remplissez un bloc de données avec des paramètres, y compris une fonction de rappel. Ensuite, vous effectuez l'appel système (qui reviendrait immédiatement) et votre rappel serait appelé de manière asynchrone (dans ce qu'on appelle ce qu'on appelle «niveau d'interruption»). Il n'était pas rare que le rappel ait un autre appel de système ASYNC, créant un long fil de fond qui fonctionnait de manière asynchrone avec le principal.
Cela signifie-t-il vraiment une amélioration de la performance en exécutant des choses parallèles et en utilisant le matériel. Mais quel est le coût d'écoute des rappels du fil parent. Est-ce qu'ils ont meilleur côté?
@Umesh: Vous n'écoutez pas les rappels d'un autre fil, le fil appelle directement le rappel. La surcharge est la même que tout autre appel de fonction.
J'ai passé la majeure partie de la dernière année codant à Silverlight, ce qui signifie que j'ai passé beaucoup de temps à réfléchir à (et à me battre avec) les mêmes problèmes que vous décrivez.
En bref, comme les autres ont souligné, la véritable force du modèle asynchrone est sa capacité à créer des systèmes robustes qui interopèrent bien avec le monde réel. Personne ne pouvait utiliser de manière réaliste une application Silverlight (ou Flash) si le fil de l'interface utilisateur est arrivé à une halte chaque fois qu'il a fallu quelques secondes pour un appel de service Web pour revenir.
Le plus gros inconvénient est que le code résultant est complexe et difficile à dépanner. Des choses comme la manipulation des erreurs sont une pita, mais les trucs les plus gênants que j'ai dû faire face à la coordination des réponses de plusieurs appels asynchrones. Si, dites, vous avez besoin d'informations d'appelez A avant de faire appelez B, et vous avez besoin d'informations de Call B avant de faire appel au C (etc.), le code résultant semble vraiment désagréable et est sensible à toutes sortes d'effets secondaires étranges. . Il existe des techniques pour faire de tout ce travail de choses, et même raisonnablement propre, mais si vous venez du monde synchroneux (comme je l'étais), c'est une courbe d'apprentissage importante. (Et cela n'aide pas que Microsoft pousse des événements comme la manière de gérer les appels de WCF lorsque des rappels, à mon avis, sont beaucoup plus propres et moins sensibles au type d'effets secondaires étranges que je parlais.)
(Et oui, d'autres personnes sont correctes en disant que ce n'est pas la langue qui est aussi asynchrone que ces cadres particuliers nécessitent de construire votre code de manière asynchrone - mais je reçois ce que vous voulez dire.)
Mise à jour 2014.09.23 -
J'ai fait beaucoup plus de travail avec une variété de cadres asynchrones depuis que j'ai écrit la réponse ci-dessus (comme tout le monde a fait n'importe quel codage Web), et j'ai pensé que j'ajouterais quelques notes aléatoires supplémentaires:
Si vous utilisez une langue telle que C # ou F # qui a un soutien asynchrone de première classe, beaucoup de cela plus facilement, au moins, une fois que vous enveloppez votre tête autour du bizarre Si vous n'utilisez pas de langue avec une prise en charge ASYNC de première classe, commencez à utiliser tout ce que Le code asynchrone est essentiel pour la rédaction de systèmes de serveur évolutif. L'un des problèmes les plus importants avec la fabrication d'une échelle de serveur Web typique est qu'il commence à manquer de threads, au moins, il se consacre s'il dédique un fil pour atteindre la demande entrante. Si ce fil stipule, car il attend un appel synchrone à long terme pour terminer, il est totalement indisponible d'aider avec quoi que ce soit d'autre. Beaucoup mieux consiste à rendre votre code serveur Web ASYNC, de sorte que lorsque vous attendez un appel de DB à revenir, ce fil peut aller au service d'une demi-douzaine d'autres demandes pendant que la DB allait et faisait tout ce que fait la DB. À ce stade, pour des systèmes hautement évolutifs, ASYNC est le seul jeu de la ville. (Demandez simplement à n'importe quel noeud AFICIONADO.)
async / attendre motifs. Être capable de boucler facilement autour des appels asynchrones et d'envelopper le tout avec un simple essayer / attraper , est incroyable si vous avez déjà eu à le faire l'ancienne façon.
prometteur ou futur ou tâche Soutien que la langue fournit (par exemple, JQuery's $. Referedred () ou angular's q.defer () . Ceux-ci sont beaucoup plus propres que ce que vous obtenez généralement avec des rappels.
Existe-t-il des pratiques pour la rédaction d'applications dans le cadre d'événement axé sur les événements?
Disons simplement que Lambda Expressions est votre nouveau meilleur ami :-). En dehors de cela, je pense que les schémas et les pratiques varieront en grande partie du cadre au cadre, en fonction des contraintes qu'ils placent sur vous. Par exemple, dans le World Silverlight, j'ai constaté que cela contribue de manière spectaculaire à envelopper le motif piloté par les événements que Microsoft fournit un modèle axé sur le rappel (et je mettez habituellement implémenter le rappel en tant qu'expression Lambda). Cela facilite considérablement la suite de la logique de l'application. Je n'ai pas fait assez de flex pour savoir ce qui est approprié là-bas.
Merci beaucoup pour votre explication monsieur. Je viens aussi de Sync World et j'ai constamment pensé à quel point le code ASYNC est sale. Je vais prendre vos conseils et entrer dans le nœud. Merci!
Comment une langue peut-elle être asynchrone?
@NSD - Ce qu'il veut dire que Flex ne bloque jamais - toutes les opérations pouvant être bloquées sur d'autres plates-formes sont mises en œuvre de manière asynchérale.
Avez-vous une définition pour "Langue d'exécution synchrone"? Ou interprétez simplement simplement la nature axée sur les événements de Flex (qui se trouve également dans presque toutes les autres API de GUI, y compris Java) comme "asynchrone"?
@ KDGregory - Je ne peux pas comprendre pourquoi vous avez simplement changé le mécanisme d'exécution de Flex par le nom d'événement axé sur la nature de Flex. C'est assez difficile pour moi de digérer car c'est la première langue que je joue avec laquelle j'ai ce genre de comportement. D'autres langues comme c et tous attendront que la méthode appelée complète pour aller à la ligne suivante. Mais dans ce que ça ne le fait pas. Mais Flex les exécuter dans des threads qui rend l'exécution plus rapide (je pense). Mais ils ont également des auditeurs d'événements qui ont besoin d'un auditeur continue à courir qui mange des cycles de processeur -am je corrige? Alors, quel est l'avantage?
Je ne pensais pas que Flex était une langue. Je suppose que c'est une région que je tombe.
C peut avoir des méthodes asynchrones, comme cela peut la plupart des langues. Peut-être que vous confondez des langues avec des cadres?
@ Azeem.Butt Wierd Exemple, JavaScript. Forcer style asynchronisé par "thread unique"