1. A propos du cours

1. Auteur : Benjamin Monmege (Aix-Marseille Université, LIS-Lab)
2. Type : Support de cours spécialisé (DIU EIL)
3. Langue : Français
4. Licence : Matériel pédagogique du DIU EIL (accessible en ligne)

2. Prérequis

1. Une très bonne maîtrise des bases de la programmation Python (syntaxe, structures de contrôle, fonctions).
2. Une compréhension des concepts fondamentaux des systèmes d'exploitation : notion de processus, d'exécution concurrente.
3. Une familiarité avec la programmation modulaire.
4. Ce cours fait partie d'un diplôme pour enseignants (DIU EIL), le public a donc une culture informatique avancée.

3. Public cible

Ce cours s'adresse spécifiquement aux enseignants en formation du DIU "Enseigner l'Informatique au Lycée" (EIL). Il est conçu pour leur donner une compréhension approfondie et pédagogique des concepts de programmation concurrente (threads) et de synchronisation en Python, afin qu'ils puissent les enseigner dans le cadre du programme de la spécialité NSI (Numérique et Sciences Informatiques) au lycée.

4. Outils matériels et logiciels

4.1 Outils matériels

1. Un ordinateur standard. La programmation multithreadée tire parti des processeurs multicœurs, mais les concepts peuvent être enseignés sur une machine monocœur.

4.2 Outils logiciels

1. Un interpréteur Python 3.
2. Les modules Python de concurrence : le module threading pour les threads et threading.Lock pour les verrous.
3. Un environnement de développement (IDE ou éditeur de texte) pour écrire et exécuter les scripts.

5. Champs d'applications

1. Enseignement secondaire : Préparation des cours sur la programmation concurrente et les sections critiques pour la spécialité NSI en Terminale.
2. Développement d'applications réactives : Création de programmes avec une interface graphique (GUI) qui reste réactive pendant l'exécution de tâches longues en arrière-plan.
3. Traitement parallèle de données : Accélération de tâches en les découpant en sous-tâches exécutées simultanément par plusieurs threads (attention au GIL en Python).
4. Simulation : Modélisation de systèmes où plusieurs entités agissent de manière concurrente (jeux, réseaux de files d'attente).

6. Courte description

Cours avancé sur la programmation concurrente en Python. Il introduit les concepts de threads (processus légers), explique les problèmes de synchronisation (conditions de course) qu'ils génèrent, et présente les solutions pour créer des sections critiques à l'aide de verrous (locks).

7. Longue description du cours

Ce support de cours, élaboré par Benjamin Monmege dans le cadre du DIU EIL, aborde un sujet fondamental et complexe de l'informatique : la programmation concurrente. Son objectif est double : maîtriser les concepts techniques et savoir les transmettre de manière claire à des élèves de lycée.

Le cours commence par introduire la notion de threads, également appelés processus légers. Il explique la différence entre un processus (un programme en cours d'exécution avec son propre espace mémoire) et un thread (un fil d'exécution à l'intérieur d'un processus, partageant la mémoire avec les autres threads du même processus). Cette distinction est cruciale pour comprendre le partage des données et les problèmes qui en découlent.

La partie "Threads en python" montre comment les mettre en œuvre pratiquement. Le cours présente le module threading et la classe Thread. Il explique comment créer un thread (en héritant de la classe Thread ou en passant une fonction cible), comment le démarrer avec la méthode start(), et comment attendre sa fin avec join(). Des exemples illustrent comment plusieurs threads peuvent s'exécuter de manière entrelacée, donnant l'illusion du parallélisme.

Le cours aborde ensuite la problématique centrale de la synchronisation. Lorsque plusieurs threads accèdent et modifient une ressource partagée (une variable, un fichier, une structure de données) sans coordination, des conditions de course (race conditions) apparaissent. Le résultat du programme devient non déterministe et dépend de l'ordre d'exécution imprévisible des threads. Le cours illustre ce problème avec un exemple classique comme l'incrémentation concurrente d'un compteur partagé, qui peut donner un résultat final incorrect.

Pour résoudre ce problème, le cours introduit le concept de section critique. Il s'agit d'une portion de code qui ne peut être exécutée que par un seul thread à la fois. La création de sections critiques garantit l'exclusion mutuelle et préserve la cohérence des données partagées.

Le cours compare ensuite différentes techniques pour implémenter ces sections critiques. Il commence par la solution par attente active (busy waiting), comme l'algorithme de Peterson (théorique) ou l'utilisation d'un simple booléen. Il en explique le principe mais aussi les limites majeures : consommation inutile de temps CPU et complexité.

La majeure partie est consacrée aux solutions d'attente passive, qui sont efficaces et fournies par le système. Le cours se focalise sur le mécanisme des verrous (locks). Il détaille comment utiliser un objet Lock du module threading : un thread doit acquérir le verrou (avec acquire()) avant d'entrer dans la section critique, et le relâcher (avec release()) en sortant. Si le verrou est déjà pris par un autre thread, le thread demandeur est mis en attente passive (bloqué) jusqu'à ce qu'il devienne disponible. Le cours montre également la bonne pratique d'utilisation du verrou via l'instruction with lock:, qui garantit son relâchement même en cas d'erreur.

Enfin, en tant que ressource pédagogique pour enseignants, le cours propose probablement des exemples et des analogies pour rendre ces concepts abstraits accessibles à des lycéens. Par exemple, comparer les threads à des caissiers partageant une seule caisse (la ressource partagée) et le verrou à un système de "caisse occupée/libre". Il aborde aussi les problèmes classiques comme l'interblocage (deadlock) et comment l'éviter.

En résumé, ce document est un cours technique de niveau avancé qui prépare des enseignants à maîtriser un sujet délicat. Il combine une explication rigoureuse des mécanismes de concurrence et de synchronisation en Python avec une réflexion sur la manière de les enseigner, en fournissant les outils conceptuels et pratiques nécessaires pour aborder la programmation concurrente en classe de Terminale NSI.

Voir ou télécharger le document sur le site d’origine

Ce document est hébergé par une source externe. Nous ne revendiquons aucun droit sur son contenu. Pour toute demande de retrait, veuillez contacter l’auteur ou l’hébergeur officiel.