Multithreading in C++ is een functie waarmee u meerdere taken tegelijk kunt uitvoeren. Een thread is de werkeenheid van een bepaald proces dat wordt uitgevoerd. Talrijke threads worden tegelijkertijd onafhankelijk van elkaar uitgevoerd om multithreading uit te voeren.
Hoe multithreading in C++ te implementeren
Een multithread-programma heeft twee of meer delen die de neiging hebben om tegelijkertijd te draaien. Elk deel staat bekend als een thread en heeft een ander uitvoeringspad. Talrijke threads worden tegelijkertijd onafhankelijk van elkaar uitgevoerd om multithreading uit te voeren.
Vereisten voor multithreading in C++
Op Windows kunnen functies met betrekking tot threads worden uitgevoerd in C++ 11 en geavanceerde versies. Wanneer u de Dev-C++-compiler gebruikt, bevindt deze zich standaard in de C++ 3-versie, dus deze moet handmatig worden gewijzigd naar de C++ 11-versie. De GNU C++11-omgeving kan worden geselecteerd door de standaardtaalinstellingen te wijzigen.
Open de Dev-C++ compiler en ga naar “Extra” in de taakbalk. Selecteer “Compileropties” en selecteer vervolgens “Instellingen”, klik op het blok “Codegeneratie” en een lijst met opdrachten zal verschijnen. Selecteer GNU C++11 uit “Taalstandaard(-std)” en klik vervolgens op OK. Nu is deze compiler helemaal klaar om threadbewerkingen te ondersteunen.
Download de bibliotheken van GitHub en plaats ze in de map lib van de Cpp-compiler. Roep deze bibliotheken in het programma aan met #include “mingw.thread.h” en
std::thread thread_object ( opvraagbaar ) ;
De std::thread wordt ondersteund door het headerbestand #include “mingw.thread.h” in C++11. Het is een threadklasse en vertegenwoordigt een enkele thread. Er wordt een nieuwe thread gemaakt met behulp van std::thread en er wordt een opvraagbare thread aan doorgegeven. Oproepbaar is een uitvoerbare code die wordt uitgevoerd wanneer de thread wordt uitgevoerd. Oproepbaar kan een van de drie onderstaande typen zijn:
Wanneer een object wordt gemaakt, wordt er een nieuwe thread gestart, die de code in het opvraagbare object uitvoert.
Lancering van Thread met behulp van Functieobject
Een functieobject kan worden gebruikt als opvraagbaar object om de thread te starten, de overbelastingsoperator () maakt het opvraagbaar:
klasse functie_object_klasse {ongeldige operator ( ) ( parameters )
{
Verklaringen;
}
}
std::thread thread_object ( functie_object_klasse ( ) , param )
De overbelastingsfunctie wordt aan de constructor geleverd als het eerste object en instructies als het tweede object.
Lancering van Thread met behulp van Functieaanwijzer
Er wordt een functieaanwijzer gedefinieerd en deze wordt vervolgens gebruikt als opvraagbare optie om een thread te starten:
ongeldige functie_aanroep ( param ){
Verklaringen;
}
std::thread thread_obj ( function_call, params ) ;
Argumenten die moeten worden doorgegeven, worden achter de naam van de functie geschreven.
Lancering van Thread met behulp van Lambda Expression
Het threadobject kan worden gestart met behulp van lambda als opvraagbaar object.
// Definieer een lambda-expressieautomatische f = [ ] ( parameters )
{
Verklaringen;
} ;
std::thread thread_object ( f, param ) ;
De lambda-expressie is gedefinieerd en de parameters worden erin aangeroepen om de thread te starten.
In sommige gevallen moet de thread stoppen voordat de volgende opdracht wordt uitgevoerd. De std::thread::join () functie wordt gebruikt om te wachten tot de thread eindigt. Als we bijvoorbeeld een GUI-taak aan de thread toewijzen, moeten we wachten op de eindtijd om de GUI eerst correct te laden, waarna de volgende opdracht wordt uitgevoerd.
int. hoofd ( ){
std::thread t1 ( opvraagbaar ) ;
t1.deelnemen ( ) ;
Verklaringen;
}
Voorbeeld
Dit is een programma dat wordt uitgevoerd voor het uitvoeren van multithreading met behulp van alle drie de opvraagbare programma's. Drie verschillende callables voeren hun respectieve commando's driemaal gelijktijdig uit zonder door elkaar te worden onderbroken:
#include#include
namespace std; gebruiken;
leegte fo ( int Z )
{
voor ( int ik = 0 ; i < Z; ik++ ) {
uit << 'Thread met behulp van functie'
'aanwijzer als oproepbaar \N ' ;
}
}
klasse thread_obj {
openbaar:
ongeldige operator ( ) ( int x )
{
voor ( int ik = 0 ; i < X; ik++ )
uit << 'Thread met behulp van functie'
'object als opvraagbaar \N ' ;
}
} ;
// hoofd code
int. hoofd ( )
{
uit << 'Draad 1 en 2 en 3'
'zelfstandig opereren'
<< eind;
draad th1 ( foe, 3 ) ;
draad th2 ( draad_obj ( ) , 3 ) ;
automatische f = [ ] ( int x ) {
voor ( int ik = 0 ; i < X; ik++ )
uit << 'Thread met behulp van lambda'
'-expressie als oproepbaar \N ' ;
} ;
draad th3 ( F, 3 ) ;
th1.join ( ) ;
th2.join ( ) ;
th3.join ( ) ;
opbrengst 0 ;
}
In dit programma worden de drie opvraagbare functies, waaronder de functieaanwijzer, het functieobject en de lambda-expressie, gebruikt om de drie threads gelijktijdig te starten. Threads 1, 2 en 3 drukken hun waarden gelijktijdig af, onafhankelijk van elkaar, zonder door elkaar te worden onderbroken. Ze drukken hun waarden driemaal af. De functie join() wordt gebruikt om te wachten tot de thread is beëindigd.
De uitvoer van alle drie de threads wordt onafhankelijk weergegeven en wordt drie keer herhaald. Elke draad wacht tot de andere als eerste eindigt.
Conclusie
Multithreading in C++ is een functie waarmee u meerdere taken tegelijk kunt uitvoeren. Het multithread-programma heeft twee of meer secties die tegelijkertijd kunnen worden uitgevoerd. Elk onderdeel staat bekend als een thread en heeft een apart pad voor uitvoering. Er zijn drie oproepbare threads, functieaanwijzers, functieobjecten en lambda-expressies. Deze maken multithreading mogelijk.