Accueil › Java › Synchroniser correctement
Synchroniser correctement
La concurrenceintermediaire
synchronized garantit qu'un seul thread à la fois exécute le code protégé par le même verrou (le moniteur associé à un objet). Il est réentrant : un thread qui détient déjà le verrou peut le reprendre (appel récursif, appel d'une autre méthode synchronisée sur le même objet) sans se bloquer.
class Compteur {
private int valeur = 0;
public synchronized void incrementer() { valeur++; } // verrou sur this
public synchronized int lire() { return valeur; } // même verrou : cohérent
}
volatile garantit la visibilité d'un champ entre threads (et un ordre via happens-before), mais pas l'atomicité : volatile int x; x++; reste une opération en trois étapes, tout aussi cassable qu'avant. Pour un compteur partagé, les classes atomiques (AtomicInteger, LongAdder) offrent des opérations réellement atomiques sans verrou explicite, via compareAndSet.
ReentrantLock (et son cousin ReadWriteLock) offre plus de contrôle que synchronized : tryLock() avec délai, verrou équitable, interruption possible en attente — au prix de devoir gérer soi-même la libération, toujours dans un finally.
Le risque à connaître : l'interblocage (deadlock), quand deux threads attendent chacun un verrou que l'autre détient. La meilleure parade reste souvent d'éviter le partage mutable : préférer des objets immuables ou confinés à un seul thread plutôt que d'ajouter des verrous.
Les termes à connaître
- synchronized
Mot-clé qui garantit l'exclusion mutuelle : un seul thread à la fois peut exécuter un bloc protégé par le même verrou (moniteur). Applicable à une méthode entière (verrou sur
this, ou sur la classe pour une méthode statique) ou à un bloc explicite (synchronized (objet) { ... }). Le verrou est réentrant : un thread qui le détient déjà peut le reprendre sans se bloquer lui-même.- volatile
Modificateur de champ qui garantit la visibilité immédiate des écritures entre threads et empêche certains réordonnancements autour du champ (via une relation happens-before entre écriture et lecture). Il ne rend pas atomique une opération composée comme
x++: il ne remplace passynchronizedni les classes atomiques pour ça.- AtomicInteger / compareAndSet
AtomicInteger,AtomicLong,AtomicReference… offrent des opérations atomiques sans verrou explicite, basées sur l'instruction processeur CAS (compare-and-swap) :compareAndSet(attendu, nouveau)ne remplace la valeur que si elle vaut encoreattendu, et renvoie un booléen.LongAdderrépartit les compteurs sur plusieurs cases internes pour réduire la contention sous forte charge, au prix d'une lecture (sum()) un peu plus coûteuse.- ReentrantLock
Implémentation explicite de
Lock(packagejava.util.concurrent.locks), plus flexible quesynchronized: verrouillage interruptible,tryLock()avec délai pour éviter un blocage indéfini, verrou équitable en option (FIFO), et une ou plusieursConditionassociées pour unwait/notifyplus précis. Doit toujours être libéré dans un blocfinally.- ReadWriteLock
Verrou qui distingue lectures et écritures : plusieurs threads peuvent détenir simultanément le verrou de lecture tant qu'aucun thread ne détient le verrou d'écriture (exclusif). Utile quand les lectures sont très majoritaires face aux écritures.
- Interblocage (deadlock)
Blocage définitif où deux threads (ou plus) attendent chacun un verrou détenu par l'autre, sans qu'aucun ne puisse jamais avancer. Se prévient en acquérant les verrous toujours dans le même ordre, ou en utilisant
tryLock()avec un délai pour abandonner et réessayer plutôt que d'attendre indéfiniment.
Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.