Quels types de verrous Linux existe-t-il ?

Types de verrous Linux : 1. mutex (verrouillage mutex), utilisé pour garantir qu'un seul thread peut accéder à l'objet à tout moment ; 2. rwlock (verrouillage en lecture-écriture), qui est divisé en verrou de lecture et verrou d'écriture. Convient aux situations où la fréquence de lecture des données est bien supérieure à la fréquence d'écriture des données ; 3. spinlock (spin lock), un seul thread peut accéder à l'objet à tout moment 4. seqlock (verrouillage séquentiel), utilisé pour distinguer In ; Dans le cas de la lecture et de l'écriture, et qu'il existe de nombreuses opérations de lecture et peu d'opérations d'écriture, la priorité des opérations d'écriture est supérieure à celle des opérations de lecture.

L'environnement d'exploitation de ce tutoriel : système linux7.3, ordinateur Dell G3.

Plusieurs mécanismes de verrouillage sous Linux

Mutex : mutex

Mutex : mutex, utilisé pour garantir qu'un seul thread peut accéder à l'objet à tout moment. Lorsque l'opération d'acquisition du verrou échoue, le thread se met en veille et se réveille en attendant que le verrou soit libéré.

Verrouillage en lecture-écriture : rwlock

 Verrouillage en lecture-écriture : rwlock, qui est divisé en verrouillage en lecture et en écriture. Lors d'une opération de lecture, plusieurs threads peuvent être autorisés à obtenir des opérations de lecture en même temps. Mais un seul thread peut obtenir le verrou en écriture à la fois. Les autres threads qui ne parviennent pas à acquérir le verrou en écriture se mettront en veille jusqu'à ce qu'ils soient réveillés lorsque le verrou en écriture sera libéré.

Remarque : les verrous en écriture bloqueront les autres verrous en lecture et en écriture. Lorsqu'un thread acquiert un verrou en écriture et est en train d'écrire, le verrou en lecture ne peut pas être acquis par d'autres threads ; les écrivains ont la priorité sur les lecteurs (une fois qu'il y a un écrivain, les lecteurs suivants doivent attendre et les écrivains ont la priorité au réveil).

• Applicable aux situations où la fréquence de lecture des données est bien supérieure à la fréquence d'écriture des données.

Spin lock : spinlock

  Spin lock : spinlock, un seul thread peut accéder à l'objet à tout moment. Mais lorsque l'opération d'acquisition du verrou échoue, il ne se met pas en veille, mais tourne sur place jusqu'à ce que le verrou soit libéré. Cela permet d'économiser la consommation de threads de l'état de veille au réveil, ce qui améliorera considérablement l'efficacité dans les environnements à temps de verrouillage court. Mais si le temps de verrouillage est trop long, cela gaspillera beaucoup de ressources CPU.

RCU

  RCU : Lecture-copie-mise à jour. Lors de la modification des données, vous devez d'abord lire les données, puis générer une copie et modifier la copie. Une fois la modification terminée, mettez à jour les anciennes données avec les nouvelles données.

Lors de l'utilisation de RCU, les lecteurs ne nécessitent presque aucune surcharge de synchronisation. Ils n'ont pas besoin d'obtenir de verrous ni d'utiliser d'instructions atomiques, ce qui ne provoquera pas de concurrence de verrouillage, il n'est donc pas nécessaire de considérer les problèmes de blocage. La surcharge de synchronisation pour les rédacteurs est relativement importante, car ils doivent copier les données modifiées et utiliser un mécanisme de verrouillage pour synchroniser et paralléliser les opérations de modification des autres rédacteurs. Il est très efficace lorsqu’il y a un grand nombre d’opérations de lecture et un petit nombre d’opérations d’écriture.

Sémaphore : sémaphore

Le sémaphore du noyau Linux est le même dans son concept et son principe que le sémaphore du mécanisme SystemV IPC en mode utilisateur, mais il ne peut jamais être utilisé en dehors du noyau, ce n'est donc pas la même chose que SystemV Le mécanisme IPC n'a rien à voir avec les sémaphores.

