Kuidas rakendada multithreading C++-s

Mitme lõimega töötlemine C++ keeles on funktsioon, mis võimaldab sooritada korraga mitut ülesannet. Lõim on konkreetse käivitatava protsessi tööüksus. Mitu lõime käitatakse korraga üksteisest sõltumatult, et teostada mitme lõimega töötlemist.

Kuidas rakendada multithreading C++-s

Mitmelõimelisel programmil on kaks või enam osa, millel on kalduvus töötada samaaegselt, iga osa on tuntud lõimena ja nende täitmiseks on erinev tee. Mitu lõime käitatakse korraga üksteisest sõltumatult, et teostada mitme lõimega töötlemist.

Eeltingimused C++ mitmelõimeliseks kasutamiseks

Windowsis saab lõimedega seotud funktsioone täita C++ 11 ja täiustatud versioonides. Dev-C++ kompilaatori kasutamisel on see vaikimisi C++ 3 versioonil, seega tuleb see käsitsi C++ 11 versiooniks muuta. GNU C++11 keskkonda saab valida keele standardseadeid muutes.

Avage Dev-C++ kompilaator ja minge tegumiribal jaotisse Tööriistad. Valige 'Compiler Options' ja seejärel 'Settings', klõpsake käskude loendi plokil 'Koodi genereerimine'. Valige jaotisest „Keelestandard(-std)” GNU C++11 ja seejärel klõpsake nuppu OK. Nüüd on see kompilaator seadistatud lõime toiminguid toetama.

Laadige raamatukogud alla GitHubist ja asetage need Cpp-kompilaatori lib kausta. Kutsuge neid teeke programmis, kasutades #include 'mingw.thread.h' ja päisefaile, allpool on selle süntaks:

std::lõime lõime_objekt ( helistatav ) ;

Std::lõime toetab päisefail #include “mingw.thread.h” keeles C++11. See on lõime klass ja esindab ühte lõime. Uus lõim luuakse kasutades std::thread ja sellele edastatakse helistatav. Callable on käivitatav kood, mis käivitatakse lõime käivitamisel. Helistatav võib olla mis tahes kolmest allpool toodud tüübist:

Kui objekt luuakse, käivitab see uue lõime, mis käivitab kutsutavas koodis.

Lõime käivitamine funktsiooniobjekti abil

Funktsiooniobjekti saab kasutada lõime käivitamiseks kutsutava objektina, ülekoormusoperaator () muudab selle helistatavaks:

klass funktsiooni_objekti_klass {
tühi operaator ( ) ( parameetrid )
{
avaldused;
}
}
std::lõime lõime_objekt ( funktsiooni_objekti_klass ( ) , params )

Ülekoormusfunktsioon antakse konstruktorile esimese objektina ja avaldused teise objektina.

Threadi käivitamine Function Pointeri abil

Funktsioonikursor on määratletud ja seda kasutatakse seejärel lõime käivitamiseks kutsutavana:

tühine funktsiooni_kutse ( param )
{
avaldused;
}
std::lõime lõime_obj ( function_call, params ) ;

Edastatavad argumendid kirjutatakse funktsiooni nime järele.

Threadi käivitamine Lambda Expressioni abil

Keermeobjekti saab käivitada, kasutades kutsutavana lambdat.

// Defineerige lambda avaldis
auto f = [ ] ( parameetrid )
{
avaldused;
} ;

std::lõime lõime_objekt ( f, params ) ;

Lambda avaldis on määratletud ja selles kutsutakse lõime käivitamiseks välja parameetrid.

Mõnel juhul peab lõim peatuma, enne kui see hakkab järgmist käsku täitma. The std::lõim::liituma () funktsiooni kasutatakse lõime lõppemise ootamiseks. Näiteks juhul, kui määrame lõimele GUI ülesande, peame ootama selle lõpuaega, et GUI esmalt korralikult laadida ja seejärel käivitatakse järgmine käsk.

int main ( )
{

std::lõime t1 ( helistatav ) ;
t1.liituma ( ) ;
avaldused;
}

Näide

See on programm, mis käivitatakse mitme lõimega töötlemiseks, kasutades kõiki kolme kutsutavat. Kolm erinevat kutsutavat täidavad oma vastavaid käske kolm korda samaaegselt, ilma et üksteist segaks:

#include
#include
kasutades nimeruumi std;

tühi foo ( int Z )
{
jaoks ( int i = 0 ; i < Z; i++ ) {
cout << 'Lõime kasutades funktsioon'
' osuti helistatavaks \n ' ;
}
}

klassi lõime_objekt {
avalik:
tühi operaator ( ) ( int x )
{
jaoks ( int i = 0 ; i < x; i++ )
cout << 'Lõime kasutades funktsioon'
' objekti kutsutavaks \n ' ;
}
} ;

// põhikood
int main ( )
{
cout << 'Lõimed 1 ja 2 ja 3'
'töötab iseseisvalt'
<< endl;

niit th1 ( foo, 3 ) ;

niit th2 ( niit_objekt ( ) , 3 ) ;

auto f = [ ] ( int x ) {
jaoks ( int i = 0 ; i < x; i++ )
cout << 'Tread using lambda'
' väljend kutsutavaks \n ' ;
} ;

niit th3 ( f, 3 ) ;

th1.liituma ( ) ;

th2.liituma ( ) ;

th3.liituma ( ) ;

tagasi 0 ;
}

Selles programmis kasutatakse kolme lõime samaaegseks käivitamiseks kolme kutsutavat, sealhulgas funktsiooni osutit, funktsiooniobjekti ja lambda-avaldist. Lõimed 1, 2 ja 3 prindivad oma väärtused samaaegselt, üksteisest sõltumatult, ilma neid katkestamata. Nad trükivad oma väärtused kolm korda välja. Funktsiooni join() kasutatakse lõime lõppemise ootamiseks.

Kõigi kolme lõime väljundid on näidatud sõltumatult ja neid korratakse kolm korda. Iga lõng ootab, kuni teine enne lõpeb.

Järeldus

Mitme lõimega töötlemine C++ keeles on funktsioon, mis võimaldab sooritada korraga mitut ülesannet. Mitme lõimega programmil on kaks või enam sektsiooni, mida saab samaaegselt käivitada, iga osa on tuntud lõimena ja sellel on täitmiseks eraldi tee. Lõimede, funktsiooniosutajate, funktsiooniobjektide ja lambda-avaldiste käivitamiseks on kolm kutsutavat. Need võimaldavad multithreadingut.

Kuidas rakendada multithreading C++-s