C ++ stdmutex /

En utilisant le mot-clé Mutex, nous pouvons verrouiller notre variable en étant accessible par plusieurs threads à la fois. Mutex est utilisé pour fournir une synchronisation dans C ++, ce qui signifie qu'un seul thread peut recevoir l'objet immédiatement. Les threads ne peuvent pas accéder au code de code verrouillé une fois le verrouillage établi. Le code a été verrouillé à l'aide de mutexes. Ainsi, même si le thread 2 est planifié tandis que le thread 1 consomme toujours la ressource partagée, Thread 2 ne pourra pas accéder à cette partie du code. Par conséquent, l'accès synchronisé aux ressources partagées dans le code est assurée.

Travail de mutex en c++

Considérez une situation dans laquelle un thread exécute une section de code qu'un mutex a verrouillé. Maintenant, si le planificateur décide de changer le contexte, tous les autres threads prêts à exécuter la même zone ne sont pas bloqués. Un seul fil de tous les autres serait en mesure d'y parvenir, mais si ce fil tentait d'exécuter une partie verrouillée du code, elle irait à nouveau endormir.

Il y aura des commutateurs de contexte répétés, mais jusqu'à ce que le verrouillage mutex sur la section verrouillée du code soit libéré, aucun thread ne pourra l'exécuter. Un fil qui a verrouillé un mutex ne peut pas le libérer.

Par conséquent, cela garantit qu'une fois qu'un thread verrouille une partie du code, aucun autre thread ne peut exécuter cette région jusqu'à ce que le fil verrouillé le déverrouille.

Ainsi, tout en fonctionnant sur des ressources partagées, ce système s'assure que les threads sont synchronisés.

En invoquant les deux fonctions suivantes, un mutex est initialisé et une serrure est ensuite obtenue: La première méthode initialise un mutex et la deuxième fonction permet le verrouillage de toute section cruciale de code.

# Int pthread_mutex_init (pthread_mutex_trylock * restreint mutex, const pthread_mutexattribute_trylock * restreindre l'attribut):
Fournit un mutex avec les caractéristiques définies par l'attribut et une référence à un autre mutex. La propriété Mutex par défaut (non-écursive) est utilisée si l'attribut est nul. Si Pthread Mutex init () est réussi, il renvoie 0 et initialise et déverrouille l'état de Mutex. Pthread mutex init () renvoie -1 si elle échoue.

# int pthread_mutex_lock (pthread_mutex_trylock * mutex):
Classe un mutex et verrouille un objet mutex. Le thread existant doit attendre que le mutex se déverrouille s'il a déjà été verrouillé par un autre fil. Un mutex est verrouillé par le fil qui le verrouillé et ce fil continue d'être le propriétaire du mutex jusqu'à ce que ce fil le déverrouille. La façon dont une serrure est utilisée peut varier selon que le mutex a la caractéristique récursive ou non. Lorsque le même thread verrouille le même type de mutex plus d'une fois, le nombre est augmenté et aucun fil d'attente n'est créé.

Pour diminuer le nombre à zéro, le thread propriétaire doit faire un nombre égal d'appels à pthread_mutex_unlock ().En cas de succès, la fonction pthread_mutex_lock () renvoie 0. Pthread_mutex_lock () renvoie -1 s'il échoue.

En effectuant les deux actions indiquées ci-dessous, le mutex peut être déverrouillé et détruit. La serrure peut être ouverte en utilisant la première technique et elle peut également être détruite afin qu'elle ne puisse pas être utilisée à l'avenir.

# int pthread_mutex_unlock (pthread_mutex_trylock * mutex):
L'objet Mutex est libéré. Si plusieurs threads ou plus font la queue pour bloquer le mutex, Pthread Mutex Unlock () oblige l'un des threads à le faire. Il le force également à s'échapper de Pthread Mutex Lock () avec l'objet mutex qu'il avait reçu précédemment. Le Mutex se déverrouille à moins qu'aucun thread ne attend et il n'a pas de propriétaire pour le moment. L'utilisation de la serrure peut changer si le mutex a la caractéristique récursive.

Lorsque le même fil verrouille une mutex donnée plus d'une fois, le nombre est diminué lors du déverrouillage et aucun fil d'attente n'est créé pour maintenir le verrouillage. Le mutex est supprimé et tous les fils d'attente sont affichés si le décompte est à zéro. Pthread_mutex_unlock () renvoie 0 en cas de succès. Pthread_mutex_unlock () revient -1 en cas d'échec.

int pthread_mutex_destroy (pthread_mutex_trylock * mutex): supprime un objet mutex. Parfois, il est appelé identifiant mutex du système. Les mutex sont utilisés pour protéger les ressources partagées. Le mutex est initialisé avec une valeur erronée mais Pthread Mutex Init permet de réinitialiser (). La valeur de retour réussie de pthread_mutex_destroy () est 0. Pthread_mutex_destroy () revient -1 en cas d'échec.

Exemple de mutex en c++

Une illustration de la façon dont la synchronisation des threads est accomplie avec des mutexes.

Ici, nous avons d'abord donné la taille de l'ID de fil «3». Ensuite, nous avons initialisé le compteur variable qui enregistre la fréquence avec les threads qui sont exécutés. Ensuite, nous avons créé le verrouillage de l'objet pour le pthread_mutex_lock. Après cela, nous avons établi une fonction «Mutex_Func» où nous avons pris la référence de verrouillage et initialisé la variable «M» avec zéro. La valeur incrémentielle est entrée dans la variable de comptoir.

Maintenant, nous avons défini la fonction principale de ce script. Les deux variables sont déclarées, une pour mutex comme «M» et une pour l'échec de la mutex comme «erreur». Lorsque la méthode «Mutex Func ()» utilise le «compteur» de ressource partagée, le même mutex est verrouillé. Le mutex identique est déverrouillé après la fonction "Mutex_Func ()". Le mutex est supprimé une fois que les deux threads ont rempli la fonction principale. Notez que seules deux tâches sont effectuées respectivement.

Dans la sortie, vous pouvez remarquer qu'un thread a commencé. Une fois que le thread en cours d'exécution n'est pas détruit, l'autre tâche qui n'a pas commencé est la tâche. Par conséquent, les deux travaux commencent et finissent les journaux cette fois. Ainsi, l'utilisation de la synchronisation de threads compatible Mutex.

Conclusion

Nous pouvons verrouiller l'objet qui contient les fonctionnalités essentielles de notre application en utilisant un mutex. De plus, cela évite les données incohérentes, ce qui est crucial pour les applications en temps réel. Comme la façon dont la synchronisation est mise en œuvre dans d'autres langages de programmation, Mutex est utilisé. Nous avons incorporé un exemple pour expliquer le concept de std :: mutex dans le langage de programmation C ++ également.