Le sémaphore doit définir une valeur initiale lors de sa création, ce qui signifie que plusieurs tâches peuvent accéder aux ressources partagées protégées par le sémaphore en même temps. Une valeur initiale de 1 devient un mutex (Mutex), c'est-à-dire là. ne peut en être qu'une à la fois. Les tâches peuvent accéder à des ressources partagées protégées par des sémaphores. Si une tâche souhaite accéder à une ressource partagée, elle doit d'abord obtenir un sémaphore. L'opération d'obtention du sémaphore réduira la valeur du sémaphore de 1. Si la valeur actuelle du sémaphore est un nombre négatif, cela indique que le sémaphore. ne peut pas être obtenu et la tâche doit y être suspendue. La file d'attente du sémaphore attend que le sémaphore soit disponible ; si la valeur actuelle du sémaphore est un nombre non négatif, cela signifie que le sémaphore peut être obtenu, donc les ressources partagées. protégés par le sémaphore sont accessibles immédiatement. Une fois que la tâche a terminé d'accéder à la ressource partagée protégée par le sémaphore, elle doit libérer le sémaphore. La libération du sémaphore s'effectue en ajoutant 1 à la valeur du sémaphore. Si la valeur du sémaphore est un nombre non positif, cela indique que. il y a une tâche en attente du sémaphore actuel, donc elle réveille également toutes les tâches en attente sur le sémaphore.

rw_semaphore (lire et écrire le sémaphore)

Les sémaphores de lecture et d'écriture subdivisent les visiteurs, qu'ils soient lecteurs ou écrivains. Les lecteurs ne peuvent lire et accéder qu'aux ressources partagées protégées par le sémaphore de lecture et d'écriture tout en conservant le sémaphore de lecture et d'écriture. Si une tâche a besoin de lire et éventuellement d'écrire, il doit être classé comme écrivain. Il doit obtenir le statut d'écrivain avant d'accéder aux ressources partagées. Les écrivains peuvent passer au statut de lecteur s'ils constatent qu'ils n'ont pas besoin d'un accès en écriture. Il n'y a pas de limite au nombre de lecteurs qu'un sémaphore en lecture-écriture peut avoir en même temps, ce qui signifie que n'importe quel nombre de lecteurs peuvent avoir un sémaphore en lecture-écriture en même temps. Si un sémaphore en lecture-écriture n'appartient pas actuellement à un écrivain et qu'aucun écrivain n'attend qu'un lecteur libère le sémaphore, alors n'importe quel lecteur peut acquérir avec succès le sémaphore en lecture-écriture, sinon le lecteur doit être suspendu jusqu'à ce que l'écrivain libère le sémaphore ; sémaphore. Si un sémaphore en lecture-écriture n'appartient pas actuellement à un lecteur ou à un écrivain et qu'aucun écrivain n'attend le sémaphore, alors un écrivain peut acquérir avec succès le sémaphore en lecture-écriture, sinon l'écrivain sera suspendu jusqu'à ce qu'il n'y ait plus de visiteurs. . Par conséquent, l'écrivain est exclusif et exclusif.
Il existe deux implémentations de sémaphores de lecture et d'écriture. L'une est universelle et ne dépend pas de l'architecture matérielle. Par conséquent, l'ajout d'une nouvelle architecture ne nécessite pas de la réimplémenter. Cependant, l'inconvénient est de faibles performances et une surcharge élevée pour l'obtention et la réimplémentation. ; L'autre est lié à l'architecture, il a donc des performances élevées, et la surcharge liée à l'acquisition et à la libération des sémaphores de lecture et d'écriture est faible, mais l'ajout d'une nouvelle architecture nécessite une réimplémentation. Lors de la configuration du noyau, vous pouvez utiliser des options pour contrôler quelle implémentation est utilisée.

Sémaphore en lecture-écriture : rw_semaphore

Le sémaphore en lecture-écriture subdivise les visiteurs, qu'ils soient lecteurs ou écrivains. Les lecteurs ne peuvent protéger que le sémaphore en lecture-écriture tout en conservant l'accès en lecture à une ressource partagée. La tâche nécessite l'écriture en plus de la lecture, elle doit alors être classée comme écrivain. Elle doit obtenir le statut d'écrivain avant d'accéder à la ressource partagée. L'écrivain constate qu'il n'a pas besoin d'un accès en écriture et peut être rétrogradé en lecteur. Il n'y a pas de limite au nombre de lecteurs qu'un sémaphore en lecture-écriture peut avoir en même temps, ce qui signifie que n'importe quel nombre de lecteurs peuvent posséder un sémaphore en lecture-écriture en même temps. Si un sémaphore en lecture-écriture n'appartient pas actuellement à un écrivain et qu'aucun écrivain n'attend qu'un lecteur libère le sémaphore, alors n'importe quel lecteur peut acquérir avec succès le sémaphore en lecture-écriture, sinon le lecteur doit être suspendu jusqu'à ce que l'écrivain libère le sémaphore ; sémaphore. Si un sémaphore en lecture-écriture n'appartient pas actuellement à un lecteur ou à un écrivain et qu'aucun écrivain n'attend le sémaphore, alors un écrivain peut acquérir avec succès le sémaphore en lecture-écriture, sinon l'écrivain sera suspendu jusqu'à ce qu'il n'y ait plus de visiteurs. . Par conséquent, l'écrivain est exclusif et exclusif.

