Clean Code — Chapitre 13 : La Concurrence
Le chapitre 13 explore la concurrence — l'exécution simultanée de plusieurs tâches. Bien que l'original parle de threads Java, les principes s'appliquent parfaitement à JavaScript/TypeScript avec async/await, Promises, et la gestion d'état asynchrone en React.
💡 L'idée clé du chapitre :
"La concurrence est dure. Elle introduit des bugs subtils qui ne se reproduisent pas toujours. La seule défense : isoler le code concurrent, le garder simple, et tester intensivement."
- Isoler la concurrence — Séparer async du sync
- Limiter l'état partagé — Éviter mutations concurrentes
- Race conditions — Détecter et prévenir
- Patterns async — async/await, Promise.all, retry
1. Pourquoi la concurrence ?
La concurrence permet d'améliorer les performances en exécutant plusieurs tâches simultanément. En JavaScript, c'est essentiel pour les appels API, les opérations I/O, et garder l'UI réactive.
2. Les défis de l'asynchrone
La concurrence introduit des problèmes complexes que le code synchrone n'a pas. Voici les 3 principaux défis :
🏁 Race Conditions
Deux opérations asynchrones modifient le même état. Le résultat dépend de qui finit en premier.
Exemple : Deux clics rapides sur "Sauvegarder"
🔒 Deadlocks
Deux tâches attendent l'une l'autre infiniment. Moins fréquent en JS mais possible avec async/await.
Exemple : A attend B qui attend A
🎭 État incohérent
L'UI affiche un état qui ne correspond plus à la réalité car une opération async est encore en cours.
Exemple : Bouton "Loading" qui reste bloqué
Exemple de Race Condition
❌ Race condition
let counter = 0;
async function increment() {
const current = counter;
await delay(100);
counter = current + 1;
}
// Deux appels simultanés
increment();
increment();
// Résultat attendu: 2
// Résultat réel: 1 ⚠️
// Les deux lisent counter=0
✅ Protection avec lock
let counter = 0;
let lock = Promise.resolve();
async function increment() {
// Attendre le lock
await lock;
// Créer nouveau lock
let release: () => void;
lock = new Promise(r => {
release = r;
});
counter++;
release!();
}
// ✅ Résultat garanti: 2
3. Principes de défense
Martin propose 4 principes pour gérer la concurrence proprement :
Application des principes en React
// ✅ PRINCIPE 1 : Isoler dans un hook
function useUsers() {
const [users, setUsers] =
useState<User[]>([]);
const [loading, setLoading] =
useState(false);
useEffect(() => {
setLoading(true);
fetchUsers()
.then(setUsers)
.finally(() =>
setLoading(false)
);
}, []);
return { users, loading };
}
// ✅ PRINCIPE 2 : État local, non partagé
function UserList() {
const { users, loading } =
useUsers();
if (loading) return <Spinner />;
return (
<div>
{users.map(u =>
<UserCard key={u.id} user={u} />
)}
</div>
);
}
// ✅ PRINCIPE 3 : Travailler sur copie
function updateUser(
id: number,
updates: Partial<User>
) {
setUsers(prev =>
prev.map(u =>
u.id === id
? { ...u, ...updates }
: u
)
);
}
4. Patterns async/await essentiels
Voici les patterns les plus utiles pour gérer l'asynchrone proprement en TypeScript.
⚡ Promise.all
Exécuter plusieurs tâches en parallèle et attendre toutes.
const [users, orders] =
await Promise.all([
fetchUsers(),
fetchOrders()
]);
🏁 Promise.race
Prendre le résultat de la première promise qui se termine.
const result =
await Promise.race([
fetchFromAPI(),
timeout(5000)
]);
🔄 Retry avec backoff
Réessayer une opération en cas d'échec avec délai exponentiel.
async function retry<T>(
fn: () => Promise<T>,
maxRetries = 3
): Promise<T> {
for (let i = 0; i < maxRetries; i++) {
try {
return await fn();
} catch (e) {
if (i === maxRetries - 1)
throw e;
await delay(2 ** i * 1000);
}
}
throw new Error("Unreachable");
}
⏰ Timeout
Abandonner une opération si elle prend trop de temps.
function withTimeout<T>(
promise: Promise<T>,
ms: number
): Promise<T> {
return Promise.race([
promise,
new Promise<T>((_, reject) =>
setTimeout(
() => reject(
new Error("Timeout")
),
ms
)
)
]);
}
5. Async en React — Bonnes pratiques
React a ses propres défis avec l'asynchrone : composants qui se démontent pendant un fetch, state updates après unmount, etc.
❌ Memory leak classique
function UserProfile({ id }) {
const [user, setUser] =
useState(null);
useEffect(() => {
fetchUser(id)
.then(setUser);
}, [id]);
return <div>{user?.name}</div>;
}
// ⚠️ Si le composant unmount
// pendant le fetch, setUser()
// est appelé sur composant mort
✅ Avec cleanup
function UserProfile({ id }) {
const [user, setUser] =
useState(null);
useEffect(() => {
let cancelled = false;
fetchUser(id).then(data => {
if (!cancelled) {
setUser(data);
}
});
return () => {
cancelled = true;
};
}, [id]);
return <div>{user?.name}</div>;
}
Pattern : AbortController
Annulation propre avec AbortController
function useUser(id: number) {
const [user, setUser] =
useState<User | null>(null);
const [loading, setLoading] =
useState(true);
const [error, setError] =
useState<Error | null>(null);
useEffect(() => {
const controller =
new AbortController();
setLoading(true);
setError(null);
fetch(`/api/users/${id}`, {
signal: controller.signal
})
.then(r => r.json())
.then(setUser)
.catch(err => {
if (err.name !== 'AbortError') {
setError(err);
}
})
.finally(() =>
setLoading(false)
);
return () => {
controller.abort();
};
}, [id]);
return { user, loading, error };
}
À Retenir — Chapitre 13
- Concurrence = performance mais complexité accrue. Les bugs async sont subtils et difficiles à reproduire.
- Race conditions : Le problème n°1. Survient quand plusieurs opérations async modifient le même état.
- Isoler l'async : Séparer le code asynchrone de la logique métier. En React : hooks custom.
- Limiter l'état partagé : Minimiser les variables mutables accessibles par plusieurs tâches async.
- Copier les données : Travailler sur des copies, pas l'original. Spread operator, map/filter.
- Promise.all : Exécuter plusieurs tâches en parallèle. 3x plus rapide que séquentiel.
- Retry + timeout : Patterns essentiels pour des apps robustes en production.
- React cleanup : Toujours nettoyer les effets async (AbortController, flag cancelled).
- Tests async : Utiliser waitFor, findBy. Tester les états loading, error, success.
⚡ Règle d'or : Le code async doit être encore plus simple que le code sync, pas plus complexe. Si votre async est compliqué, c'est qu'il y a un problème de design.