Java FM.book - Pearson France

Préface à l’édition française
Lors de la première édition de ce livre, nous avions écrit que "les processeurs multi-
cœurs commencent à être suffisamment bon marché pour apparaître dans les systèmes
de milieu de gamme". Deux ans plus tard, nous pouvons constater que cette tendance
s’est poursuivie, voire accélérée.
Même les portables et les machines de bureau d’entrée de gamme disposent maintenant
de processeurs multicœurs, tandis que les machines de haut de gamme voient leur
nombre de cœurs grandir chaque année et que les fabricants de CPU ont clairement
indiqué qu’ils s’attendaient à ce que le nombre de cœurs progresse de façon exponen-
tielle au cours des prochaines années. Du coup, il devient difficile de trouver des systèmes
monoprocesseurs.
Cette tendance du matériel pose des problèmes non négligeables aux développeurs logi-
ciels. Il ne suffit plus d’exécuter des programmes existants sur de nouveaux processeurs
pour qu’ils aillent plus vite. La loi de Moore continue de développer plus de transistors
chaque année, mais elle nous offre désormais plus de cœurs que de cœurs plus rapides.
Si nous voulons tirer parti des avantages de la puissance des nouveaux processeurs, nos
programmes doivent être écrits pour supporter les environnements concurrents, ce qui
représente un défi à la fois en termes d’architecture, de programmation et de tests. Le
but de ce livre est de répondre à ces défis en offrant des techniques, des patrons et des
outils pour analyser les programmes concurrents et pour encapsuler la complexité des
interactions concurrentes.
Comprendre la concurrence est devenu plus que jamais nécessaire pour les développeurs
Java.
Brian Goetz
Williston, VT
Janvier 2008
=Java FM.book Page XXI Mardi, 7. avril 2009 7:11 07

Présentation de l’ouvrage
Structure de l’ouvrage
Pour éviter la confusion entre les mécanismes de bas niveau de Java et les politiques de
conception nécessaires, nous présenterons un ensemble de règles simplifié permettant
d’écrire des programmes concurrents. En lisant ces règles, les experts pourront dire :
"Hum, ce n’est pas entièrement vrai : la classe C est thread-safe bien qu’elle viole la
règle R !" Écrire des programmes corrects qui ne respectent pas nos règles est bien sûr
possible, mais à condition de connaître parfaitement les mécanismes de bas niveau du
modèle mémoire de Java, or nous voulons justement que les développeurs puissent
écrire des programmes concurrents sans avoir besoin de maîtriser tous ces détails. Nos
règles simplifiées permettent de produire des programmes concurrents corrects et faciles
à maintenir.
Nous supposons que le lecteur connaît déjà un peu les mécanismes de base de la
programmation concurrente en Java. Programmation concurrente en Java n’est pas une
introduction à la programmation concurrente – pour cela, consultez le chapitre consacré
à ce sujet dans un ouvrage qui fait autorité, comme The Java Programming Language
(Arnold et al., 2005). Ce n’est pas non plus un ouvrage de référence sur la concurrence en
général – pour cela, lisez Concurrent Programming in Java (Lea, 2000). Nous préférons
ici offrir des règles de conceptions pratiques pour aider les développeurs à créer des
classes concurrentes, sûres et efficaces. Lorsque cela sera nécessaire, nous ferons référence
aux sections appropriées de The Java Programming Language, Concurrent Programming
in Java, The Java Language Specification (Gosling et al., 2005) et Effective Java (Bloch,
2001) en utilisant les conventions [JPL n.m], [CPJ n.m], [JLS n.m] et [EJ Item n].
Après l’introduction (Chapitre 1), ce livre est découpé en quatre parties.
Les bases. La première partie (Chapitres 2 à 5) s’intéresse aux concepts fondamentaux de
la concurrence et des threads, ainsi qu’à la façon de composer des classes "thread-safe"1
à partir des composants fournis par la bibliothèque de classes. Une "carte de référence"
résume les règles les plus importantes présentées dans cette partie.
1. N.d.T : Dans ce livre nous garderons certains termes anglais car ils n’ont pas d’équivalents reconnus
en français. C’est le cas de "thread-safe", qui est une propriété indiquant qu’un code a été conçu pour
se comporter correctement lorsqu’on y accède par plusieurs threads simultanément.
=Java FM.book Page XXIII Mardi, 7. avril 2009 7:11 07

