Programmation concurrente

La programmation concurrente désigne la manière dont un programme gère l'exécution simultanée de plusieurs tâches (ou processus) au sein de son flux d'exécution. Les structures de contrôle sont des éléments syntaxiques organisant l'ordre dans lequel les instructions d'un programme sont exécutées, et la programmation concurrente en ajoute une dimension supplémentaire : plusieurs séquences d'instructions peuvent être exécutées en parallèle ou de façon entrelacée.

Définition de la programmation concurrente

La programmation concurrente est un paradigme de programmation dans lequel différentes parties d'un programme sont exécutées "en même temps" ou presque, afin de résoudre des problèmes où plusieurs tâches doivent progresser simultanément. Elle est particulièrement utile lorsque des ressources partagées doivent être utilisées efficacement (par exemple, sur des systèmes multicoeurs) ou lorsque des tâches doivent être réalisées de manière désynchronisée (comme les opérations d'entrée/sortie).

Structures de contrôle dans la programmation concurrente

Voici les principales structures de contrôle associées à la gestion de la concurrence :

• Création et gestion des processus léger : Dans de nombreux langages de programmation, un programme peut créer plusieurs processus léger ou processus pour exécuter des tâches en parallèle. Des structures de contrôle sont utilisées pour gérer la création, la terminaison et la coordination entre ces unités d'exécution.

Exemple en Java :

1. Thread thread = new Thread(() -> {
2.      // code concurrent exécuté dans ce processus léger
3. });
4. thread.start();  // lancement du processus léger

Exemple de la création d'un processus en Concurrent Pascal :

1. process TaskA;begin
2.  while true do begin
3.   writeln('Tâche A est exécuté');
4.  end;
5. end;

Ici, la création d'un processus léger est une structure de contrôle permettant d'exécuter un morceau de code de façon parallèle à d'autres parties du programme.

• Les moniteurs : Les moniteurs sont une structure de contrôle cruciale. Un moniteur est un type abstrait encapsulant des variables et des procédures et gérant l'accès exclusif à des ressources partagées. Seul un processus peut entrer dans un moniteur à un moment donné, ce qui garantit l'intégrité des données partagées.

Exemple de moniteur pour la synchronisation dans Concurrent Pascal :

1. monitor SharedResource;
2. var
3.  sresource: integer;
4.  
5. procedure AccessResource;begin
6.  sresource:=sresource+1;
7.  writeln('Ressource accédée, valeur :', sresource);
8. end;
9.  
10. procedure ReleaseResource;begin
11.  sresource:=sresource-1;
12.  writeln('Ressource libérée, valeur :', sresource);
13. end;
14.  
15. end.

Ici, SharedResource est un moniteur contrôlant l'accès à une variable partagée sresource. Les processus appelant AccessResource ou ReleaseResource ne peuvent y accéder que de manière séquentielle, garantissant qu'un seul processus à la fois modifie la ressource partagée.

• Les variables conditionnelles : Les moniteurs incluent des variables conditionnelles, étant des mécanismes utilisés pour synchroniser l'exécution de processus concurrents. Une variable conditionnelle permet à un processus d'attendre qu'une certaine condition soit remplie avant de continuer son exécution.

Exemple de variable conditionnelle en Concurrent Pascal :

