Langage de programmation moderne avec abstractions intuitives de programmation simultanée [fermé]

Je suis intéressé par l’apprentissage de la programmation concurrente, en mettant l’accent sur le niveau application / utilisateur (pas la programmation système). Je recherche un langage de programmation moderne de haut niveau offrant des abstractions intuitives pour l'écriture d'applications simultanées. Je veux me concentrer sur les langages qui augmentent la productivité et cachent la complexité de la programmation simultanée.

Pour donner des exemples, je ne considère pas comme une bonne option d’écrire du code multithread en C, C ++ ou Java car mon humble avis est ma productivité est réduite et leur modèle de programmation n’est pas intuitif. D'autre part, les langages qui augmentent la productivité et offrent des abstractions plus intuitives telles que Python et le module de multitraitement, Erlang, Clojure, Scala, etc. seraient de bonnes options.

Que recommanderiez-vous en fonction de votre expérience et pourquoi?

EDIT: Merci à tous pour vos réponses intéressantes. Il est difficile de conclure sans essayer, car il y a beaucoup de bons candidats: Erlang, Clojure, Scala, Groovy et peut-être Haskell. J'ai voté sur la réponse avec les arguments les plus convaincants, mais je vais essayer tous les bons candidats avant de décider lequel choisir :)

Vous devriez certainement regarder Clojure - à mon avis, c'est le meilleur langage moderne pour la programmation multicœur et il est extrêmement productif.

Attributs clés:

• C'est un langage fonctionnel , ce qui est une aubaine pour la concurrence et votre capacité à développer en utilisant des abstractions de niveau supérieur. Il présente des structures de données persistantes totalement immuables et des séquences paresseuses qui seront familières à toute personne ayant une expérience des langages fonctionnels comme Haskell.
• Il propose un tout nouveau système de mémoire logicielle transactionnelle permettant un accès simultané sans verrouillage à un état mutable. Rendre le code sécurisé par la concurrence est souvent aussi simple que de l'envelopper dans un bloc (dosync ....).
• C'est un Lisp - ce qui le rend extrêmement puissant pour la métaprogrammation et la génération de code à base de macros. Cela peut apporter des avantages significatifs en termes de productivité (essai de Paul Graham - "Battre les moyennes")
• Il s’agit d’un langage JVM . Ainsi, non seulement vous avez accès à la vaste gamme de bibliothèques et d’outils de l’écosystème Java, mais vous bénéficiez également des efforts considérables déployés en matière d’ingénierie pour faire de la JVM une plate-forme efficace pour les applications côté serveur simultanées. Sur le plan pratique, cela lui confère un avantage considérable par rapport aux langues qui ne disposent pas de ce type de fondement.
• C'est dynamique - ce qui donne un code très concis et beaucoup de productivité. Notez toutefois que vous pouvez utiliser des indicateurs de type statique facultatifs pour améliorer les performances, si nécessaire.
• Le langage est conçu autour d'abstractions, ce qui est un peu difficile à expliquer, mais le résultat final est que vous obtenez un ensemble de fonctionnalités relativement orthogonales que vous pouvez combiner pour résoudre vos problèmes. Un exemple serait l'abstraction de séquence, qui vous permet d'écrire du code traitant de chaque type d'objet "séquentiel" (ce qui inclut tout: listes, chaînes, tableaux Java, séquences infinies de paresseux, lignes lues dans un fichier, etc.).
• Il y a une grande communauté - utile, perspicace, mais surtout très pragmatique - l'objectif de Clojure est généralement de "faire avancer les choses".

Quelques exemples de mini code avec une inclinaison de concurrence:

;; define and launch a future to execute do-something in another thread
(def a (future (do-something)))

;; wait for the future to finish and print its return value
(println @a)

;; call two functions protected in a single STM transaction
(dosync
  (function-one)
  (function-two))

En particulier, il vaut la peine de regarder une ou plusieurs de ces vidéos:

• http://www.infoq.com/presentations/Value-Identity-State-Rich- Hickey
• http://www.infoq.com/presentations/Are-We-There-Yet-Rich- Hickey
• http://www.infoq.com/presentations/Clojure-The-Art-of-Abstraction

