Linux – Synchronisation des threads et exclusion mutuelle

1. Mutex mutex
Synchronisation : accès aux ressources de manière ordonnée. Exclusion mutuelle : un seul s'exécute à la fois ; mais pour les programmes multithread, le problème des conflits d'accès est très courant. La solution consiste à introduire un mutex (Mutex, MutualExclusive Lock) et à obtenir le verrou. l'opération "lecture-modification-écriture", puis relâchez le verrou sur les autres threads qui n'ont pas obtenu le verrou ne peuvent qu'attendre mais ne peuvent pas accéder aux données partagées. De cette manière, l'opération en trois étapes "lecture-modification-écriture". write" forme une opération atomique. Soit les exécuter tous, soit aucun, ils ne seront pas interrompus en cours d'exécution, et cette opération ne se fera pas en parallèle sur les autres processeurs.
Les verrous Mutex sont représentés par des variables de type pthread_mutex_t. Initialisé avec pthread_mutex_init et détruit avec hread_destroy(). Renvoie 0 en cas de succès et un numéro d'erreur en cas d'échec. . Si la variable Mutex est allouée statiquement (variable globale ou variable statique), elle peut également être initialisée avec la définition de macro PTHREAD_MUTEX_INITIALIZER, ce qui équivaut à une initialisation avec pthread_mutex_init et le paramètre attr est NULL
Un thread peut appeler pthread_mutex_lock pour obtenir le Mutex.Si à ce moment un autre thread Si le thread a appelé pthread_mutex_lock pour obtenir le Mutex, le thread actuel doit attendre qu'un autre thread appelle pthread_mutex_unlock pour libérer le Mutex, et le thread actuel est réveillé avant de pouvoir obtenir le Mutex et continuer l'exécution. . Cela signifie que si un thread verrouille le mutex mais ne le déverrouille pas, et qu'un autre thread veut obtenir le mutex, il doit raccrocher et attendre que le thread verrouillé déverrouille le mutex et libère le mutex, puis le thread est réveillé et peut obtenir le mutex.
Si un thread veut obtenir le verrou mais ne veut pas se bloquer et attendre, il peut appeler pthread_mutex_trylock. Si le Mutex a été acquis par un autre thread, cette fonction échouera et retournera EBUSY sans provoquer le thread. pendre et attendre.

1 #include<stdio.h>  
  2 #include<stdlib.h>  
  3 #include<pthread.h>  
  4 static int g_count=0;  
  5 void * addWrite(void * arg)  
  6 {  
  7     int count=0;  
  8     int value=0;  
  9     while(count++ <5000)  
 10     {  
 11         value=g_count;  
 12         printf("g_count is %d\n",g_count);  
 13         g_count=value+1;  
 14     }  
 15 }  
 16 int main()  
 17 {  
 18     pthread_t id1;  
 19     pthread_t id2;  
 20     int ret=pthread_create(&id1,NULL,addWrite,NULL);  
 21     int res=pthread_create(&id2,NULL,addWrite,NULL);  
 22     pthread_join(id1,NULL);  
 23     pthread_join(id2,NULL);

Nous créons deux threads, chacun augmentant g_count 5000 fois Normalement le compteur final devrait être égal à 10000, mais en fait le résultat est différent à chaque exécution du programme, parfois il atteint 5000. Parfois je le fais. comptez plus de 6 000, mais après avoir ajouté le verrou, ajoutez pthread_mutex_init sur la cinquième ligne (comme indiqué ci-dessous)

Résultat :

Après avoir ajouté le verrou, il génère 10000
2. Principe de mise en œuvre du verrouillage et du déverrouillage

Afin de réaliser l'opération de verrouillage mutex, la plupart des architectures fournissent des instructions d'échange ou d'échange. L'instruction consiste à échanger des données entre le registre et l'unité de mémoire. Puisqu'il n'y a qu'une seule instruction, l'atomicité est garantie. Même sur une plate-forme multiprocesseur, les cycles de bus pour accéder à la mémoire sont séquentiels. L'instruction d'échange sur un processeur est exécutée. quand un autre Les instructions d'échange du processeur ne peuvent attendre que les cycles de bus. Ceci est montré dans le pseudocode ci-dessous. L'opération de déverrouillage en déverrouillage est également mise en œuvre avec une seule instruction pour garantir son atomicité.

3. Deadlock
・Généralement, si le même thread appelle lock deux fois, lors du deuxième appel, parce que le verrou a déjà été occupé, le thread raccrochera. et attendez que d'autres threads libèrent le verrou. Cependant, le thread est suspendu sans possibilité de libérer le verrou, il sera donc dans un état d'attente suspendu pour toujours. Une autre situation de blocage typique est la suivante : le thread A acquiert le verrou 1 et le thread B acquiert le verrou 2. À ce moment-là, le thread A appelle le verrou pour tenter d'acquérir le verrou 2. Par conséquent, il doit se bloquer et attendre que le thread B se libère. lock 2, et ceci Lorsque le thread B appelle également lock pour essayer d'obtenir le verrou 1, le résultat est qu'il doit attendre que le thread A libère le verrou 1, donc les deux threads A et B sont dans un état suspendu pour toujours.
Conditions de formation d'un blocage
① Condition d'exclusion mutuelle : une ressource ne peut être utilisée que par un seul thread à la fois.
②.Conditions de demande et de conservation : Lorsqu'un processus est bloqué en raison d'une demande de ressources, il conservera les ressources obtenues.

③. Conditions de non-privation : Les ressources obtenues par le processus ne peuvent pas être privées de force avant d'être épuisées.

④Condition d'attente cyclique : une relation de ressources d'attente cyclique tête-à-queue est formée entre plusieurs processus

Si plus de threads et plus de verrous sont impliqués, cela est plus susceptible de provoquer un problème de blocage. Lors de l'écriture d'un programme, vous devez essayer d'éviter d'acquérir plusieurs verrous en même temps. Si cela est nécessaire, il existe un principe : si tous les threads ont besoin de plusieurs verrous, ils doivent suivre le même ordre (le plus courant est le même). ordre d'adresse de la variable Mutex) Si le verrou est obtenu, le blocage ne se produira pas. Par exemple, si le verrou 1, le verrou 2 et le verrou 3 sont utilisés dans un programme et que les adresses de leurs variables Mutex correspondantes sont verrou 1

Ce qui précède est le contenu de la synchronisation des threads Linux et de l'exclusion mutuelle. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !