C ++ staat bekend als een van de snelste programmeertalen met goede prestaties, hoge precisie en een adequaat geheugenbeheersysteem. Deze programmeertaal ondersteunt ook de gelijktijdige uitvoering van meerdere threads met het delen van meerdere bronnen tussen hen. Bij multithreading is de thread alleen bedoeld om de leesbewerking uit te voeren die geen problemen oplevert, omdat de thread niet wordt beïnvloed door wat de andere threads op dat moment doen. Maar als deze threads de bronnen onderling moesten delen, kan één thread de gegevens op dat moment wijzigen, waardoor het probleem ontstaat. Om dit probleem aan te pakken, hebben we de C ++ 'Mutex' die de toegang van meerdere bronnen tot onze code / object voorkomt door de synchronisatie te bieden die stelt dat de toegang tot het object / de code aan slechts één thread tegelijk kan worden verleend, zodat meerdere threads niet tegelijkertijd toegang tot dat object kunnen krijgen.
Procedure:
We zullen leren hoe we de toegang van meerdere threads tot een object tegelijk kunnen stoppen met behulp van mutex lock. We zullen het hebben over de syntaxis van het mutex-slot, wat multiple-threading is en hoe we kunnen omgaan met de problemen die worden veroorzaakt door multiple-threading met behulp van het mutex-slot. Vervolgens zullen we een voorbeeld nemen van de meervoudige threading en de mutex-vergrendeling daarop implementeren.
Syntaxis:
Als we willen leren hoe we de mutex-vergrendeling kunnen implementeren, zodat we de toegang van meerdere threads tegelijkertijd naar ons object of onze code kunnen voorkomen, kunnen we de volgende syntaxis gebruiken:
$ standaard :: mutex mut_x
$mut_x. op slot doen ( ) ;
Void func_name ( ) {
$ // code die we willen verbergen voor de meerdere threads zou hier worden geschreven
$mut_x. ontgrendelt ( ) ;
}
We zullen deze syntaxis nu gebruiken in het dummy-voorbeeld en in de pseudo-code (die we niet zomaar kunnen uitvoeren zoals het is in de code-editor) om u te laten weten hoe we deze syntaxis precies kunnen gebruiken, zoals hieronder vermeld:
$ standaard :: mutex mut_x
Void blok ( ) {
$mut_x. op slot doen ( ) ;
$ standaard :: cout << 'Hallo' ;
$mut_x. ontgrendelt ( ) ;
}
Voorbeeld:
Laten we in dit voorbeeld eerst proberen de multithread-bewerking te maken en deze bewerking vervolgens te omringen met mutex-vergrendeling en ontgrendeling om de bewerking te synchroniseren met de gemaakte code of het gemaakte object. Mutex houdt zich bezig met race-omstandigheden, wat de waarden zijn die vrij onvoorspelbaar zijn en ze zijn afhankelijk van het wisselen van de draden die tijdbewust zijn. Om het voorbeeld voor mutex te implementeren, moeten we eerst de belangrijke en vereiste bibliotheken uit de repositories importeren. De benodigde bibliotheken zijn:
$ # include
$ # include
$ # include
De 'iostream' -bibliotheek biedt ons een functie om de gegevens als Cout weer te geven, de gegevens als Cin te lezen en de instructie als endl te beëindigen. We gebruiken de 'thread' -bibliotheek om de programma's of functies van de threads te gebruiken. Met de 'mutex' -bibliotheek kunnen we zowel de mutex-vergrendeling als de ontgrendeling in de code implementeren. We gebruiken de '# include' omdat dit alle programma's toestaat die verband houden met de bibliotheek die in de code is opgenomen.
Nu, nadat de vorige stap is voltooid, definiëren we de mutex-klasse of een globale variabele voor de mutex met behulp van de std. Vervolgens maken we een functie voor mutex vergrendelen en ontgrendelen die we daarna in de code kunnen aanroepen. In dit voorbeeld noemen we deze functie blok. In de hoofdtekst van de blokfunctie roepen we eerst de 'mutex.lock()' aan en beginnen we met het schrijven van de logica van de code.
De mutex.lock() weigert de toegang van de andere threads om ons gecreëerde object of onze gemaakte code te bereiken, zodat slechts één thread ons object tegelijk kan lezen. In de logica voeren we een for-lus uit die op de index van 0 tot 9 loopt. We geven de waarden in de lus weer. Zodra deze logica is gemaakt in het mutex-slot nadat de bewerking is voltooid of nadat de logica is verlaten, noemen we de methode 'mutex.unlock()'. Met deze methode-aanroep kunnen we het gemaakte object ontgrendelen vanuit mutex-vergrendeling, omdat de toegang van het object tot één enkele thread eerder was verleend en zodra de bewerking op dat object door één thread tegelijk is uitgevoerd. We willen nu dat de andere threads ook toegang krijgen tot dat object of die code. Anders beweegt onze code in de 'deadlock' -situatie waardoor het gemaakte object met de mutex voor altijd in de vergrendelde situatie blijft en geen enkele andere thread toegang tot dat object zou hebben. Daarom blijft een onvolledige bewerking worden uitgevoerd. Hierna verlaten we de blokfunctie en gaan we naar het hoofdmenu.
In het algemeen geven we eenvoudig onze gemaakte mutex weer door de drie threads te maken met behulp van de 'std :: thread thread_name (door de reeds gemaakte blokfunctie hier aan te roepen waarin we de mutex hebben gemaakt)' met de namen thread1, thread2 en thread3, enz. Op deze manier worden de drie threads gemaakt. Vervolgens voegen we deze drie threads samen om tegelijkertijd te worden uitgevoerd door de 'thread_name. join ()”-methode. En dan retourneren we de waarde gelijk aan nul. De eerder genoemde uitleg van het voorbeeld is geïmplementeerd in de vorm van de code die kan worden weergegeven in de volgende afbeelding:
In de uitvoer van de code kunnen we de uitvoering en weergave van alle drie de threads één voor één zien. We kunnen zelfs zien of onze applicatie onder de categorie multithreading valt. Toch heeft geen van de threads de gegevens overschreven of gewijzigd en de gewijzigde bron gedeeld vanwege de implementatie van de mutex van het 'functieblok'.
Conclusie
Deze gids geeft een gedetailleerde uitleg van het concept van de mutex-functie die in C++ wordt gebruikt. We hebben besproken wat de multithreading-applicaties zijn, welke problemen we tegenkomen bij multithreading-applicaties en waarom we de mutex moeten implementeren voor multithreading-applicaties. Vervolgens hebben we de syntaxis voor de mutex besproken met het dummy-voorbeeld met behulp van de pseudo-code. Vervolgens hebben we een compleet voorbeeld geïmplementeerd op de multithreading-applicaties met de mutex op de C++ visuele studio.