1. monitor Printer;
2.  
3. var
4.  printing:boolean;
5.  
6. condition PrinterFree;
7.  
8. procedure RequestPrinter;begin
9.  if printing then
10.   wait(PrinterFree);  (* Attendre que l'imprimante soit libre *)
11.  printing:=true;
12.  writeln('Imprimante acquis');
13. end;
14.  
15. procedure ReleasePrinter;begin
16.  printing := false;
17.  signal(PrinterFree);  (* Signaler que l'imprimante est libre *)
18.  writeln('Imprimante libérée');
19. end;
20.  
21. end.

Dans cet exemple, le moniteur Printer contrôle l'accès à une imprimante. La variable conditionnelle PrinterFree est utilisée pour forcer les processus à attendre (via wait()) que l'imprimante soit libre avant de l'utiliser, et pour notifier (via signal()) lorsque l'imprimante devient disponible.

• Attente et synchronisation (join, await, wait) : Des structures comme join() en Java ou await en C# permettent de synchroniser les tâches concurrentes, c'est-à-dire de forcer une partie du programme à attendre qu'une autre tâche soit terminée avant de continuer son exécution.

Exemple en Java :

1. thread.join();  // Attend que le processus léger se termine

Cette structure garantit que l'exécution du programme principal ne continuera pas tant que le processus léger thread n'a pas terminé.

Voici un exemple complet où plusieurs processus doivent accéder à une ressource partagée (une imprimante), en utilisant des moniteurs pour synchroniser leur accès en Concurrent Pascal :

1. monitor Printer;
2. var
3.  printing: boolean;
4.  condition PrinterFree;
5.  
6. procedure RequestPrinter;begin
7.  if printing then
8.   wait(PrinterFree);  (* Attendre que l'imprimante soit libre *)
9.  printing:=true;
10. end;
11.  
12. procedure ReleasePrinter;begin
13.  printing := false;
14.  signal(PrinterFree);  (* Signaler que l'imprimante est libre *)
15. end;
16.  
17. end.
18.  
19. process User1;begin
20.  while true do begin
21.   RequestPrinter;
22.   writeln('Utilisateur 1 est en train d''imprimer');
23.   ReleasePrinter;
24.  end;
25. end;
26.  
27. process User2;begin
28.  while true do begin
29.   RequestPrinter;
30.   writeln('Utilisateur 1 est en train d''imprimer');
31.   ReleasePrinter;
32.  end;
33. end;

Dans cet exemple, User1 et User2 sont deux processus qui essaient d'utiliser l'imprimante. Le moniteur Printer gère l'accès exclusif à l'imprimante à l'aide de la variable printing. Les processus User1 et User2 appellent RequestPrinter pour obtenir l'accès à l'imprimante. Si l'imprimante est déjà utilisée, ils attendent que celle-ci soit libérée grâce à la variable conditionnelle PrinterFree.

• Mutex et Sémaphores : Pour protéger l'accès à des ressources partagées (comme des fichiers ou des variables), des mécanismes comme les mutex (verrous) ou les sémaphores sont utilisés. Ce sont des structures de contrôle empêchant plusieurs tâches d'accéder à la même ressource en même temps, afin d'éviter les conflits.

Exemple en C (pthreads) :

1. pthread_mutex_t lock;
2. pthread_mutex_lock(&lock);
3. /* Section critique */
4. pthread_mutex_unlock(&lock);

Ici, pthread_mutex_lock() et pthread_mutex_unlock() sont des structures de contrôle organisant l'accès concurrent à une section critique du code.

• Boucles d'événements (Event Loops) : Dans des environnements désynchronisées, comme en JavaScript, la gestion de la concurrence est souvent assurée par des boucles d'événements, gérant l'exécution des callbacks et des promesses (promises) en réponse à des événements.

Exemple en JavaScript :

1. async function fetchData() {
2.   let response = await fetch(url);
3.   let data = await response.json();
4.   console.log(data);
5. }

Ici, l'utilisation de await est une structure de contrôle permettant au programme d'attendre que la requête soit terminée avant de continuer.

• Parallélisme implicite (Fork/Join) : Certains langages permettent de définir des tâches étant implicitement exécutées en parallèle sans que le programmeur ait besoin de créer manuellement des processus légers. Ces langages utilisent des structures de contrôle comme fork et join pour gérer la concurrence.

  Exemple en Java (cadre d'application Fork/Join Framework) :

  1. ForkJoinPool pool = new ForkJoinPool();
  2. pool.invoke(new RecursiveTaskExample());

  Dans cet exemple, les tâches sont automatiquement découpées et exécutées en parallèle par le cadre d'application.

• Canaux (Channels) : Dans certains langages de programmation comme Go, les canaux sont des structures de contrôle utilisées pour communiquer entre goroutines (les unités d'exécution concurrente en Go) de manière sécurisée.

Exemple en Go :

1. c := make(chan int)
2. go func() {
3.      c <- 42  // Envoi d'une donnée à travers le canal
4. }()
5. value := <-c  // Réception de la donnée

Ici, le canal permet de coordonner l'exécution entre deux goroutines, l'une envoyant des données et l'autre les recevant.

Langage de programmation

Voici quelques langages de programmation gérant les programmes ou processus concurrent :

Cadre d'application ou bibliothèque

Voici quelques cadres d'application ou bibliothèques gérant les programmes ou processus concurrent en fonction des langages de programmation :

Conclusion

Les structures de contrôle en programmation concurrente permettent de gérer l'exécution simultanée ou entrelacée de tâches tout en assurant la coordination entre elles. Cela inclut des mécanismes comme la création de processus léger, la synchronisation via des primitives comme les mutex ou sémaphores, l'attente d'événements ou l'usage de canaux pour échanger des informations entre différentes unités d'exécution. La clef est de permettre une exécution efficace et correcte des programmes, même dans un environnement où plusieurs tâches doivent progresser en parallèle.

Voir également

Langage de programmation - Mesa - Processus et concurrence