Java — `synchronized` (Gestion de la concurrence)

Le mot-clé synchronized permet de contrôler l’accès concurrent à une ressource afin d’éviter les conflits entre threads.

1. Idée simple

synchronized :

➡️ bloque l’accès concurrent ➡️ garantit qu’un seul thread exécute le code à la fois

2. Méthode synchronisée (instance)

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }
}

ici :

lock sur l’objet courant (this)
un seul thread par instance

3. Bloc synchronisé

synchronized(this) {
    count++;
}

permet de synchroniser uniquement une partie du code

4. Méthode `static synchronized`

class Counter {
    private static int count = 0;

    public static synchronized void increment() {
        count++;
    }
}

ici :

lock sur la classe (Counter.class)
partagé entre toutes les instances

5. Résumé des locks

Type	Lock utilisé
méthode instance	objet (`this`)
bloc `synchronized(this)`	objet (`this`)
méthode static	classe

6. Pourquoi utiliser `synchronized` ?

éviter les race conditions
garantir cohérence des données
sécuriser les accès concurrents

7. Pièges fréquents

lock trop large → performance
oublier le lock → bugs
deadlock possible

8. Limites

blocage (threads attendent)
pas toujours performant
peut créer contention

9. Questions classiques

Q1

synchronized fait quoi ? bloque accès concurrent

Q2

lock instance = ? objet (this)

Q3

lock static = ? classe

Q4

danger principal ? deadlock

10. À retenir

synchronized = exclusivité
instance → lock objet
static → lock classe
attention aux performances

🧾 En résumé

protège les données partagées
évite les conflits entre threads
peut ralentir si mal utilisé

C’est un outil puissant mais à utiliser avec précaution en concurrence.

Java — synchronized (Gestion de la concurrence)