Többszálú a több végrehajtási szál egyetlen programon belüli futtatásának koncepciója. Ez egy nagyon hasznos funkció olyan programozási nyelvekben, mint a C++, mivel lehetővé teszi, hogy több műveletet hajtsunk végre egyidejűleg. C++ nyelven, többszálú keresztül érhető el
Többszálú olyan, mint a multitasking. Ez azt jelenti, hogy két vagy több szál fut egyszerre. Egy ilyen programban minden komponensre szálként hivatkozunk, és minden szál egyedi végrehajtási útvonalat határoz meg. Nincs beépített támogatása többszálú a C++ 11 előtti programok. Ezt a szolgáltatást teljes mértékben az operációs rendszer biztosítja.
Többszálú úgy is hivatkozhatunk, mint egy program kisebb szálakra való felosztására, amelyek párhuzamosan futnak le. A szál osztály, amelyhez használják többszálú C++ nyelven számos szál létrehozását és végrehajtásuk kezelését teszi lehetővé.
Hozzon létre szálakat C++-ban
Szál létrehozásához C++-ban használjuk a std::szál osztály, amely a beépített szálkönyvtárban található. A hívható argumentumként van megadva az osztály objektumának konstruktorának std::szál új szál létrehozásához. Azt a kódot, amely akkor fut le, amikor egy szál aktív hívható . Amikor megszerkesztjük a std::szál objektum esetén egy új szál jön létre, ami a által szolgáltatott kódot okozza hívható futtatni. Hívható Ezzel a három módszerrel határozható meg.
1. módszer: Funkciómutató
Hívható függvénymutatót használó függvények definiálhatók így.
void function_call ( paramétereket )
A függvény létrehozása után a függvényt tartalmazó szálobjektum a következőképpen jön létre:
std::szál thread_obj ( function_call, paraméterek ) ;
2. módszer: Funkcióobjektum
A függvényobjektum használata során kihasználjuk az operátor túlterhelésének gondolatát. A szál kialakítása közben lefutandó kód a túlterhelt függvényben található.
osztály Objektum_osztály {üres kezelő ( ) ( paramétereket )
{
// végrehajtandó kód
}
} ;
std::szál thread_object ( Object_class ( ) , paraméterek )
3. módszer: Lambda kifejezés
Hívható A lambda kifejezést használó függvények így definiálhatók.
auto f = [ ] ( paramétereket ) {// végrehajtandó kód
} ;
std::szál thread_object ( f, paraméterek ) ;
Példa többszálú feldolgozásra C++ nyelven
#include#include
névtér használata std;
void func_thread ( int N )
{
számára ( int i = 0 ; én < N; i++ ) {
cout << '1. szál :: hívható => Függvénymutató használata \n ' ;
}
}
osztály thread_obj {
nyilvános:
üres kezelő ( ) ( int n ) {
számára ( int i = 0 ; én < n; i++ )
cout << '2. szál :: callable => Funkcióobjektum használata \n ' ;
}
} ;
int fő ( )
{
auto f = [ ] ( int n ) {
számára ( int i = 0 ; én < n; i++ )
cout << '3. szál :: callable => Lambda kifejezés használata \n ' ;
} ;
szál th1 ( func_thread, 2 ) ;
szál th2 ( thread_obj ( ) , 2 ) ;
szál th3 ( f, 2 ) ;
th1.csatlakozni ( ) ;
th2.csatlakozni ( ) ;
th3.csatlakozni ( ) ;
Visszatérés 0 ;
}
A fenti kódban három szálat fejlesztettünk ki három különálló szálból hívhatóak -függvénymutató, objektum és lambda-kifejezés. Minden szál két külön példányként indul. Három szál egyidejűleg és külön-külön is aktív, amint az a kimeneten látható.
Kimenet
A multithreading előnyei és hátrányai
Több munka gyorsabban elvégezhető, köszönhetően többszálú . Ez azért van így, mert lehetővé teszi számos szál számára, hogy különböző feladatokat hajtson végre egyszerre. Többszálú lehetővé teszi a programozók számára, hogy hálózati tevékenységeket végezzenek, fényképeket vagy videókat dolgozzanak fel, és bonyolult számításokat végezzenek anélkül, hogy lelassítaná az alkalmazás többi részét. Többszálú segít a felhasználói felületek érzékenyebbé tételében. A képernyőt megváltoztató kód külön szálban történő futtatásával a felhasználói felület szabadon marad más feladatok elvégzésére, például a felhasználói bevitelre való reagálásra. Ez simább és gyorsabb felhasználói felületet eredményez.
A használatnak azonban van néhány korlátozása többszálú . Az egyik legfontosabb kihívás a munka során többszálú programok elkerülik a versenyfeltételeket. A versenyhelyzet olyan helyzet, amikor két vagy több szál egyszerre próbál hozzáférni ugyanahhoz a megosztott erőforráshoz, ami kiszámíthatatlan viselkedéshez vezet. A versenyfeltételek elkerülése érdekében a fejlesztők olyan szinkronizálási technikákat alkalmaznak, mint a mutexek, szemaforok és akadályok.
Következtetés
Többszálú A C++ egy hatékony koncepció, amely lehetővé teszi a fejlesztők számára, hogy olyan programokat hozzanak létre, amelyek egyszerre több feladatot is végrehajthatnak. A könyvtár által biztosított szálosztály használatával a fejlesztők több szálat hozhatnak létre, kezelhetnek és vezérelhetnek. Többszálú használható a teljesítmény javítására, a válaszkészség növelésére és a rendszererőforrás-korlátozások leküzdésére. Azonban a munka során felmerülő kihívások miatt többszálú programokat, a fejlesztőknek óvatosnak kell lenniük, és megfelelő szinkronizálási technikákat kell alkalmazniuk a versenykörülmények elkerülése érdekében.