Formations — 1 037 leçons en français

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 pas synchronized ni 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 encore attendu, et renvoie un booléen. LongAdder ré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 (package java.util.concurrent.locks), plus flexible que synchronized : verrouillage interruptible, tryLock() avec délai pour éviter un blocage indéfini, verrou équitable en option (FIFO), et une ou plusieurs Condition associées pour un wait/notify plus précis. Doit toujours être libéré dans un bloc finally.

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.

Lire l'explication détaillée et faire le quiz →

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.