A többszálú C++-ban egy olyan szolgáltatás, amely lehetővé teszi több feladat egyidejű, párhuzamos végrehajtását. A szál egy adott folyamat munkaegysége. Számos szál egymástól függetlenül fut egyszerre a többszálú feldolgozás érdekében.
Hogyan valósítsuk meg a többszálas működést C++-ban
A többszálú program két vagy több részből áll, amelyek hajlamosak egyidejűleg futni, mindegyik részt szálnak nevezik, és különböző végrehajtási útvonalaik vannak. Számos szál egymástól függetlenül fut egyszerre a többszálú feldolgozás érdekében.
Előfeltételek a Multithreading C++ nyelven
Windows rendszeren a szálakkal kapcsolatos funkciók a C++ 11 és a haladó verziókban is végrehajthatók. A Dev-C++ fordító használata közben alapértelmezés szerint a C++ 3-as verzión van, ezért manuálisan kell átállítani a C++ 11-es verzióra. A GNU C++11 környezet a szabványos nyelvi beállítások módosításával választható ki.
Nyissa meg a Dev-C++ fordítót, és lépjen az „Eszközök” elemre a tálcán. Válassza a „Fordító beállításai”, majd a „Beállítások” lehetőséget, kattintson a „Kódgenerálás” blokkra, és megjelenik a parancsok listája. Válassza ki a GNU C++11-et a „Language Standard(-std)” listából, majd kattintson az OK gombra. Most ez a fordító be van állítva a szálműveletek támogatására.
Töltse le a könyvtárakat a GitHubról és helyezze el őket a Cpp fordító lib mappájába. Hívja meg ezeket a könyvtárakat a programban az #include „mingw.thread.h” és a
std::szál thread_object ( hívható ) ;
Az std::szálat a C++11 #include „mingw.thread.h” fejlécfájlja támogatja. Ez egy szálosztály, és egyetlen szálat képvisel. Egy új szál jön létre az std::thread használatával, és egy hívható szál kerül átadásra. A Callable egy végrehajtható kód, amely a szál futása közben fut le. A hívható az alábbi három típus bármelyike lehet:
Egy objektum létrehozásakor egy új szálat indít el, amely végrehajtja a hívható kódot.
A szál indítása a Function Object használatával
Egy függvényobjektum hívhatóként használható a szál elindításához, a túlterhelés operátor () hívhatóvá teszi:
osztály függvény_objektum_osztály {üres kezelő ( ) ( params )
{
Nyilatkozatok;
}
}
std::szál thread_object ( function_object_class ( ) , params )
A túlterhelési függvényt a konstruktor első objektumként, az utasításokat pedig második objektumként kapja meg.
A Thread indítása a Function Pointer segítségével
Egy függvénymutatót definiálunk, majd hívhatóként használják egy szál indításához:
void function_call ( param ){
Nyilatkozatok;
}
std::szál thread_obj ( function_call, params ) ;
Az átadandó argumentumokat a függvény neve után írjuk.
A Thread indítása a Lambda Expression használatával
A szál objektum a lambda használatával indítható hívhatóként.
// Határozzon meg egy lambda kifejezéstauto f = [ ] ( params )
{
Nyilatkozatok;
} ;
std::szál thread_object ( f, params ) ;
A lambda kifejezés definiálva van, és a paraméterek meghívása a szál elindításához.
Egyes esetekben a szálnak le kell állnia, mielőtt elkezdené végrehajtani a következő parancsot. A std::szál::csatlakozás () függvény arra szolgál, hogy megvárja a szál végét. Például abban az esetben, ha egy GUI-feladatot rendelünk a szálhoz, először meg kell várnunk a befejezési idejét, hogy megfelelően betöltsük a grafikus felhasználói felületet, majd megtörténik a következő parancs végrehajtása.
int fő ( ){
std::szál t1 ( hívható ) ;
t1.csatlakozni ( ) ;
Nyilatkozatok;
}
Példa
Ez egy olyan program, amely többszálú művelet végrehajtására fut mindhárom hívható használatával. Három különböző hívható hajtja végre a megfelelő parancsokat egyidejűleg háromszor egymás megszakítása nélkül:
#include#include
névtér használata std;
üres foo ( int Z )
{
számára ( int i = 0 ; én < Z; i++ ) {
cout << 'Szál a funkció használatával'
' mutató hívhatóként \n ' ;
}
}
osztály thread_obj {
nyilvános:
üres kezelő ( ) ( int x )
{
számára ( int i = 0 ; én < x; i++ )
cout << 'Szál a funkció használatával'
' objektumot hívhatóként \n ' ;
}
} ;
// fő kód
int fő ( )
{
cout << '1. és 2. és 3. szál'
„önállóan működik”
<< endl;
szál th1 ( fú, 3 ) ;
szál th2 ( thread_obj ( ) , 3 ) ;
auto f = [ ] ( int x ) {
számára ( int i = 0 ; én < x; i++ )
cout << 'Cérna lambda használatával'
' kifejezés hívható \n ' ;
} ;
szál th3 ( f, 3 ) ;
th1.csatlakozni ( ) ;
th2.csatlakozni ( ) ;
th3.csatlakozni ( ) ;
Visszatérés 0 ;
}
Ebben a programban a három hívható, beleértve a függvénymutatót, a függvényobjektumot és a lambda kifejezést, a három szál egyidejű indítására használják. Az 1., 2. és 3. szál párhuzamosan, egymástól függetlenül nyomtatja ki az értékeit, anélkül, hogy egymást megszakítanák. Háromszor nyomtatják ki értékeiket. A join() függvény arra szolgál, hogy megvárja a szál végét.
Mindhárom szál kimenetei egymástól függetlenül láthatók, és háromszor ismétlődnek. Mindegyik szál először a másik végére vár.
Következtetés
A többszálú C++-ban egy olyan szolgáltatás, amely lehetővé teszi több feladat egyidejű, párhuzamos végrehajtását. A többszálú programnak két vagy több szakasza van, amelyek egyidejűleg is futhatnak, mindegyik rész szálként ismert, és külön elérési útvonala van a végrehajtáshoz. Három hívható szál, függvénymutató, függvényobjektum és lambda-kifejezés indítható. Ezek lehetővé teszik a többszálú feldolgozást.