Java — Atomic (Thread-safe sans lock)

Les classes Atomic en Java permettent de gérer la concurrence sans utiliser synchronized, avec de meilleures performances.

1. Idée simple

Les classes Atomic permettent :

➡️ des opérations atomiques (indivisibles) ➡️ thread-safe sans lock explicite

2. Exemple classique

AtomicInteger count = new AtomicInteger(0);

count.incrementAndGet();

équivalent à :

count++;

MAIS en version thread-safe

3. Pourquoi c’est important ?

int count = 0;
count++; // ❌ pas thread-safe

problème :

opération en plusieurs étapes
race condition possible

4. Solution avec Atomic

AtomicInteger count = new AtomicInteger(0);

count.incrementAndGet(); // ✔️ thread-safe

5. Classes principales

AtomicInteger
AtomicLong
AtomicBoolean
AtomicReference<T>

6. Méthodes importantes

count.get();               // lire
count.set(10);             // écrire
count.incrementAndGet();   // ++
count.compareAndSet(0, 1); // CAS

7. Compare-And-Set (CAS)

principe :

count.compareAndSet(0, 1);

signifie :

si valeur = 0 → remplace par 1
sinon → ne fait rien
base des algorithmes lock-free

8. Atomic vs synchronized

	Atomic	synchronized
thread-safe	✔️	✔️
lock	❌	✔️
performance	✔️ meilleur	❌ plus lent
usage	simple	complexe

9. Quand utiliser Atomic ?

Bon cas

compteur
flags
opérations simples

Mauvais cas

logique complexe
plusieurs variables dépendantes

Pièges fréquents

croire que tout devient thread-safe
utiliser Atomic pour logique complexe
oublier les conditions de course

10. Questions classiques

Q1

AtomicInteger est thread-safe ? Oui

Q2

utilise des locks ? Non

Q3

basé sur quoi ? CAS (compare-and-set)

11. À retenir

Atomic = opérations atomiques
pas de lock
performant
limité aux cas simples

🧾 En résumé

remplace souvent synchronized pour les cas simples
basé sur CAS
très utilisé en concurrence moderne

Les classes Atomic permettent un code concurrent rapide et sûr sans blocage.