Il existe deux implémentations de sémaphores de lecture et d'écriture. L'une est universelle et ne dépend pas de l'architecture matérielle. Par conséquent, l'ajout d'une nouvelle architecture ne nécessite pas de la réimplémenter, mais l'inconvénient est de faibles performances et la surcharge liée à l'obtention et à l'écriture. la libération des sémaphores de lecture et d'écriture est Large ; l'autre est liée à l'architecture, donc les performances sont élevées et la surcharge liée à l'acquisition et à la libération des sémaphores de lecture et d'écriture est faible, mais l'ajout d'une nouvelle architecture nécessite une réimplémentation. Lors de la configuration du noyau, vous pouvez utiliser des options pour contrôler quelle implémentation est utilisée.

seqlock**** (verrouillage séquentiel)

est utilisé dans des situations où la lecture et l'écriture peuvent être distinguées, et il existe de nombreuses opérations de lecture et peu d'opérations d'écriture, et la priorité des opérations d'écriture est supérieure à celle de la lecture opérations. L'idée d'implémentation de seqlock est d'utiliser un entier croissant pour représenter la séquence. Lorsque l'opération d'écriture entre dans la section critique, séquence++ est utilisée ; lorsque l'opération d'écriture quitte la section critique, séquence est à nouveau +++.

L'opération d'écriture doit également obtenir un verrou (tel qu'un mutex). Ce verrou n'est utilisé que pour l'exclusion mutuelle d'écriture-écriture afin de garantir qu'il y a au plus une opération d'écriture en cours en même temps. Lorsque la séquence est un nombre impair, cela signifie qu'une opération d'écriture est en cours. A ce moment, l'opération de lecture doit attendre que la séquence devienne un nombre pair pour entrer dans la section critique. Lorsqu'une opération de lecture entre dans la section critique, il est nécessaire d'enregistrer la valeur de la séquence actuelle. Lorsqu'elle sort de la section critique, comparez la séquence enregistrée avec la séquence actuelle. Si elles ne sont pas égales, cela signifie qu'une opération d'écriture a eu lieu. tandis que l'opération de lecture est entrée dans la section critique. À ce moment, l'opération de lecture L'opération de lecture n'est pas valide et doit revenir et réessayer.

l'écriture seqlock doit s'exclure mutuellement. Cependant, le scénario d'application de seqlock lui-même est une situation dans laquelle il y a plus de lecture et moins d'écriture, et la probabilité de conflit d'écriture est très faible. Il n’y a donc fondamentalement aucune perte de performances dans le mutex d’écriture-écriture ici. Les opérations de lecture et d’écriture ne doivent pas nécessairement s’exclure mutuellement. Le scénario d'application de seqlock est que les opérations d'écriture ont priorité sur les opérations de lecture. Pour les opérations d'écriture, il n'y a presque pas de blocage (sauf si un événement peu probable tel qu'un conflit d'écriture-écriture se produit) et seule l'action supplémentaire de séquence++ est requise. L'opération de lecture n'a pas besoin d'être bloquée, mais une nouvelle tentative est requise lorsqu'un conflit de lecture-écriture est détecté. Une application typique de seqlock est la mise à jour de l'horloge. Il y aura une interruption d'horloge toutes les 1 millisecondes dans le système, et le gestionnaire d'interruption correspondant mettra à jour l'horloge (opération d'écriture).

Le programme utilisateur peut appeler des appels système tels que gettimeofday pour obtenir l'heure actuelle (opération de lecture). Dans ce cas, l'utilisation de seqlock peut empêcher un trop grand nombre d'appels système gettimeofday de bloquer le gestionnaire d'interruption (ce serait le cas si des verrous en lecture-écriture étaient utilisés à la place de seqlock). Le gestionnaire d'interruption est toujours prioritaire, et si l'appel système gettimeofday entre en conflit avec lui, peu importe si le programme utilisateur attend.

La différence entre les verrous mutex et les verrous en lecture-écriture :

1) Les verrous en lecture-écriture font la distinction entre les lecteurs et les écrivains, tandis que les verrous mutex ne font pas la distinction

2) Les verrous mutex ne permettent qu'à un seul thread d'accéder à l'objet en même temps , indépendamment de la lecture ou de l'écriture ; Un verrou en lecture-écriture n'autorise qu'un seul écrivain en même temps, mais permet à plusieurs lecteurs de lire l'objet en même temps.

Recommandations associées : "Tutoriel vidéo Linux"

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!