A C ++ köztudottan az egyik leggyorsabb programozási nyelv jó teljesítménnyel, nagy pontossággal és megfelelő memóriakezelő rendszerrel. Ez a programozási nyelv több szál egyidejű végrehajtását is támogatja több erőforrás megosztásával. A többszálú kezelésben a szál csak az olvasási műveletet hajtja végre, amely nem okoz problémát, mivel a szálat nem befolyásolja az, amit a többi szál akkor csinál. De ha ezeknek a szálaknak meg kellett osztaniuk az erőforrásokat közöttük, akkor az egyik szál módosíthatja az adatokat, ami a problémát okozza. Ennek a problémának a kezelésére a C++ „Mutex”-ünk van, amely megakadályozza, hogy több erőforrás hozzáférjen kódunkhoz/objektumunkhoz azáltal, hogy biztosítja a szinkronizálást, amely kimondja, hogy az objektumhoz/kódhoz való hozzáférés egyszerre csak egy szál számára biztosítható, hogy több szál ne tudjon egyszerre hozzáférni ehhez az objektumhoz.
Eljárás:
Megismerjük, hogyan állíthatjuk le egyszerre több szál hozzáférését egy objektumhoz mutex zár segítségével. Szó lesz a mutex zár szintaxisáról, mi az a többszörös szálfűzés, és hogyan kezelhetjük a többszörös szálfűzés okozta problémákat a mutex zár segítségével. Ezután példát veszünk a többszörös szálfűzésre, és megvalósítjuk rajtuk a mutex zárolást.
Szintaxis:
Ha meg akarjuk tanulni, hogyan valósíthatjuk meg a mutex zárolást úgy, hogy megakadályozzuk több szál egyidejű elérését objektumunkhoz vagy kódunkhoz, akkor a következő szintaxist használhatjuk:
$ std :: mutex mut_x
$mut_x. zár ( ) ;
Érvénytelen funkciónév ( ) {
$ // kód, amit el akarunk rejteni a több szál elől, ide kerülne
$mut_x. kinyit ( ) ;
}
Most ezt a szintaxist fogjuk használni az álpéldán és a pszeudo kódban (amit nem tudunk csak úgy futtatni, ahogyan a kódszerkesztőben van), hogy tudassa Önnel, hogyan tudjuk pontosan használni ezt a szintaxist, amint azt a következőkben említettük:
$ std :: mutex mut_x
Üres blokk ( ) {
$mut_x. zár ( ) ;
$ std :: cout << 'Szia' ;
$mut_x. kinyit ( ) ;
}
Példa:
Ebben a példában próbáljuk meg először létrehozni a többszálú műveletet, majd ezt a műveletet mutex zárolással és feloldással vegyük körül, hogy biztosítsuk a műveletek szinkronizálását a létrehozott kóddal vagy objektummal. A Mutex versenyfeltételekkel foglalkozik, amelyek olyan értékek, amelyek meglehetősen kiszámíthatatlanok, és az időtudatos szálak váltásától függenek. A mutex példájának megvalósításához először importálni kell a fontos és szükséges könyvtárakat a tárolókból. A szükséges könyvtárak a következők:
$ # include
$ # include
$ # include
Az „iostream” könyvtár egy olyan funkciót biztosít számunkra, amely az adatokat Cout-ként jeleníti meg, az adatokat Cin-ként olvassa be, és az utasítást endl-ként fejezi be. A „szál” könyvtárat használjuk a szálak programjainak vagy függvényeinek felhasználására. A „mutex” könyvtár lehetővé teszi, hogy a mutex zárolást és feloldást is megvalósítsuk a kódban. Azért használjuk a „# include”-ot, mert ez lehetővé teszi a kódban szereplő könyvtárhoz kapcsolódó összes programot.
Most, miután az előző lépést elvégeztük, definiáljuk a mutex osztályt vagy a mutex globális változóját az std használatával. Ezután létrehozunk egy függvényt a mutex zároláshoz és feloldáshoz, amelyet utólag meghívhatunk a kódban. Ebben a példában ezt a függvényt blokknak nevezzük. A blokkfüggvény törzsében először meghívjuk a „mutex.lock()”-t, és elkezdjük írni a kód logikáját.
A mutex.lock() megtagadja a többi szál hozzáférését, hogy elérjék a létrehozott objektumunkat vagy kódunkat, így egyszerre csak egy szál tudja olvasni az objektumunkat. A logikában egy for ciklust futtatunk, amely az indexen fut 0-tól 9-ig. Megjelenítjük a ciklus értékeit. Miután ez a logika létrejött a mutex zárban, miután a működése befejeződött, vagy a logikából való kilépés után, meghívjuk a „mutex.unlock()” metódust. Ez a metódushívás lehetővé teszi a létrehozott objektum feloldását a mutex zárolásból, mivel az objektum egyetlen szálhoz való hozzáférését korábban biztosítottuk, és ha az objektumon a műveletet egyszerre csak egy szál végzi el. Most azt akarjuk, hogy a többi szál is hozzáférjen ehhez az objektumhoz vagy kódhoz. Ellenkező esetben a kódunk a „patthelyzetben” mozog, ami azt eredményezi, hogy a mutex-szel létrehozott objektum örökre a zárolt helyzetben marad, és semmilyen más szál nem tud hozzáférni az objektumhoz. Ezért a befejezetlen művelet továbbra is végrehajtódik. Ezt követően kilépünk a blokk funkcióból és áttérünk a főre.
A főben egyszerűen megjelenítjük a létrehozott mutexet úgy, hogy létrehozzuk a három szálat az „std :: szál szál_neve (itt meghívjuk a már létrehozott blokkfüggvényt, amelyben létrehoztuk a mutexet)” segítségével a szál1, szál2 és szál3 stb. Így jön létre a három szál. Ezután a „szál_neve” meghívásával összekapcsoljuk ezt a három szálat, hogy egyidejűleg lehessen végrehajtani. join ()” módszer. Ezután a nullával egyenlő értéket adjuk vissza. A példa korábban említett magyarázata a következő ábrán látható kód formájában valósul meg:
A kód kimenetében egyenként láthatjuk mindhárom szál végrehajtását és megjelenítését. Még akkor is láthatjuk, ha az alkalmazásunk a többszálú kategóriájába tartozik. Ennek ellenére egyik szál sem írta felül vagy módosította az adatokat, és nem osztotta meg a módosított erőforrást a „funkcióblokk” mutex megvalósítása miatt.
Következtetés
Ez az útmutató részletes magyarázatot ad a C++-ban használt mutex függvény fogalmára. Megbeszéltük, mik azok a többszálú alkalmazások, milyen problémákkal kell szembesülnünk a többszálú alkalmazásoknál, és miért van szükség a mutex megvalósítására a többszálú alkalmazásokhoz. Ezután megvitattuk a mutex szintaxisát az ál-kódot használó dummy példával. Ezután egy teljes példát implementáltunk a többszálú alkalmazásokra a mutex segítségével a C++ Visual Studio-ban.