XXIV Programmation concurrente en Java
Les Chapitres 2 (Thread safety) et 3 (Partage des objets) présentent les concepts
fondamentaux de cet ouvrage. Quasiment toutes les règles liées aux problèmes de
concurrence, à la construction de classes thread-safe et à la vérification du bon fonc-
tionnement de ces classes sont introduites dans ces deux chapitres. Si vous préférez
la "pratique" à la "théorie", vous pourriez être tenté de passer directement à la
deuxième partie du livre, mais assurez-vous de lire ces chapitres avant d’écrire du
code concurrent !
Le Chapitre 4 (Composition d’objets) explique comment composer des classes
thread-safe pour former des classes thread-safe plus importantes. Le Chapitre 5
(Briques de base) décrit les briques de base de la programmation concurrente – les
collections et les synchronisateurs thread-safe – fournies par les bibliothèques de la
plate-forme.
Structuration des applications parallèles. La deuxième partie (Chapitres 6 à 9) explique
comment utiliser les threads pour améliorer le rendement ou le temps de réponse des
applications concurrentes. Le Chapitre 6 (Exécution des tâches) montre comment iden-
tifier les tâches parallélisables et les exécuter. Le Chapitre 7 (Annulation et arrêt) expli-
que comment demander aux tâches et aux threads de se terminer avant leur échéance
normale ; la façon dont les programmes gèrent l’annulation et la terminaison est souvent
l’un des facteurs permettant de différencier les applications concurrentes vraiment
robustes de celles qui se contentent de fonctionner. Le Chapitre 8 (Pools de threads)
présente quelques-unes des techniques les plus avancées de l’exécution des tâches. Le
Chapitre 9 (Applications graphiques) s’intéresse aux techniques permettant d’améliorer
le temps de réponse des sous-systèmes monothreads.
Vivacité, performances et tests. La troisième partie (Chapitres 10 à 12) s’occupe
de vérifier que les programmes concurrents font bien ce que l’on veut qu’ils fassent,
tout en ayant des performances acceptables. Le Chapitre 10 (Éviter les problèmes de
vivacité) explique comment éviter les problèmes de vivacité qui peuvent empêcher
les programmes d’avancer. Le Chapitre 11 (Performances et adaptabilité) présente
les techniques permettant d’améliorer les performances et l’adaptabilité du code
concurrent. Le Chapitre 12 (Tests des programmes concurrents) décrit les techni-
ques de test du code concurrent, qui permettent de vérifier qu’il est à la fois correct
et performant.
Sujets avancés. La quatrième et dernière partie (Chapitres 13 à 16) présente des sujets
qui n’intéresseront probablement que les développeurs expérimentés : les verrous
explicites, les variables atomiques, les algorithmes non bloquants et le développement
de synchronisateurs personnalisés.
=Java FM.book Page XXIV Mardi, 7. avril 2009 7:11 07

