Chapitre 13 – La Concurrence

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.

Synchrone vs Asynchrone ❌ Synchrone (bloquant) Tâche 1 (3s) Tâche 2 (2s) Tâche 3 (1s) Total : 6 secondes ✅ Asynchrone (parallèle) Tâche 1 Tâche 2 Tâche 3 Total : ~3 secondes (temps de la plus longue) ⚡ 2x plus rapide !

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 :

4 principes anti-concurrence 1. Isoler le code concurrent Séparer la logique async de la logique métier 2. Limiter la portée des données Minimiser l'état partagé mutable 3. Copier les données Travailler sur des copies, pas l'original 4. Les threads doivent être indépendants Pas de dépendances entre tâches async Application en React • Isoler : Hooks custom pour async (useUsers, useOrders) • Limiter : State local > Global, éviter mutations directes • Copier : Spread operator {...obj}, map/filter retournent copies

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.