El multithreading en C++ és una característica que permet realitzar múltiples tasques simultàniament en concurrència. Un fil és la unitat de treball d'un procés concret que s'està executant. Nombrosos fils s'executen independentment els uns dels altres al mateix temps per realitzar multithreading.
Com implementar multithreading en C++
Un programa multifil té dues o més parts que tenen tendència a executar-se simultàniament, cada part es coneix com a fil i té un camí d'execució diferent. Nombrosos fils s'executen independentment els uns dels altres al mateix temps per realitzar multithreading.
Requisits previs per a Multithreading en C++
A Windows, les funcions relacionades amb els fils es poden realitzar en C++ 11 i versions avançades. Mentre s'utilitza el compilador Dev-C++, de manera predeterminada es troba a la versió C++ 3, per la qual cosa s'ha de canviar manualment a la versió C++ 11. L'entorn GNU C++11 es pot seleccionar canviant la configuració estàndard de l'idioma.
Obriu el compilador Dev-C++ i aneu a 'Eines' a la barra de tasques. Seleccioneu 'Opcions del compilador' i, a continuació, seleccioneu 'Configuració', feu clic al bloc 'Generació de codi' i apareixerà una llista de les ordres. Seleccioneu GNU C++ 11 a 'Language Standard(-std)' i feu clic a D'acord. Ara aquest compilador està tot configurat per suportar operacions de fil.
Baixeu les biblioteques de GitHub i col·loqueu-los a la carpeta lib del compilador Cpp. Truqueu aquestes biblioteques al programa utilitzant #include 'mingw.thread.h' i els fitxers de capçalera
std::thread thread_object ( cridable ) ;
El std::thread és compatible amb el fitxer de capçalera #include 'mingw.thread.h' en C++11. És una classe de fil i representa un únic fil. Es crea un fil nou utilitzant std::thread i se li passa una crida. Callable és un codi executable, que s'executa quan s'executa el fil. L'anomenable pot ser qualsevol dels tres tipus que s'indiquen a continuació:
Quan es crea un objecte, s'inicia un nou fil, que executa el codi a l'invocable.
Llançament del fil mitjançant l'objecte de funció
Un objecte de funció es pot utilitzar com a invocable per llançar el fil, l'operador de sobrecàrrega () el fa cridable:
classe classe_objecte_funció {operador nul ( ) ( paràmetres )
{
Declaracions;
}
}
std::thread thread_object ( classe_objecte_funció ( ) , paràmetres )
La funció de sobrecàrrega es proporciona al constructor com a primer objecte i les declaracions com a segon objecte.
Llançament del fil mitjançant el punter de funció
Es defineix un punter de funció i després s'utilitza com a invocable per llançar un fil:
void function_call ( param ){
Declaracions;
}
std::thread thread_obj ( function_call, paràmetres ) ;
Els arguments a passar s'escriuen després del nom de la funció.
Llançament del fil mitjançant l'expressió Lambda
L'objecte thread es pot llançar utilitzant lambda com a invocable.
// Definiu una expressió lambdaautomàtic f = [ ] ( paràmetres )
{
Declaracions;
} ;
std::thread thread_object ( f, paràmetres ) ;
Es defineix l'expressió lambda i s'hi criden els paràmetres per iniciar el fil.
En alguns casos, el fil s'ha d'aturar abans que comenci a executar la següent ordre. El std::thread::join () La funció s'utilitza per esperar que finalitzi el fil. Per exemple, en cas que assignem una tasca de GUI al fil, haurem d'esperar al seu moment d'acabament per carregar correctament la GUI primer i després es produiria l'execució de la següent ordre.
int principal ( ){
std::fil t1 ( cridable ) ;
t1.unir-se ( ) ;
Declaracions;
}
Exemple
Aquest és un programa que s'executa per realitzar multithreading utilitzant els tres invocables. Tres invocables diferents executen les seves respectives ordres simultàniament tres vegades sense ser interromputs els uns pels altres:
#inclou#inclou
utilitzant namespace std;
foo buit ( int Z )
{
per ( int i = 0 ; i < Z; i++ ) {
cout << 'Funció d'ús del fil'
' punter com a trucable \n ' ;
}
}
classe thread_obj {
públic:
operador nul ( ) ( int x )
{
per ( int i = 0 ; i < x; i++ )
cout << 'Funció d'ús del fil'
'objecte com a cridable \n ' ;
}
} ;
// codi principal
int principal ( )
{
cout << 'Fils 1, 2 i 3'
'funcionar de manera independent'
<< endl;
fil th1 ( foo, 3 ) ;
fil th2 ( fil_obj ( ) , 3 ) ;
automàtic f = [ ] ( int x ) {
per ( int i = 0 ; i < x; i++ )
cout << 'Fil utilitzant lambda'
'expressió com a cridable \n ' ;
} ;
fil th3 ( f, 3 ) ;
th1.uneix-te ( ) ;
th2.join ( ) ;
th3.join ( ) ;
tornar 0 ;
}
En aquest programa, s'utilitzen els tres fils invocables, inclosos el punter de funció, l'objecte de funció i l'expressió lambda per llançar els tres fils simultàniament. Els fils 1, 2 i 3 imprimeixen els seus valors simultàniament, independentment els uns dels altres, sense que els interrompin. Imprimeixen els seus valors tres vegades. La funció join() s'utilitza per esperar que finalitzi el fil.
Les sortides dels tres fils es mostren de manera independent i es repeteixen tres vegades. Cada fil espera que l'altre acabi primer.
Conclusió
El multithreading en C++ és una característica que permet realitzar múltiples tasques simultàniament en concurrència. El programa multifil té dues o més seccions que es poden executar simultàniament, cada part es coneix com a fil i té un camí d'execució independent. Hi ha tres invocables per llançar fils, punters de funció, objectes de funció i expressions lambda. Aquests permeten el multithreading.