Présentation de l’ouvrage XXV
Exemples de code
Bien que de nombreux concepts généraux exposés dans ce livre s’appliquent aux
versions de Java antérieures à Java 5.0, voire aux environnements non Java, la plupart
des exemples de code (et tout ce qui concerne le modèle mémoire de Java) supposent
que vous utilisiez Java 5.0 ou une version plus récente. En outre, certains exemples
utilisent des fonctionnalités qui ne sont apparues qu’à partir de Java 6.
Les exemples de code ont été résumés afin de réduire leur taille et de mettre en évidence les
parties importantes. Leurs versions complètes, ainsi que d’autres exemples, sont disponi-
bles sur le site web www.pearson.fr, à la page consacrée à ce livre.
Ces exemples sont classés en trois catégories : les "bons", les "moyens" et les "mauvais".
Les bons exemples illustrent les techniques conseillées. Les mauvais sont les exemples
qu’il ne faut surtout pas suivre et sont signalés par l’icône "Mr. Yuk" (cette icône est une
marque déposée de l’hôpital des enfants de Pittsburgh, qui nous a autorisés à l’utiliser),
qui indique qu’il s’agit d’un code "toxique", comme dans le Listing 1. Les exemples
"moyens" illustrent des techniques qui ne sont pas nécessairement mauvaises mais qui
sont fragiles ou peu efficaces ; ils sont signalés par l’icône "Peut mieux faire", comme
dans le Listing 2.
Listing 1 : Mauvaise façon de trier une liste. Ne le faites pas.
public <T extends Comparable<? super T>> void sort(List<T> list) {
// Ne renvoie jamais la mauvaise réponse !
System.exit(0);
}
Vous pourriez vous interroger sur l’intérêt de donner de "mauvais" exemples car,
après tout, un livre ne devrait expliquer que les bonnes méthodes, pas les mauvaises.
Cependant, ces exemples ont deux buts : ils illustrent les pièges classiques et, ce qui
est le plus important, ils montrent comment faire pour vérifier qu’un programme est
thread-safe – et la meilleure méthode consiste à présenter les situations où ce n’est
pas le cas.
Listing 2 : Méthode peu optimale de trier une liste.
public <T extends Comparable<? super T>> void sort(List<T> list) {
for (int i=0; i<1000000; i++)
neRienFaire();
Collections.sort(list);
}
=Java FM.book Page XXV Mardi, 7. avril 2009 7:11 07

XXVI Programmation concurrente en Java
Remerciements
Ce livre est issu du développement du paquetage java.util.concurrent, qui a été créé
par le JSR 166 pour être inclus dans Java 5.0. De nombreuses personnes ont contribué à
ce JSR ; nous remercions tout particulièrement Martin Buchholz pour le travail qu’il a
effectué afin d’intégrer le code au JDK, ainsi que tous les lecteurs de la liste de diffusion
concurrency-interest, qui ont émis des suggestions sur la proposition initiale des API.
Cet ouvrage a été considérablement amélioré par les suggestions et l’aide d’une petite
armée de relecteurs, de conseillers, de majorettes et de critiques en fauteuil. Nous
voudrions remercier Dion Almaer, Tracy Bialik, Cindy Bloch, Martin Buchholz, Paul
Christmann, Cliff Click, Stuart Halloway, David Hovemeyer, Jason Hunter, Michael
Hunter, Jeremy Hylton, Heinz Kabutz, Robert Kuhar, Ramnivas Laddad, Jared Levy,
Nicole Lewis, Victor Luchangco, Jeremy Manson, Paul Martin, Berna Massingill, Michael
Maurer, Ted Neward, Kirk Pepperdine, Bill Pugh, Sam Pullara, Russ Rufer, Bill Scherer,
Jeffrey Siegal, Bruce Tate, Gil Tene, Paul Tyma et les membres du Silicon Valley Patterns
Group, qui, par leurs nombreuses conversations techniques intéressantes, ont contribué
à améliorer ce livre.
Nous remercions tout spécialement Cliff Biffie, Barry Hayes, Dawid Kurzyniec, Angelika
Langer, Doron Rajwan et Bill Venners, qui ont relu l’ensemble du manuscrit en détail,
trouvé des bogues dans les exemples de code et suggéré de nombreuses améliorations.
Merci à Katrina Avery pour son travail d’édition et à Rosemary Simpson, qui a produit
l’index alors que les délais impartis n’étaient pas raisonnables. Merci également à Ami
Dewar pour ses illustrations.
Nous voulons aussi remercier toute l’équipe d’Addison-Wesley, qui nous a aidés à faire
de ce livre une réalité. Ann Sellers a lancé le projet et Greg Doench l’a mené jusqu’à
son terme ; Elizabeth Ryan l’a guidé à travers tout le processus de production.
Merci également aux milliers de développeurs qui ont contribué indirectement à l’exis-
tence des logiciels utilisés pour créer ce livre : TeX, LaTeX, Adobe Acrobat, pic, grap,
Adobe Illustrator, Perl, Apache Ant, IntelliJIDEA, GNU emacs, Subversion, TortoiseSVN
et, bien sûr, la plate-forme Java et les bibliothèques de classes.
=Java FM.book Page XXVI Mardi, 7. avril 2009 7:11 07