En quoi le système événementiel Node.js est-il différent du modèle d'acteur d'Akka?
J'ai travaillé avec Node.js pendant un petit moment et je me considère plutôt bien avec Java. Mais je viens de découvrir Akka et j'ai été immédiatement intéressé par son modèle d'acteur (d'après ce que je comprends).
Maintenant, en supposant que mes compétences JavaScript étaient à égalité avec mes compétences Scala/Java, je veux me concentrer sur l'aspect pratique de l'un ou l'autre système. Surtout en termes de services Web.
Je croyais comprendre que Node est excellent pour gérer de nombreuses opérations simultanées. J'imagine qu'un bon service Web Node pour un système de gestion des actifs serait excellent pour gérer de nombreux utilisateurs) soumettre des modifications en même temps (dans une application volumineuse et dense).
Mais après avoir lu sur les acteurs d'Akka, il semble que ce serait Excel à la même chose. Et j'aime l'idée de réduire le travail en morceaux de la taille d'une bouchée. De plus, il y a des années, j'ai essayé Erlang et suis tombé amoureux du système de transmission de messages qu'il utilise.
Je travaille sur de nombreuses applications qui traitent d'une logique métier complexe et je pense qu'il est temps de sauter plus lourd dans l'une ou l'autre. Surtout la mise à niveau des anciennes applications Struts et C #.
Quoi qu'il en soit, en évitant les guerres saintes, en quoi les deux systèmes sont-ils fondamentalement différents? Il semble que les deux visent le même objectif. Avec peut-être l'architecture "d'auto-guérison" d'Akka qui a un avantage.
MODIFIER
Il semble que j'obtienne des votes serrés. S'il vous plaît ne prenez pas cette question comme "ce qui est mieux, nœud ou akka?". Ce que je recherche, ce sont les différences fondamentales dans les bibliothèques événementielles comme Node et celles basées sur les acteurs comme Akka.
Sans entrer dans les détails (que je connais trop peu dans le cas de Node.js), la principale différence est que Node.js ne prend en charge que la concurrence sans parallélisme tandis qu'Akka prend en charge les deux. Les deux systèmes sont entièrement pilotés par les événements et peuvent évoluer vers des charges de travail importantes, mais le manque de parallélisme rend les choses difficiles dans Node.js (c'est-à-dire que le parallélisme est explicitement codé en démarrant plusieurs nœuds et en répartissant les demandes en conséquence; il est donc inflexible au moment de l'exécution) , alors qu'il est assez facile dans Akka en raison de ses exécuteurs multithread accordables. Compte tenu de petites unités de travail isolées (invocations d'acteurs), Akka parallélisera automatiquement l'exécution pour vous.
Une autre différence d'importance est qu'Akka inclut un système pour gérer l'échec de manière structurée (en faisant superviser chaque acteur par son parent, ce qui est obligatoire) tandis que Node.js s'appuie sur des conventions pour que les auteurs transmettent les conditions d'erreur d'un rappel à l'autre. Le problème sous-jacent est que les systèmes asynchrones ne peuvent pas utiliser l'approche standard des exceptions employées par les systèmes synchrones basés sur la pile, car le code "appelant" aura migré vers différentes tâches au moment où l'erreur de rappel se produit. Le fait d'avoir intégré la gestion des erreurs dans le système augmente la probabilité que les applications construites sur ce système soient robustes.
Ce qui précède n'est pas censé être exhaustif, je suis sûr qu'il y a beaucoup plus de différences.
Je n'ai pas encore utilisé Akka, mais il semble que ce soit comme erlang mais en Java. Dans erlang, tous les processus sont comme des acteurs dans Akka, ils ont des boîtes aux lettres, vous pouvez envoyer des messages entre eux, vous avez des superviseurs, etc.
Node.js utilise la simultanéité coopérative. Cela signifie que vous disposez de la simultanéité lorsque vous l'autorisez (par exemple lorsque vous appelez l'opération io ou un événement asynchrone). Lorsque vous avez une longue opération (calcul de quelque chose en boucle longue), des blocs système entiers.
Erlang utilise la commutation de tâches préemptive. Lorsque vous avez une longue boucle, le système peut l'interrompre pour exécuter une autre opération et continuer après un certain temps. Pour une concurrence massive, Node.js est bon si vous ne faites que des opérations courtes. Les deux prennent en charge des millions de clients: http://blog.caustik.com/2012/08/19/node-js-w1m-concurrent-connections/http: //blog.whatsapp .com/index.php/2012/01/1-million-is-so-2011 /
Dans Java vous avez besoin de threads pour faire n'importe quelle concurrence, sinon vous ne pouvez pas suspendre l'exécution à l'intérieur de la fonction qu' erlang fait (en fait erlang fait une pause entre les appels de fonction, mais cela se produit avec toutes les fonctions). Vous pouvez mettre en pause exécution entre les messages.
Je ne suis pas sûr que ce soit une comparaison juste à tirer. J'ai lu ceci comme "comment un système basé sur des événements se compare-t-il à un modèle d'acteur?". Nodejs peut prendre en charge un modèle d'acteur comme Scala le fait à Akka, ou C # le fait à Orléans, en fait consultez nactor , quelqu'un semble déjà l'essayer.
Quant à la façon dont un système événementiel et un modèle d'acteur se comparent, je laisserais les gens plus sages le décrire. Quelques brèves remarques sur le modèle Actor:
- Le modèle d'acteur est basé sur un message
- Les modèles d'acteurs tendent à bien fonctionner avec les systèmes distribués (clusters). Bien sûr, les systèmes basés sur les événements peuvent être distribués, mais je pense que le modèle d'acteur a une distribution intégrée en ce qui concerne la distribution des calculs. Une nouvelle demande peut être acheminée vers un nouvel acteur dans un autre silo, vous ne savez pas comment cela fonctionnerait en fonction des événements.
- Le modèle Actor prend en charge l'échec dans la mesure où, si les apperas du cluster 1 sont en panne, l'observateur peut généralement trouver un autre silo pour effectuer le travail.
Consultez également drame . C'est une autre implémentation du modèle d'acteur nodejs.