Pourquoi Akka est-il bon pour la concurrence?
Je suis nouveau dans Akka et Acteur Framework - Je suis sûr que je manque quelque chose d'évident, veuillez accepter mes excuses à l'avance.
Je continue à lire que l'un des points principaux pour choisir Akka est la façon dont il gère la concurrence.
Ce n'est pas clair pour moi pourquoi Akka est si spécial; Je comprends qu'il y a beaucoup de petits acteurs très légers et rapides; Cependant, comment cela peut-il m'aider lorsque deux utilisateurs sauvent un formulaire en même temps?
Je n'aurais toujours pas besoin d'une sorte de serrure de concurrence (pessimiste/optimiste/etc.)?
L'un des avantages des modèles de traitement des messages tels que les acteurs et les agents est que les problèmes de concurrence traditionnels (principalement synchronisation de l'État partagé) ne sont plus un problème. L'acteur peut garder l'état privé et le mettre à jour librement sans serrures. Le cadre de l'acteur garantit qu'un seul message est traité à la fois. Avec traitement sérialisé, le code peut être écrit de manière sans verrouillage.
Dans votre exemple d'utilisateurs Sauvegarde d'un formulaire, en supposant que l'acteur conserve une liste de certaines données de chaque formulaire, l'acteur peut mettre à jour la liste sans serrures, car le cadre garantit qu'un seul formulaire sera traité à la fois. Traditionnellement, vous devrez verrouiller les accès de la liste ou utiliser une liste simultanée.
La stratégie de simultanément est une question légèrement différente et reste votre responsabilité (sans stratégie la plus courante). Pour changer votre exemple légèrement, disons que les deux utilisateurs essaient de mettre à jour la même instance de formulaire en même temps. Sans stratégie de concurrence, ses changements écraseront l'autre (probablement le dernier victoire). C'est bien, mais au mieux, cela se traduit par un comportement inattendu pour l'utilisateur dont les modifications ont été écrasées. S'ils voient le formulaire, ils ont juste changé, il aura des valeurs inattendues (de l'autre utilisateur). Au pire (lorsque nous ne parlons pas simplement de formulaires de mises à jour, mais des choses comme des commandes d'expédition) Cela pourrait entraîner des pertes de divers types (temps, revenus, etc.).
L'utilisation d'une stratégie de simultanément contribue à identifier ces cas et à pouvoir les résoudre en fonction des règles d'entreprise. Par exemple, la simultanéité optimiste a l'utilisateur d'envoyer la version du formulaire mise à jour. Lorsque l'acteur va traiter le changement, il remarque que le 2e utilisateur pense qu'il met à jour la version 5 lorsque le formulaire est en réalité à la version 6 en raison de la mise à jour du premier utilisateur. Désormais au moins, nous pouvons informer le 2e utilisateur que le formulaire a déjà changé depuis qu'ils ont commencé à le modifier. Ou quelles que soient les règles que l'entreprise veut appliquer là-bas.
Dans le cas de la mise à jour d'une forme, vous ne vous souciez probablement pas autant de concurrence (dépend, je suppose). Mais dans d'autres cas, il peut être une chose très importante d'être au moins en mesure de vérifier et de gérer les violations. Vous voudrez peut-être même ignorer la violation de la concurrence, comme si les utilisateurs ont changé différentes sections (pour continuer la forme analogie). Ou si la modification a un impact important sur l'entreprise (une grosse commande), vous souhaitez l'accepter et résoudre des conflits mineurs plus tard (par exemple, la mise à jour des informations de contact annuel n'a pas été complétée).
Je crois que Akka a un certain nombre d'autres dimensions, telles que la manière dont il gère les défaillances, les superviseurs, etc. qui sont des considérations importantes pour Devops.
Je vais écrire sur le modèle de l'acteur en général (pas seulement Akka) par rapport aux autres modèles de concurrence, tels que la simultanéité classique à verrouillage et la mémoire transactionnelle nette.
Avantages
Concept plus facile pour comprendre et utiliser
La concurrence à verrouillage est difficile; En particulier, il est très difficile de le faire comprendre car il existe de nombreux concepts à comprendre et à utiliser pour être corrects et efficaces: serrures, sémaphores, threads, synchronisation, exclusion mutuelle, barrière de mémoire, etc.
Les acteurs, d'autre part, sont un concept plus abstrait; Vous avez des acteurs qui envoient et reçoivent des messages. Pas besoin de saisir et d'utiliser des concepts de bas niveau tels que la barrière mémoire.
Applique l'immuabilité
- L'utabilité est une source de nombreuses erreurs et bugs dans la programmation, en particulier dans les applications multi-threadées. Le modèle Acteur résout ce problème en appliquant l'immuabilité.
Moins d'erreur sujette
- À cause des deux raisons ci-dessus
Efficace
- Pas si efficace en tant que bon verrouillage écrit, mais en général plus efficace que la mémoire transactionnelle logicielle.
Facilement évolutif
- Théoriquement au moins, l'application devrait être assez bien évolue en ajoutant davantage d'acteurs pour effectuer vos emplois. Avec le verrouillage est assez difficile à échelle.
Inconvénients
Toutes les langues n'appliquent pas facilement l'immutabilité;
- Erlang, la langue que les premiers acteurs popularisés a une immuabilité à son noyau mais Java et Scala (en réalité la JVM) n'applicit pas l'immuabilité.
Toujours assez complexe
- Les acteurs sont basés sur un modèle asynchrone de programmation qui n'est pas si simple et facile à modéliser dans tous les scénarios; Il est particulièrement difficile de gérer les erreurs et les scénarios de défaillance.
N'empêche pas l'impasse ou la faim
- Deux acteurs peuvent être dans l'état qui attendent un message un des autres; Ainsi, vous avez une impasse comme avec des serrures, bien que beaucoup plus facile à déboguer. Avec une mémoire transactionnelle, vous êtes garanti GRATUITEMENT.
Pas si efficace
- En raison de l'immutabilité appliquée et parce que de nombreux acteurs doivent changer d'utilisation des mêmes acteurs du thread ne seront pas aussi efficaces que la simultanéité basée sur le verrouillage.
Conclusion
La simultanéité basée sur le verrouillage est la plus efficace, mais elle est difficile à programmer et à ériger. La mémoire transactionnelle logicielle est le sujet le plus clair, facile à programmer et moins d'erreur, mais c'est aussi le moins efficace. Les acteurs sont quelque part entre ces deux modèles avec tous les aspects: facilitant la programmation, l'efficacité et la préjublisation des erreurs.