Programmation concurrente en Java
Visitez le site de la version américaine de l'ouvrage :
www.javaconcurrencyinpractice.com
Codes sources Listings (I & II)
Présentation de l'ouvrage
1 Mauvaise façon de trier une liste. Ne le faites pas
2 Méthode peu optimale de trier une liste
1 Introduction
1.1 Générateur de séquence non thread-safe
1.2 Générateur de séquence thread-safe
I Les bases
2 Thread safety
2.1 Une servlet sans état
2.2 Servlet comptant le nombre de requêtes sans la synchronisation nécessaire. Ne le faites pas
2.3 Situation de compétition dans une initialisation paresseuse. Ne le faites pas
2.4 Servlet comptant les requêtes avec AtomicLong
2.5 Servlet tentant de mettre en cache son dernier résultat sans l'atomicité adéquate. Ne le faites pas
2.6 Servlet mettant en cache le dernier résultat, mais avec une très mauvaise concurrence. Ne le faites pas
2.7 Ce code se bloquerait si les verrous internes n'étaient pas réentrants
2.8 Servlet mettant en cache la dernière requête et son résultat
3 Partage des objets
3.1 Partage de données sans synchronisation. Ne le faites pas
3.2 Conteneur non thread-safe pour un entier modifiable
3.3 Conteneur thread-safe pour un entier modifiable
3.4 Compter les moutons
3.5 Publication d'un objet
3.6 L'état modifiable interne à la classe peut s'échapper. Ne le faites pas
3.7 Permet implicitement à la référence this de s'échapper. Ne le faites pas
3.8 Utilisation d'une méthode fabrique pour empêcher la référence this de s'échapper
3.9 Confinement des variables locales, de types primitifs ou de types références
3.10 Utilisation de ThreadLocal pour garantir le confinement au thread
3.11 Classe non modifiable construite à partir d'objets modifiables sous-jacents
3.12 Conteneur non modifiable pour mettre en cache un nombre et ses facteurs
3.13 Mise en cache du dernier résultat à l'aide d'une référence volatile vers un objet conteneur non modifiable
3.14 Publication d'un objet sans synchronisation appropriée. Ne le faites pas
3.15 Classe risquant un problème si elle n'est pas correctement publiée
4 Composition d'objets
4.1 Compteur mono-thread utilisant le patron moniteur de Java
4.2 Utilisation du confinement pour assurer la thread safety
4.3 Protection de l'état à l'aide d'un verrou privé
4.4 Implémentation du gestionnaire de véhicule reposant sur un moniteur
4.5 Classe Point modifiable ressemblant à java.awt.Point
4.6 Classe Point non modifiable utilisée par DelegatingVehicleTracker
4.7 Délégation de la thread safety à un objet ConcurrentHashMap
4.8 Renvoi d'une copie statique de l'ensemble des emplacements au lieu d'une copie "vivante"
4.9 Délégation de la thread à plusieurs variables d'état sous-jacentes
4.10 Classe pour des intervalles numériques, qui ne protège pas suffisamment ses invariants. Ne le faites pas
4.11 Classe point modifiable et thread-safe
4.12 Gestionnaire de véhicule qui publie en toute sécurité son état interne
4.13 Extension de Vector pour disposer d'une méthode ajouter-si-absent
4.14 Tentative non thread-safe d'implémenter ajouter-si-absent. Ne le faites pas
4.15 Implémentation d'ajouter-si-absent avec un verrouillage côté client
4.16 Implémentation d'ajouter-si-absent en utilisant la composition
5 Briques de base
5.1 Actions composées sur un Vector pouvant produire des résultats inattendus
5.2 Actions composées sur Vector utilisant un verrouillage côté client
5.3 Itération pouvant déclencher ArrayIndexOutOfBoundsException
5.4 Itération avec un verrouillage côté client
5.5 Parcours d'un objet List avec un Iterator
5.6 Itération cachée dans la concaténation des chaînes. Ne le faites pas
5.7 Interface ConcurrentMap
5.8 Tâches producteur et consommateur dans une application d'indexation des fichiers
5.9 Lancement de l'indexation
5.10 Restauration de l'état d'interruption afin de ne pas absorber l'interruption
5.11 Utilisation de la classe CountDownLatch pour lancer et stopper des threads et mesurer le temps d'exécution
5.12 Utilisation de FutureTask pour précharger des données dont on aura besoin plus tard
5.13 Coercition d'un objet Throwable non contrôlé en RuntimeException
5.14 Utilisation d'un Semaphore pour borner une collection
5.15 Coordination des calculs avec CyclicBarrier pour une simulation de cellules
5.16 Première tentative de cache, utilisant HashMap et la synchronisation
5.17 Remplacement de HashMap par ConcurrentHashMap
5.18 Enveloppe de mémoïsation utilisant FutureTask
5.19 Implémentation finale de Memoizer
5.20 Servlet de factorisation mettant en cache ses résultats avec Memoizer
II Structuration des applications concurrentes
6 Exécution des tâches
6.1 Serveur web séquentiel
6.2 Serveur web lançant un thread par requête
6.3 Interface Executor
6.4 Serveur web utilisant un pool de threads
6.5 Executor lançant un nouveau thread pour chaque tâche
6.6 Executor exécutant les tâches de façon synchrone dans le thread appelant
6.7 Méthodes de ExecutorService pour le cycle de vie
6.8 Serveur web avec cycle de vie
6.9 Classe illustrant le comportement confus de Timer
6.10 Affichage séquentiel des éléments d'une page
6.11 Interfaces Callable et Future
6.12 Implémentation par défaut de newTaskFor() dans ThreadPoolExecutor (voir source JDK)
6.13 Attente du téléchargement d'image avec Future
6.14 La classe QueueingFuture utilisée par ExecutorCompletionService (voir source JDK)
6.15 Utilisation de CompletionService pour afficher les éléments de la page dès qu'ils sont disponibles
6.16 Récupération d'une publicité dans un délai imparti
6.17 Obtention de tarifs dans un délai imparti
7 Annulation et arrêt
7.1 Utilisation d'un champ volatile pour stocker l'état d'annulation
7.2 Génération de nombres premiers pendant une seconde
7.3 Annulation non fiable pouvant bloquer les producteurs. Ne le faites pas
7.4 Méthodes d'interruption de Thread (montre toutes les méthodes Thread)
7.5 Utilisation d'une interruption pour l’annulation
7.6 Propagation de InterruptedException aux appelants
7.7 Tâche non annulable qui restaure l’interruption avant de se terminer
7.8 Planification d’une interruption sur un thread emprunté. Ne le faites pas
7.9 Interruption d’une tâche dans un thread dédié
7.10 Annulation d’une tâche avec Future
7.11 Encapsulation des annulations non standard dans un thread par redéfinition de interrupt()
7.12 Encapsulation des annulations non standard avec newTaskFor()
7.13 Service de journalisation producteur-consommateur sans support de l’arrêt
7.14 Moyen non fiable d’ajouter l’arrêt au service de journalisation
7.15 Ajout d’une annulation fiable à LogWriter
7.16 Service de journalisation utilisant un ExecutorService
7.17 Arrêt d’un service avec une pilule empoisonnée
7.18 Thread producteur pour IndexingService
7.19 Thread consommateur pour IndexingService
7.20 Utilisation d’un Executor privé dont la durée de vie est limitée à un appel de méthode
7.21 ExecutorService mémorisant les tâches annulées après l’arrêt
7.22 Utilisation de TrackingExecutorService pour mémoriser les tâches non terminées
7.23 Structure typique d’un thread d’un pool de threads
7.24 Interface UncaughtExceptionHandler
7.25 UncaughtExceptionHandler, qui inscrit l’exception dans le journal
7.26 Enregistrement d’un hook d’arrêt pour arrêter le service de journalisation
8 Pools de threads
8.1 Interblocage de tâches dans un Executor monothread. Ne le faites pas
8.2 Constructeur général de ThreadPoolExecutor
8.3 Création d’un pool de threads de taille fixe avec une file bornée et la politique de saturation caller-runs
8.4 Utilisation d’un Semaphore pour ralentir la soumission des tâches
8.5 Interface ThreadFactory
8.6 Fabrique de threads personnalisés
8.7 Classe de base pour les threads personnalisés
8.8 Modification d’un Executor créé avec les méthodes fabriques standard
8.9 Pool de threads étendu par une journalisation et une mesure du temps
8.10 Transformation d’une exécution séquentielle en exécution parallèle
8.11 Transformation d’une récursion terminale séquentielle en récursion parallèle
8.12 Attente des résultats calculés en parallèle
8.13 Abstraction pour les jeux de type "taquin"
8.14 Nœud pour le framework de résolution des jeux de réflexion
8.15 Résolveur séquentiel d’un puzzle
8.16 Version parallèle du résolveur de puzzle
8.17 Loquet de résultat partiel utilisé par ConcurrentPuzzleSolver
8.18 Résolveur reconnaissant qu’il n’y a pas de solution
9 Applications graphiques
9.1 Implémentation de SwingUtilities à l’aide d’un Executor
9.2 Executor construit au-dessus de SwingUtilities
9.3 Écouteur d’événement simple
9.4 Liaison d’une tâche longue à un composant visuel
9.5 Tâche longue avec effet visuel
9.6 Annulation d’une tâche longue
9.7 Classe de tâche en arrière-plan supportant l’annulation et la notification de terminaison et de progression
9.8 Utilisation de BackgroundTask pour lancer une tâche longue et annulable
Suite des codes sources Listings des parties III & IV et Codes Annexe annotations