Suivant en concurrence

Depuis un an, je travaille beaucoup sur la concurrence en Java et j'ai construit et travaillé sur de nombreux packages simultanés. Donc, en termes de développement dans le monde simultané, je suis assez confiant. De plus, je suis très intéressé à en apprendre et à mieux comprendre la programmation simultanée.

Mais je ne peux pas me répondre quoi ensuite? Quel supplément devrais-je apprendre ou travailler pour hériter de plus de compétences liées au traitement multicœur. S'il y a un bon livre (lu et apprécié «simultanéité en pratique» et «programmation simultanée en java») ou des ressources liées au traitement multicœur pour que je puisse passer au niveau suivant?

Avis de non-responsabilité - Je ne suis pas un expert de la concurrence, mais mon co-auteur l'est, je le perroquet :-)

Puisque vous avez lu les livres de Doug Lea et Brian Goetz, vous avez certainement couvert le meilleur matériel à ce jour.

À l'avenir, il y a les nouvelles améliorations de concurrence dans Java 7. Plus particulièrement le framework Fork / Join et les nouvelles API NIO asynchrones.

Java 8 introduira de nouvelles améliorations de concurrence avec les collections lambdas / parallèles.

Une autre chose à considérer sérieusement est des moyens alternatifs de traiter la concurrence. Pour être franc, l'approche de «verrouillage des objets mutables» de Java sera toujours sujette aux erreurs, quelle que soit l'amélioration des API. Je recommande donc de regarder le modèle d'acteur de Scala et le STM de Clojure comme moyens alternatifs de traiter les problèmes de concurrence tout en maintenant l'interopérabilité avec Java.

[avertissement -> auto-publicité] Je recommanderai donc naturellement notre prochain livre, The Well-Grounded Java Developer , qui couvre toutes les choses que j'ai mentionnées ci-dessus: -). [/ warning]

De peur que j'oublie, Groovy a également une bibliothèque Gpars hautement recommandée, je ne l'ai pas utilisée personnellement cependant.

Le langage de programmation D fournit deux paradigmes pour la programmation simultanée, qui ont tous deux leurs utilisations et sont plutôt intéressants.

std.concurrency fournit le passage de message sans partage de mémoire par défaut. Toutes les variables globales et statiques dans D sont thread-local par défaut spawnet sendn'autorisent pas l'envoi de messages contenant une indirection de pointeur mutable. Un partage limité peut être obtenu via le sharedmot - clé, ce qui implique une vérification supplémentaire par le système de type. En dehors du dialecte sûr du langage, vous pouvez forcer les variables globales / partagées classiques de style C / Java en utilisant le __gsharedmot - clé, mais tous les paris sont désactivés en ce qui concerne la sécurité de la course. Ce modèle est détaillé dans un chapitre gratuit du livre d'Andrei Alexandresu "The D Programming Language".

std.parallelism est moins sûr mais à certains égards plus flexible que std.concurrency et est spécifiquement orienté vers les données multicœurs et le parallélisme des tâches pour augmenter le débit de traitement des données plutôt que la concurrence générale. Il comporte une boucle foreach parallèle, des appels de fonction asynchrones, des réductions parallèles, etc. Il fournit des mécanismes pour faciliter l'écriture de code sans danger pour la course, mais cela nécessite encore un certain degré de discipline.

Une discussion plus approfondie sur les deux principaux paradigmes multithreading en D peut être trouvée dans mon récent article sur le sujet.

Je vous suggère fortement d'aller voir Clojure

L'approche de la concurrence est très nouvelle et, à mon avis, une avancée significative par rapport à ce que vous voyez en Java et dans la plupart des autres langages. Quelques points clés:

• L'identité et l'état sont séparés - OOP complète l'identité de l'objet avec son état actuel sous la forme de variables membres mutables. Clojure sépare strictement l'identité (références gérées) et l'état (structures de données immuables) de manière à simplifier considérablement le développement de programmes simultanés fiables.
• Structures de données immuables persistantes - parce que tout est immuable, vous pouvez prendre un instantané des données / état à tout moment et être assuré qu'il ne sera pas muté sous vous. Mais mieux que cela - ce sont des structures de données persistantes qui partagent des données avec les versions précédentes. Par conséquent, les opérations sont beaucoup plus proches de O (1) que de O (n) que vous paieriez pour une stratégie de copie sur écriture pour les données immuables.
• Mémoire transactionnelle logicielle - plutôt que d'utiliser des verrous, vous insérez simplement le code dans un bloc (dosync ...) et ils sont automatiquement exécutés comme une transaction. Aucun risque de blocages et pas besoin de développer des stratégies de verrouillage complexes. C'est une victoire massive, surtout lorsqu'elle est combinée avec les structures de données immuables ci-dessus. En effet, Clojure implémente le contrôle d'accès concurrentiel multi-versions dans sa STM.
• Le paradigme de programmation fonctionnelle est utilisé pour faciliter l'écriture de code simultané fiable. Fondamentalement, si vous prenez une structure de données immuable, exécutez-la via une fonction pure et affichez une structure de données immuable différente, alors votre code est garanti sans danger pour la concurrence.

Je suggère de regarder cette vidéo comme introduction

Jetez un œil au langage Scala, qui étend Java et s'exécute sur la JVM. Il emprunte la notion d '"Acteurs" à Erlang et offre une bonne capacité pour gérer les échecs de concurrence.

Si vous voulez le porter à un tout nouveau niveau, vous voudrez peut-être vous pencher sur la programmation avec CUDA .

Cela vous permet de répartir vos algorithmes sur des centaines de cœurs de traitement sur votre carte graphique plutôt que sur les quelques cœurs principaux du processeur. Il existe même des liaisons de langage qui facilitent apparemment relativement facilement l'accélération de langages de haut niveau comme python en utilisant des techniques GPGPU .

Programmation de la concurrence sur la JVM: Mastering Synchronization, STM et Actors traite de la programmation simultanée dans Scala, Clojure, JRuby et Groovy.
Vous obtiendrez une compréhension assez solide des différentes approches de la concurrence.

Où est ton sourire?