Synchronisation des processus en C/C++

La synchronisation des processus est une technologie qui résout le problème de l'accès simultané aux données partagées, ce qui peut entraîner une incohérence des données. Les processus de collaboration font référence à des processus qui peuvent affecter d'autres processus ou être affectés par d'autres processus, ce qui entraîne des données de processus incohérentes. Par conséquent, la synchronisation des processus est nécessaire pour garantir la cohérence des données.

Problème de section critique

Chaque processus a une section de code réservée appelée section critique. Dans cette section, le processus peut modifier les variables publiques, mettre à jour les tables, écrire dans des fichiers, etc. L'élément clé à noter à propos des sections critiques est que même si un processus s'exécute dans sa section critique, les autres processus ne peuvent pas s'exécuter dans leur section critique. Chaque processus doit demander l'autorisation avant d'entrer dans sa section critique, la section de code qui implémente cette demande est la section d'entrée, la fin du code est la section de sortie et le code restant est la section restante.

Vous trouverez ci-dessous la structure de la section critique d'un processus spécifique P1

a les trois exigences suivantes : La section critique doit être satisfaite

• Mutuellement exclusive - Si un processus suppose que P1 est dans sa section Supposons que P2 ne puisse pas s'exécuter dans sa section critique plutôt que tout autre processus s'exécutant dans la section critique.
• Progression - Si aucun processus ne s'exécute dans sa section critique et que certains processus souhaitent entrer dans la section critique de leur section critique, alors seuls les processus qui ne s'exécutent pas dans la partie restante peuvent demander à entrer dans la section critique. section, et le choix peut être reporté indéfiniment.
• Bounded Wait - Dans l'attente limitée, il existe une limite au nombre de fois qu'un processus peut entrer dans sa section critique après avoir émis une demande d'accès à sa section critique et avant que la demande ne soit accordée.

Il existe deux méthodes couramment utilisées dans les systèmes d'exploitation pour gérer les parties critiques.

Noyau préemptif - Un noyau préemptif permet de préempter un processus pendant que le processus est préempté. Fonctionne en mode noyau.

Noyau non préemptif - Un noyau non préemptif ne permet pas de préempter les processus exécutés en mode noyau.

Solution de Peterson

La solution de Peterson est une solution logicielle classique au problème des sections critiques. Il est limité à deux processus qui alternent entre leurs parties critiques et restantes. La partie de Peterson nécessite de partager deux éléments de données entre les deux processus, à savoir

• Intturn ;
• Drapeau booléen[2]

Ici, la variable turn indique à qui revient le tour d'entrer dans la section critique, et le tableau de drapeaux indique si le processus Soyez prêt à entrer dans la zone critique.

Si turn == i, cela signifie que le processus Pi est autorisé à entrer dans sa section critique.

Si flag[j] est VRAI, cela signifie que le processus j est prêt à entrer dans sa section critique

Voici la structure du processus P dans la solution Peterson

La solution Peterson conserve les trois conditions -

• Mutuellement exclusives − Un seul processus peut accéder à la section critique à la fois.
• Progrès - Les processus en dehors de la section critique n'empêcheront pas d'autres processus d'entrer dans la section critique.
Bounded Wait - Chaque processus a la possibilité d'entrer dans sa section critique sans attendre indéfiniment.

Le matériel de synchronisation

a été implémenté à l'aide de deux types d'instructions -

• Test et Set()
• swap()

Test et Set () sont des solutions matérielles au problème de synchronisation. Parmi eux, il existe une variable partagée par plusieurs processus appelée Lock, qui peut avoir une valeur de 0 et 1, où 1 signifie acquérir le verrou et 0 signifie libérer le verrou.

Chaque fois qu'un processus tente d'entrer dans la section critique, il doit interroger la valeur du verrou. Si la valeur de lock est 1, alors ils doivent attendre que la valeur de lock ne passe pas à 0.

Vous trouverez ci-dessous l'implémentation mutuellement exclusive de TestAndSet()

Semaphore

Semaphore est un outil de synchronisation utilisé pour surmonter les problèmes causés par les instructions TestAndSet() et Swap(). Le sémaphore S est une variable entière accessible via les deux opérations atomiques standards de wait() et signal()

wait() fonction :

wait(S) {
   While S <= 0
   ; // no operation
   S--;
}

Signal() fonction fonction :

signal(S) {
   S++;
}

Lorsqu'un Le processus modifie la valeur d'un sémaphore, d'autres processus ne peuvent pas opérer sur la même valeur de sémaphore en même temps.

La mise en œuvre de l'exclusion mutuelle à l'aide du sémaphore est donnée ci-dessous

Le système d'exploitation utilise deux types de sémaphores, à savoir :

Sémaphore de comptage - Ce type de sémaphore La valeur peut varier dans un domaine illimité

Sémaphore binaire - La valeur de ce type de sémaphore peut varier entre 0 et 1. Ils sont également appelés verrous mutex. Il est utilisé par le système d'exploitation pour résoudre les problèmes de section critiques dans plusieurs processus.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!