Sådan implementeres multithreading i C++

Multithreading i C++ er en funktion, der gør det muligt at udføre flere opgaver samtidigt samtidig. En tråd er arbejdsenheden i en bestemt proces, der udføres. Talrige tråde udføres uafhængigt af hinanden på samme tid for at udføre multithreading.

Sådan implementeres multithreading i C++

Et multithread-program har to eller flere dele, der har en tendens til at køre samtidigt, hver del er kendt som en tråd og har en anden vej til udførelse. Talrige tråde udføres uafhængigt af hinanden på samme tid for at udføre multithreading.

Forudsætninger for Multithreading i C++

På Windows kan funktioner relateret til tråde udføres i C++ 11 og avancerede versioner. Mens du bruger Dev-C++ compileren, er den som standard på C++ 3-versionen, så den skal ændres til C++ 11-versionen manuelt. GNU C++11-miljøet kan vælges ved at ændre sprogstandardindstillingerne.

Åbn Dev-C++ compileren og gå til 'Værktøjer' på proceslinjen. Vælg 'Compiler Options' og vælg derefter 'Settings', klik på 'Code Generation' blokken, en liste over kommandoerne vises. Vælg GNU C++11 fra 'Language Standard(-std)', og klik derefter på OK. Nu er denne compiler klar til at understøtte trådoperationer.

Download bibliotekerne fra GitHub og placer dem i lib-mappen i Cpp-kompileren. Kald disse biblioteker i programmet ved hjælp af #include 'mingw.thread.h' og header-filer, nedenfor er dets syntaks:

std::tråd tråd_objekt ( opkaldbar ) ;

Std::threaden understøttes af #include 'mingw.thread.h' header-filen i C++11. Det er en trådklasse og repræsenterer en enkelt tråd. En ny tråd oprettes ved hjælp af std::thread og en callable sendes til den. Callable er en eksekverbar kode, der udføres, når tråden kører. Callable kan være en af de tre typer nedenfor:

Når et objekt er oprettet, starter det en ny tråd, der udfører koden i det callable.

Start af tråd ved hjælp af funktionsobjekt

Et funktionsobjekt kan bruges som et callable til at starte tråden, overload-operatøren () gør det callable:

klasse funktionsobjektklasse {
ugyldig operatør ( ) ( params )
{
Udsagn;
}
}
std::tråd tråd_objekt ( funktionsobjektklasse ( ) , params )

Overbelastningsfunktionen leveres til konstruktøren som det første objekt og sætninger som det andet objekt.

Start af tråd ved hjælp af funktionsmarkør

En funktionsmarkør er defineret, og den bruges derefter som en callable til at starte en tråd:

void function_call ( param )
{
Udsagn;
}
std::tråd tråd_obj ( function_call, params ) ;

Argumenter, der skal vedtages, skrives efter navnet på funktionen.

Lancering af tråd ved hjælp af Lambda Expression

Trådobjektet kan startes med lambda som callable.

// Definer et lambda-udtryk
auto f = [ ] ( params )
{
Udsagn;
} ;

std::tråd tråd_objekt ( f, params ) ;

Lambda-udtrykket er defineret, og parametrene kaldes i det for at starte tråden.

I nogle tilfælde skal tråden stoppe, før den begynder at udføre den næste kommando. Det std::thread::join () funktionen bruges til at vente på, at tråden slutter. For eksempel, hvis vi tildeler en opgave med GUI til tråden, skal vi vente på dens sluttidspunkt for at indlæse GUI’en korrekt først, og derefter vil den næste kommando blive udført.

int main ( )
{

std::tråd t1 ( opkaldbar ) ;
t1.tilslut ( ) ;
Udsagn;
}

Eksempel

Dette er et program, der udføres til at udføre multithreading ved at bruge alle tre callable. Tre forskellige opkaldbare udfører deres respektive kommandoer samtidigt tre gange uden at blive afbrudt af hinanden:

#include
#inkluder
bruger navneområde std;

ugyldigt foo ( int Z )
{
til ( int i = 0 ; jeg < Z; i++ ) {
cout << 'Tråd ved hjælp af funktion'
' pointer som kan kaldes \n ' ;
}
}

klasse thread_obj {
offentlig:
ugyldig operatør ( ) ( int x )
{
til ( int i = 0 ; jeg < x; i++ )
cout << 'Tråd ved hjælp af funktion'
'objekt som kan kaldes \n ' ;
}
} ;

// hovedkode
int main ( )
{
cout << 'Tråd 1 og 2 og 3'
'fungerer selvstændigt'
<< endl;

tråd th1 ( foo, 3 ) ;

tråd th2 ( thread_obj ( ) , 3 ) ;

auto f = [ ] ( int x ) {
til ( int i = 0 ; jeg < x; i++ )
cout << 'Tråd med lambda'
' udtryk som kaldes \n ' ;
} ;

tråd th3 ( f, 3 ) ;

th1.tilslut ( ) ;

th2.tilslut ( ) ;

th3.tilslut ( ) ;

Vend tilbage 0 ;
}

I dette program bruges de tre callable, inklusive funktionsmarkør, funktionsobjekt og lambda-udtryk, til at starte de tre tråde samtidigt. Tråd 1, 2 og 3 udskriver deres værdier samtidigt, uafhængige af hinanden, uden at blive afbrudt af hinanden. De udskriver deres værdier tre gange. join()-funktionen bruges til at vente på, at tråden slutter.

Udgangene fra alle tre tråde vises uafhængigt og gentages tre gange. Hver tråd venter på, at den anden slutter først.

Konklusion

Multithreading i C++ er en funktion, der gør det muligt at udføre flere opgaver samtidigt samtidig. Multithread-programmet har to eller flere sektioner, der kan køre samtidigt, hver del er kendt som en tråd og har en separat sti til udførelse. Der er tre kaldbare til at starte tråde, funktionsmarkører, funktionsobjekter og lambda-udtryk. Disse muliggør multithreading.

Sådan implementeres multithreading i C++