Hur man implementerar multithreading i C++

Multithreading i C++ är en funktion som gör att man kan utföra flera uppgifter samtidigt samtidigt. En tråd är arbetsenheten för en viss process som exekveras. Många trådar körs oberoende av varandra samtidigt för att utföra multithreading.

Hur man implementerar multithreading i C++

Ett flertrådsprogram har två eller flera delar som har en tendens att köras samtidigt, varje del är känd som en tråd och har en annan väg för exekvering. Många trådar körs oberoende av varandra samtidigt för att utföra multithreading.

Förutsättningar för Multithreading i C++

På Windows kan funktioner relaterade till trådar utföras i C++ 11 och avancerade versioner. När du använder Dev-C++-kompilatorn är den som standard på C++ 3-versionen, så den måste ändras till C++ 11-versionen manuellt. GNU C++11-miljön kan väljas genom att ändra språkstandardinställningarna.

Öppna Dev-C++ kompilatorn och gå till 'Verktyg' i aktivitetsfältet. Välj 'Compiler Options' och välj sedan 'Settings', klicka på 'Code Generation'-blocket, en lista med kommandon visas. Välj GNU C++11 från 'Language Standard(-std)' och klicka sedan på OK. Nu är den här kompilatorn klar för att stödja trådoperationer.

Ladda ner biblioteken från GitHub och placera dem i mappen lib i Cpp-kompilatorn. Anropa dessa bibliotek i programmet med #include 'mingw.thread.h' och header-filer, nedan är dess syntax:

std::thread thread_object ( anropsbar ) ;

Std::-tråden stöds av rubrikfilen #include 'mingw.thread.h' i C++11. Det är en trådklass och representerar en enda tråd. En ny tråd skapas med std::thread och en anropsbar skickas till den. Callable är en körbar kod som exekveras när tråden körs. Callable kan vara någon av de tre typerna nedan:

När ett objekt skapas, startar det en ny tråd, som exekverar koden i den anropbara.

Starta tråd med funktionsobjekt

Ett funktionsobjekt kan användas som ett anropsbart för att starta tråden, överbelastningsoperatören () gör det anropsbart:

klass funktion_objekt_klass {
ogiltig operatör ( ) ( params )
{
Uttalanden;
}
}
std::thread thread_object ( function_object_class ( ) , params )

Överbelastningsfunktionen tillhandahålls till konstruktorn som det första objektet och satserna som det andra objektet.

Starta tråden med funktionspekaren

En funktionspekare definieras och den används sedan som en anropsbar för att starta en tråd:

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

Argument som ska skickas skrivs efter funktionens namn.

Lansering av tråd med Lambda Expression

Trådobjektet kan startas med lambda som anropsbart.

// Definiera ett lambdauttryck
auto f = [ ] ( params )
{
Uttalanden;
} ;

std::thread thread_object ( f, params ) ;

Lambda-uttrycket definieras och parametrarna anropas i det för att starta tråden.

I vissa fall måste tråden stoppas innan den börjar köra nästa kommando. De std::thread::join () funktionen används för att vänta på att tråden ska sluta. Till exempel, om vi tilldelar en uppgift med GUI till tråden, måste vi vänta på dess sluttid för att först ladda det grafiska gränssnittet ordentligt och sedan körs nästa kommando.

int main ( )
{

std::tråd t1 ( anropsbar ) ;
t1.gå med ( ) ;
Uttalanden;
}

Exempel

Detta är ett program som körs för att utföra multithreading med alla tre anropbara. Tre olika anropsbara kör sina respektive kommandon samtidigt tre gånger utan att bli avbrutna av varandra:

#include
#inkludera
använder namnutrymme std;

void foo ( int Z )
{
för ( int i = 0 ; i < Z; i++ ) {
cout << 'Tråd med funktion'
'-pekaren som anropbar \n ' ;
}
}

klass thread_obj {
offentlig:
ogiltig operatör ( ) ( int x )
{
för ( int i = 0 ; i < x; i++ )
cout << 'Tråd med funktion'
'objekt som anropsbart \n ' ;
}
} ;

// huvudkoden
int main ( )
{
cout << 'Tråd 1 och 2 och 3'
'fungerar självständigt'
<< endl;

tråd th1 ( foo, 3 ) ;

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

auto f = [ ] ( int x ) {
för ( int i = 0 ; i < x; i++ )
cout << 'Tråd med lambda'
' uttryck som anropsbart \n ' ;
} ;

tråd th3 ( f, 3 ) ;

th1.join ( ) ;

th2.gå med ( ) ;

th3.gå med ( ) ;

lämna tillbaka 0 ;
}

I detta program används de tre anropbara inklusive funktionspekare, funktionsobjekt och lambda-uttryck för att starta de tre trådarna samtidigt. Tråd 1, 2 och 3 skriver ut sina värden samtidigt, oberoende av varandra, utan att avbrytas av varandra. De trycker sina värden tre gånger. Funktionen join() används för att vänta på att tråden ska sluta.

Utgångarna från alla tre trådarna visas oberoende och upprepas tre gånger. Varje tråd väntar på att den andra ska ta slut först.

Slutsats

Multithreading i C++ är en funktion som gör att man kan utföra flera uppgifter samtidigt samtidigt. Flertrådsprogrammet har två eller flera sektioner som kan köras samtidigt, varje del är känd som en tråd och har en separat väg för exekvering. Det finns tre anropbara för att starta trådar, funktionspekare, funktionsobjekt och lambda-uttryck. Dessa möjliggör multithreading.

Hur man implementerar multithreading i C++