Retour aux projets

Projet 42

Philosophers

Une introduction concrète à la concurrence, aux threads et aux problèmes de synchronisation.

Stack

  • C
  • Threads
  • Mutex

Skills acquis

  • Créer et synchroniser plusieurs threads
  • Utiliser des mutex pour protéger des ressources partagées
  • Comprendre les risques de deadlock et de race condition
  • Raisonner sur le temps, l’état et la concurrence

Liens

Philosophers est une implémentation du problème classique des philosophes qui dînent. Le projet permet de comprendre les bases de la programmation concurrente : threads, mutex, synchronisation, accès partagés et conditions de course.

01 — Concurrence

Tout le monde veut la fourchette.

Le problème des philosophes est simple à expliquer, mais beaucoup moins simple à implémenter correctement. Plusieurs threads partagent des ressources limitées, et il faut éviter qu’ils se bloquent ou se marchent dessus.

Illustration de philosophes partageant des ressources autour d’une table
Fig. 01
Une table, des fourchettes, et soudain un cours complet sur la synchronisation.

02 — Synchronisation

Éviter le chaos.

Les mutex permettent de contrôler l’accès aux ressources partagées, mais ils introduisent aussi de nouveaux risques. Le projet pousse à réfléchir à l’ordre des actions, aux temps d’attente et aux situations où plusieurs threads dépendent les uns des autres.

Le cauchemar des multithreads.
Fig. 02

03 — Timing

Le temps devient critique.

La gestion du temps est centrale dans Philosophers. Il faut mesurer précisément les états, détecter les blocages et éviter les comportements imprévisibles. Le projet m’a aidé à mieux comprendre la difficulté d’écrire du code concurrent fiable.

Illustration d’un programme concurrent surveillant le temps
Fig. 03