Se sap que C++ és un dels llenguatges de programació més ràpids amb un bon rendiment, alta precisió i un sistema de gestió de memòria adequat. Aquest llenguatge de programació també admet l'execució simultània de diversos fils amb la compartició de múltiples recursos entre ells. En multithreading, el fil només és per realitzar l'operació de lectura que no fa cap problema, ja que el fil no es veu afectat pel que estan fent els altres fils en aquell moment. Però si aquests fils havien de compartir els recursos entre ells, un fil pot modificar les dades en aquell moment, cosa que provoca el problema. Per fer front a aquest problema, tenim el C++ 'Mutex' que impedeix l'accés de múltiples recursos cap al nostre codi/objecte proporcionant la sincronització que indica que l'accés a l'objecte/codi només es pot proporcionar a un fil alhora, de manera que múltiples fils no podrien accedir a aquest objecte simultàniament.
Procediment:
Coneixerem com podem aturar l'accés de diversos fils a un objecte alhora mitjançant el bloqueig mutex. Parlarem de la sintaxi del bloqueig mutex, què és el fil múltiple i com podem tractar els problemes causats pel bloqueig mutex mitjançant el bloqueig mutex. A continuació, prendrem un exemple del fil múltiple i implementarem el bloqueig mutex en ells.
Sintaxi:
Si volem saber com podem implementar el bloqueig mutex per evitar l'accés de múltiples fils simultàniament cap al nostre objecte o codi, podem utilitzar la sintaxi següent:
$ std :: mutex mut_x
$mut_x. pany ( ) ;
Void nom_funció ( ) {
$ // el codi que volem amagar dels múltiples fils s'escriurà aquí
$mut_x. desbloqueja ( ) ;
}
Ara utilitzarem aquesta sintaxi a l'exemple fictici i al pseudocodi (que no podem executar com està a l'editor de codi) per fer-vos saber com podem utilitzar aquesta sintaxi exactament tal com s'esmenta a continuació:
$ std :: mutex mut_x
Bloc buit ( ) {
$mut_x. pany ( ) ;
$ std :: cout << 'Hola' ;
$mut_x. desbloqueja ( ) ;
}
Exemple:
En aquest exemple, intentem crear primer l'operació multifil i després envoltar aquesta operació amb bloqueig i desbloqueig de mutex per proporcionar la sincronització de l'operació amb el codi o l'objecte creat. Mutex s'ocupa de les condicions de carrera que són els valors que són força impredictibles i que depenen del canvi dels fils que són conscients del temps. Per implementar l'exemple per a mutex, primer hem d'importar les biblioteques importants i necessàries dels dipòsits. Les biblioteques necessàries són:
$ # inclou
$ # inclou
$ # inclou
La biblioteca 'iostream' ens proporciona una funció per mostrar les dades com a Cout, llegir les dades com a Cin i finalitzar la declaració com a endl. Utilitzem la biblioteca 'thread' per utilitzar els programes o funcions dels fils. La biblioteca 'mutex' ens permet implementar tant el bloqueig com el desbloqueig mutex al codi. Utilitzem el '# include' perquè permet tots els programes relacionats amb la biblioteca inclosos al codi.
Ara, un cop fet el pas anterior, definim la classe mutex o una variable global per al mutex utilitzant el std. Aleshores, creem una funció per al bloqueig i desbloqueig mutex que podríem trucar després al codi. En aquest exemple, anomenem aquesta funció com a bloc. Al cos de la funció de bloc, primer cridem el 'mutex.lock()' i comencem a escriure la lògica del codi.
El mutex.lock() nega l'accés dels altres fils per arribar al nostre objecte o codi creat, de manera que només un fil pot llegir el nostre objecte alhora. A la lògica, executem un bucle for que s'executa a l'índex de 0 a 9. Mostrem els valors al bucle. Una vegada que aquesta lògica es crea al bloqueig mutex després de fer-ne l'operació o després de sortir de la lògica, anomenem el mètode 'mutex.unlock()'. Aquesta trucada al mètode ens permet desbloquejar l'objecte creat des del bloqueig mutex, ja que l'accés de l'objecte a un sol fil es va proporcionar abans i una vegada que l'operació en aquest objecte es fa per un fil alhora. Ara volem que els altres fils també accedeixin a aquest objecte o codi. En cas contrari, el nostre codi es mou en la situació de 'bloqueig' que fa que l'objecte creat amb el mutex romangui en la situació de bloqueig per sempre i cap altre fil podria accedir a aquest objecte. Per tant, es continua executant una operació incompleta. Després d'això, sortim de la funció de bloc i passem a la principal.
En general, simplement mostrem el nostre mutex creat creant els tres fils utilitzant el 'std :: thread_name (cridant la funció de bloc ja creada aquí en la qual hem creat el mutex)' amb els noms thread1, thread2 i thread3, etc. D'aquesta manera es creen els tres fils. A continuació, unim aquests tres fils per executar-los simultàniament cridant al 'nom_fil. Mètode join ()”. I després, retornem el valor igual a zero. L'explicació de l'exemple esmentada anteriorment s'implementa en forma de codi que es pot mostrar a la figura següent:
A la sortida del codi, podem veure l'execució i la visualització dels tres fils un per un. Podem veure fins i tot si la nostra aplicació entra dins de la categoria de multithreading. Tot i així, cap dels fils ha sobreescrit o modificat les dades i compartit el recurs modificat a causa de la implementació del mutex del 'bloc de funció'.
Conclusió
Aquesta guia ofereix una explicació detallada del concepte de la funció mutex utilitzada en C++. Hem comentat quines són les aplicacions multithreading, quins problemes ens hem de trobar a les aplicacions multithreading i per què hem d'implementar el mutex per a aplicacions multithreading. A continuació, vam parlar de la sintaxi del mutex amb l'exemple fictici utilitzant el pseudocodi. A continuació, vam implementar un exemple complet sobre les aplicacions multithreading amb el mutex a l'estudi visual C++.