Mutex multi-thread Linux : un mécanisme de synchronisation thread-safe

Le système Linux est un système d'exploitation qui prend en charge l'exécution simultanée de tâches multiples. Il peut exécuter plusieurs processus en même temps, améliorant ainsi l'utilisation et l'efficacité du système. Cependant, s'il existe plusieurs threads dans un processus et que ces threads doivent partager certaines données ou ressources, une incohérence des données ou une concurrence entre les ressources peuvent se produire, entraînant des erreurs ou des exceptions système. Afin de résoudre ce problème, certains mécanismes de synchronisation doivent être utilisés, tels que les sémaphores, les variables de condition, les mutex, etc. Parmi eux, un mutex est un mécanisme de synchronisation relativement simple et efficace. Il permet à un thread de verrouiller des données ou des ressources partagées lors de leur accès pour empêcher d'autres threads d'y accéder en même temps, garantissant ainsi la sécurité des threads. Cet article présentera la méthode d'exclusion mutuelle des mutex multithread dans le système Linux, y compris l'initialisation, le verrouillage, le déverrouillage et la destruction du mutex.

Sync

Plusieurs threads dans le même processus partagent les ressources mémoire du processus. Lorsque plusieurs threads accèdent à la même ressource partagée en même temps, ils doivent se coordonner les uns avec les autres pour éviter des problèmes tels que l'incohérence des données et l'écrasement. et la communication sont appelés problèmes de synchronisation des threads. L'idée de la synchronisation des threads est de permettre à plusieurs threads d'accéder aux ressources partagées de manière séquentielle plutôt qu'en parallèle

.

Exclusion mutuelle VS Synchronisation

• Exclusion mutuelle : signifie qu'une certaine ressource permet à un seul visiteur d'y accéder en même temps, ce qui est unique et exclusif. Mais l’exclusion mutuelle ne peut pas limiter l’ordre dans lequel les visiteurs accèdent aux ressources, c’est-à-dire que l’accès n’est pas ordonné. Si l'opération est une opération atomique, elle s'exclut naturellement mutuellement
• Synchronisation : fait référence à l'accès ordonné aux ressources par les visiteurs via d'autres mécanismes sur la base de l'exclusion mutuelle (dans la plupart des cas). Dans la plupart des cas, la synchronisation implémente déjà l'exclusion mutuelle, en particulier lorsque toutes les écritures sur les ressources doivent s'exclure mutuellement. Dans quelques cas, plusieurs visiteurs peuvent être autorisés à accéder aux ressources en même temps

Mutex :

• Il s’agit essentiellement d’un verrou qui fournit un accès exclusif aux ressources. La fonction principale de Mutex est donc l’exclusion mutuelle. Un mutex permet à un seul thread d'accéder aux données en même temps et peut être considéré comme un sémaphore 0/1
• Les valeurs des objets Mutex ne sont que 0 et 1. Représentent respectivement l'état de verrouillage et l'état d'inactivité de Mutex :
  • Statut de verrouillage : l'objet actuel est verrouillé. Si le processus/thread utilisateur tente de verrouiller les ressources critiques, il entrera en attente
  .
  • État inactif : l'objet actuel est inactif, le processus/thread utilisateur peut verrouiller les ressources critiques, puis la valeur Mutex diminue de 1 et devient 0.
• Le mutex peut avoir une valeur initiale lors de sa création, indiquant si le mutex est dans un état verrouillé ou inactif après sa création.
• Dans le même thread, afin d'éviter les blocages, le système ne permet pas de verrouiller le Mutex deux fois de suite (le système revient généralement immédiatement après le deuxième appel). En d’autres termes, les deux opérations correspondantes de verrouillage et de déverrouillage doivent être effectuées dans le même thread.

Modèle Mutex

#include 
pthread_mutex_t  mutex                //定义互斥锁               
pthread_mutex_init()            //初始化锁          
pthread_mutex_lock()/pthread_mutex_trylock()  ...     //加锁                  
pthread_mutex_unlock()          //解锁                        
pthread_mutex_destroy()         //销毁                        
//成功返回0,失败返回error number
#include 
int pthread_mutex_init  (pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
int pthread_mutex_lock  (pthread_mutex_t *mutex);
int pthread_mutex_trylock   (pthread_mutex_t *mutex);
int pthread_mutex_unlock    (pthread_mutex_t *mutex);
int pthread_mutex_destroy   (pthread_mutex_t *mutex);

impasse

Le blocage se produit principalement lorsqu'il existe plusieurs verrous dépendants, et il se produit lorsqu'un thread tente de verrouiller le mutex dans l'ordre opposé avec un autre thread
Lorsque le fil boule noire utilise les ressources partagées dans le sens de A->, et que le fil boule blanche utilise les ressources partagées dans l'ordre de B->A, malheureusement, le fil boule noire verrouille la ressource A jusqu'à ce que il obtient les ressources B libérées, le fil de boule blanche verrouille la ressource B jusqu'à ce qu'il obtienne la ressource libérée A. Le résultat final est qu'ils ne peuvent pas obtenir les ressources qu'ils veulent, et ils verrouillent tous les ressources que l'autre partie veut

解决死锁：

• 对共享资源操作前一定要获得锁
• 完成操作后一定要释放锁
• 尽量短的时间占用锁
• 如果有多锁，如获得的顺序是ABC顺序，那么释放顺序也该是ABC
• 线程错误返回时会释放它所获得的锁

例子

#include
#include
#include
#include

char* buf[5];
int pos;
//1.定义互斥量
pthread_mutex_t mutex;
void* task(void* pv){
    //3.使用互斥量进行加锁
    pthread_mutex_lock(&mutex);
    
    //4.访问共享内存
    buf[pos]=(char*)pv;
    sleep(1);
    pos++;

    //5.使用互斥量进行解锁
    pthread_mutex_unlock(&mutex);
}
main(){
    //2.初始化互斥量
    pthread_mutex_init(&mutex,NULL);

    pthread_t thread;
    pthread_create(&thread,NULL,task,(void*)"zhangfei");
    pthread_t thread2;
    pthread_create(&thread2,NULL,task,(void*)"guanyu");
    
    pthread_join(thread,NULL);
    pthread_join(thread2,NULL);

    //打印字符指针数组中的有效数据
    int i=0;
    for(i=0;iprintf("%s ",buf[i]);
    }
    printf("\n");
    //6.如果不再使用则销毁互斥量
    pthread_mutex_destroy(&mutex);
    return 0;
}

本文介绍了Linux系统中多线程互斥量的互斥的方法，包括互斥量的初始化、加锁、解锁和销毁等方面。通过了解和掌握这些知识，我们可以更好地使用互斥量来实现多线程之间的同步，提高系统的稳定性和效率。当然，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!