Vous pouvez essayer D. Il propose trois modèles. Je recommande soit le premier ou le second.

1. std.concurrency . Si vous utilisez ce module pour tous vos besoins en simultanéité, une combinaison du langage et de la bibliothèque standard impose l'isolation entre les threads. Les threads communiquent principalement par le biais du passage de messages, avec une prise en charge limitée de la mémoire partagée de manière à favoriser la "sécurité d'abord" et à interdire les courses de données de bas niveau. Malheureusement, la documentation de std.concurrency doit être améliorée, mais le modèle est documenté dans un chapitre gratuit du livre de Andrei Alexandrescu, "The D Programming Language".

2. std.parallélisme . Ce module est conçu spécifiquement pour le parallélisme multicœur plutôt que pour la simultanéité en cas général. (La simultanéité et le parallélisme ne sont pas la même chose, bien que la simultanéité soit nécessaire pour mettre en œuvre le parallélisme. ) Puisque le parallélisme est synonyme de performance, std.parallelism ne fournit aucune garantie d'isolement car il rendrait difficile l'écriture de code parallèle efficace. Cependant, il élimine de nombreux détails de bas niveau sources d'erreurs, de sorte qu'il est très difficile de s'y tromper si vous parallélisez des charges de travail que vous avez vérifiées manuellement sont mutuellement indépendantes.

3. core.thread est un wrapper de bas niveau sur les API de threading spécifiques à un système d'exploitation. Std.concurrency et std.parallelism l'utilisent sous le capot, mais je vous recommande de ne l'utiliser que si vous écrivez votre propre bibliothèque de concurrence ou que vous trouvez un cas ridicule qui ne peut pas être fait correctement, que ce soit std.parallelism ou std. .concurrency. Personne ne devrait utiliser quelque chose d'aussi bas niveau pour le travail quotidien.

Erlang est certainement une excellente option, mais Go , la nouvelle langue de Google, pourrait être un peu plus pratique .

Ce n'est pas si loin des autres langues communes, il est donc généralement facile à obtenir si vous connaissez déjà d'autres langues «faciles». Beaucoup de gens le comparent à Python ou même à Lua pour ce qui est du niveau de confort de programmation.

Jetez un coup d'œil à la programmation parallèle de Microsoft pour .net. C'est très intuitif.

De nombreux ordinateurs personnels et stations de travail ont deux ou quatre cœurs (c’est-à-dire des processeurs) qui permettent l’exécution simultanée de plusieurs threads. Dans un avenir proche, les ordinateurs devraient avoir beaucoup plus de cœurs. Pour tirer parti du matériel d'aujourd'hui et de demain, vous pouvez paralléliser votre code afin de répartir le travail entre plusieurs processeurs. Dans le passé, la parallélisation nécessitait une manipulation à bas niveau des threads et des verrous. Visual Studio 2010 et .NET Framework 4 améliorent la prise en charge de la programmation parallèle en fournissant un nouveau runtime, de nouveaux types de bibliothèques de classes et de nouveaux outils de diagnostic. Ces fonctionnalités simplifient le développement en parallèle de sorte que vous puissiez écrire du code parallèle efficace, à grain fin et évolutif dans un idiome naturel sans avoir à travailler directement avec les threads ou le pool de threads.

Erlang et Scala ont tous les deux une concurrence basée sur les acteurs , ce que j'ai trouvé très intuitif et facile à apprendre.

Le modèle d'acteur en informatique est un modèle mathématique de calcul simultané qui traite les "acteurs" comme les primitives universelles du calcul numérique concomitant: en réponse à un message qu'il reçoit, un acteur peut prendre des décisions locales, créer plus d'acteurs, envoyer plus de messages , et déterminer comment répondre au prochain message reçu ... Il a été utilisé à la fois comme cadre pour une compréhension théorique du calcul et comme base théorique pour plusieurs implémentations pratiques de systèmes concurrents.

J'apprends tout sur Haskell et la lecture de cet article m'a convaincu que Haskell est une bonne option pour la programmation simultanée. Parce qu'il est purement fonctionnel (le système de types sait si une fonction effectue une entrée, une sortie ou une lecture / modification d'état global), il peut faire des choses comme la mémoire transactionnelle logicielle (très bien résumée dans l'article ci-dessus) qui se comporte de la même manière que les transactions. dans les bases de données - vous obtenez un tas de choses intéressantes comme atomicity avec seulement un peu de sucre supplémentaire. Autant que je sache, les fils Haskell sont également très légers. Outre ces fonctionnalités, le fait que Haskell soit purement fonctionnel permet d'exécuter des tâches même simples en parallèle avec à peine plus d'un mot-clé (par). la source

Le langage GO de Google propose des outils intéressants pour l'accès simultané. Ce serait une autre chose amusante à essayer. Voir: http://golang.org/doc/effective_go.html#concurrency et en lire un peu pour des exemples.

La programmation simultanée est un sujet important et ne laisse de la place que pour certains faits saillants de Go.

La programmation simultanée dans de nombreux environnements est rendue difficile par les subtilités requises pour implémenter un accès correct aux variables partagées. Go encourage une approche différente dans laquelle les valeurs partagées sont transmises sur les canaux et, en fait, jamais activement partagées par des threads d'exécution distincts. Un seul goroutine a accès à la valeur à un moment donné. Les courses de données ne peuvent pas se produire, par conception. Pour encourager cette façon de penser, nous l’avons réduite à un slogan:

Ne communiquez pas en partageant la mémoire; au lieu de cela, partagez la mémoire en communiquant.

Cette approche peut être prise trop loin. Les comptes de référence peuvent être mieux réalisés en plaçant un mutex autour d'une variable entière, par exemple. Mais en tant qu'approche de haut niveau, l'utilisation de canaux pour contrôler l'accès facilite la rédaction de programmes clairs et corrects.

Une façon de penser à ce modèle est de considérer un programme typique à un seul thread s'exécutant sur un processeur. Il n'a pas besoin de primitives de synchronisation. Maintenant, lancez un autre exemple. il n'a pas non plus besoin de synchronisation. Maintenant, laissez ces deux communiquer. si la communication est le synchroniseur, il n'y a toujours pas besoin d'une autre synchronisation. Les pipelines Unix, par exemple, correspondent parfaitement à ce modèle. Bien que l'approche de Go en matière de simultanéité trouve son origine dans les processus de communication séquentielle (CSP) de Hoare, elle peut également être considérée comme une généralisation des types de tuyaux Unix ...

Dans la prochaine version, C # le rend encore plus facile que ce que montre le diagramme. Il y a deux nouveaux mots-clés Async et Await.

Async est utilisé comme modificateur de fonction et dit "cette opération effectue son travail sur un autre thread.

Await est utilisé dans une fonction Async, et c'est là que la magie se produit. En principe, Await indique au compilateur d'exécuter l'opération en suivant le mot clé dans un thread séparé et d'attendre les résultats. N'importe quel code après l'appel en attente est exécuté après l'opération.

AUSSI, l'opération se synchronise sur le thread appelant (ainsi, si vous effectuez une opération asynchrone en réponse à un clic de bouton, vous n'avez pas besoin de poster manuellement sur le thread d'interface utilisateur). Deux petits mots-clés et vous obtenez beaucoup de pouvoir d'accès simultané. Lire la suite ici

Je recommanderais toujours le C ++. Il est plus que capable des abstractions nécessaires pour écrire du code concurrent décent. La probabilité écrasante est que vous disposiez simplement d'une médiocre bibliothèque pour effectuer le travail, car les bonnes bibliothèques pour effectuer le travail sont relativement nouvelles et, de fait, les connaissances relatives à l'utilisation de C ++ ne sont pas tout à fait communes. Le TBB d’Intel n’existe que depuis quelques années et le PPL de Microsoft n’est disponible que depuis l’année dernière.

Si vous utilisez quelque chose comme TBB ou PPL, le code simultané n'est, en fait, pas tout à fait trivial à écrire, dans la mesure où la simultanéité n'est jamais triviale, mais loin d'être ardue. Si vous utilisez directement pthreads ou les threads Win32, il n’est pas étonnant que vous n’aimiez pas ça, vous écrivez pratiquement en assembleur avec de telles fonctions. Mais avec la PPL, vous parlez d'algorithmes fonctionnels standard parallélisés pour vous, de structures de données génériques pour un accès simultané, etc.

Un plug pour Ada est nécessaire ici, car il contient toutes les abstractions de niveau supérieur pour le parallélisme et la simultanéité. autrement connu sous le nom de tâche . En outre, OP ayant demandé intuitif (critère subjectif!), Je pense qu'une approche différente du monde centré sur Java pourrait être appréciée.

Je suggérerais Groovy / Java / GPars si vous pouvez utiliser une machine virtuelle Java, car elle permet aux acteurs, aux flux de données, aux processus de communication séquentiels (CSP), au parallélisme des données, à la mémoire logicielle transactionnelle (STM), aux agents, ... Il existe de nombreux modèles de concurrence et de parallélisme de haut niveau, chacun ayant ses «points faibles» différents. Vous ne voulez pas utiliser un modèle qui ne correspond pas à la solution d'un problème que vous essayez de construire. Les langages et les frameworks avec un seul modèle vous obligent à pirater des algorithmes.

Bien sûr, je pourrais être perçu comme partial, car je contribue à Groovy et à GPars. Par contre, je travaille avec CSP et Python, cf. Python-CSP.

Un autre point est que la question initiale concerne l'apprentissage, pas l'écriture d'un système de production. Ainsi, la combinaison Groovy / Java / GPars est un bon moyen d’apprentissage, même si le travail de production éventuel est effectué en C ++ en utilisant quelque chose comme Just :: Thread Pro ou TBB plutôt qu’en étant basé sur la JVM.

(Certains liens URL parfaitement raisonnables ont dû être supprimés en raison de la panique suscitée par le spamming par le site hôte.)

Qu'en est-il de Clojure? Vous pouvez utiliser Swing par exemple, mais en profitant de la fonction de programmation simultanée Clojure? Clojure a une très bonne intégration Java.

Aussi, avez-vous envisagé Java 7 Fork / Join framework ?

Vous voudrez peut-être aussi consulter Groovy et la bibliothèque GPars . GPars BTW est quelque peu similaire à .NET Parallel Extension mentionné dans une autre réponse, mais la syntaxe flexible de Groovys permet une meilleure lecture dans certaines circonstances.

Scala a été mentionné à plusieurs reprises dans les questions et les réponses, mais je n'ai vu aucune référence à Akka, qui est une implémentation d'acteur pouvant être utilisée à la fois avec Scala et Java.

Je pense que cela dépend de ce que vous construisez. Des applications de bureau ou un serveur? J'ai entendu dire que node.js (mais que je n'ai pas d'expérience personnelle) est excellent pour la programmation simultanée de serveurs (à la fois en termes d'écriture de code et de performances). Si je voulais écrire une nouvelle application serveur, je le ferais probablement. Pas sûr des applications de bureau ... J'ai écrit pas mal de choses en C # et certains outils cachent bien la complexité, bien que dans d'autres cas, vous devez vous en occuper de front.

Je peux me faire mal à la tête, mais avez-vous lu le chapitre 7 de TAOUP ? La section à laquelle je pense en particulier concerne les threads par rapport aux processus. J'ai constaté que le concept de traitement simultané faisait penser la plupart des gens aux threads, mais je n'ai jamais vu de cas où un thread est plus facile et plus rapide à utiliser que de générer un processus enfant.

Vous communiquez tous les détails de la gestion de la concurrence aux personnes intelligentes qui ont créé votre système d'exploitation. Il existe déjà de nombreuses méthodes de communication en place et vous n'avez pas à vous soucier du verrouillage des ressources partagées. Fondamentalement, les threads sont un hack d’efficacité, qui relève de la règle de l’optimisation. N'optimisez pas si vous n'avez pas testé la nécessité.

Recherchez une bonne bibliothèque de sous-processus, telle que envoyé pour python . Ou vous pouvez simplement écrire plusieurs programmes séparés en C et écrire un autre programme "maître" pour utiliser fork et pipe pour générer et communiquer avec les sous-processus.