Le multithreading en C++ est une fonctionnalité qui permet d'effectuer plusieurs tâches simultanément en simultanéité. Un thread est l'unité de travail d'un processus particulier en cours d'exécution. De nombreux threads s'exécutent indépendamment les uns des autres en même temps pour effectuer du multithreading.
Comment implémenter le multithreading en C++
Un programme multithread comporte deux parties ou plus qui ont tendance à s'exécuter simultanément, chaque partie est connue sous le nom de thread et a un chemin d'exécution différent. De nombreux threads s'exécutent indépendamment les uns des autres en même temps pour effectuer du multithreading.
Pré-requis pour le multithreading en C++
Sous Windows, les fonctions liées aux threads peuvent être exécutées en C++ 11 et dans les versions avancées. Lors de l'utilisation du compilateur Dev-C++, il se trouve par défaut sur la version C++ 3, il doit donc être modifié manuellement vers la version C++ 11. L'environnement GNU C++11 peut être sélectionné en modifiant les paramètres standard du langage.
Ouvrez le compilateur Dev-C++ et accédez à « Outils » dans la barre des tâches. Sélectionnez « Options du compilateur » puis sélectionnez « Paramètres », cliquez sur le bloc « Génération de code » et une liste des commandes apparaîtra. Sélectionnez GNU C++11 dans « Language Standard (-std) », puis cliquez sur OK. Ce compilateur est désormais prêt à prendre en charge les opérations de thread.
Téléchargez les bibliothèques depuis GitHub et placez-les dans le dossier lib du compilateur Cpp. Appelez ces bibliothèques dans le programme en utilisant les fichiers d'en-tête #include « mingw.thread.h » et
std :: thread thread_object ( appelable ) ;
Le std::thread est pris en charge par le fichier d'en-tête #include « mingw.thread.h » en C++11. C'est une classe de thread et représente un seul thread. Un nouveau thread est créé à l'aide de std::thread et un appelable lui est transmis. Callable est un code exécutable, qui est exécuté lors de l'exécution du thread. Callable peut être l’un des trois types indiqués ci-dessous :
Lorsqu'un objet est créé, il lance un nouveau thread qui exécute le code dans l'appelable.
Lancement de Thread à l'aide d'un objet fonction
Un objet fonction peut être utilisé comme appelable pour lancer le thread, l'opérateur de surcharge() le rend appelable :
classe fonction_object_class {opérateur vide ( ) ( paramètres )
{
Déclarations ;
}
}
std :: thread thread_object ( fonction_object_class ( ) , paramètres )
La fonction de surcharge est fournie au constructeur en tant que premier objet et les instructions en tant que deuxième objet.
Lancement de Thread à l'aide du pointeur de fonction
Un pointeur de fonction est défini, et il est ensuite utilisé comme appelable pour lancer un thread :
appel de fonction vide ( paramètre ){
Déclarations ;
}
std :: thread thread_obj ( function_call, paramètres ) ;
Les arguments à transmettre sont écrits après le nom de la fonction.
Lancement de Thread à l'aide d'une expression Lambda
L'objet thread peut être lancé en utilisant lambda comme appelable.
// Définir une expression lambdaautomatique f = [ ] ( paramètres )
{
Déclarations ;
} ;
std :: thread thread_object ( f, paramètres ) ;
L'expression lambda est définie et les paramètres y sont appelés pour lancer le thread.
Dans certains cas, le thread doit s'arrêter avant de commencer à exécuter la commande suivante. Le std :: thread :: join () La fonction est utilisée pour attendre la fin du thread. Par exemple, si nous attribuons une tâche d'interface graphique au thread, nous devons d'abord attendre son heure de fin pour charger correctement l'interface graphique, puis l'exécution de la commande suivante aura lieu.
int main ( ){
std :: fil t1 ( appelable ) ;
t1.joindre ( ) ;
Déclarations ;
}
Exemple
Il s'agit d'un programme exécuté pour effectuer du multithreading en utilisant les trois appelables. Trois callables différents exécutent leurs commandes respectives simultanément trois fois sans être interrompus les uns par les autres :
#include#include
en utilisant l'espace de noms std ;
vide foo ( entier Z )
{
pour ( int je = 0 ; je < Z ; je++ ) {
cout << 'Thread utilisant la fonction'
' pointeur appelable \n ' ;
}
}
classe thread_obj {
publique:
opérateur vide ( ) ( entier x )
{
pour ( int je = 0 ; je < X; je++ )
cout << 'Thread utilisant la fonction'
' objet comme appelable \n ' ;
}
} ;
// Code principal
int main ( )
{
cout << 'Thèmes 1, 2 et 3'
'fonctionner de manière indépendante'
<< fin;
fil th1 ( foo, 3 ) ;
fil th2 ( fil_obj ( ) , 3 ) ;
automatique f = [ ] ( entier x ) {
pour ( int je = 0 ; je < X; je++ )
cout << 'Thread utilisant lambda'
' expression comme appelable \n ' ;
} ;
fil th3 ( F, 3 ) ;
th1.joindre ( ) ;
th2.joindre ( ) ;
th3.joindre ( ) ;
retour 0 ;
}
Dans ce programme, les trois appelables, notamment le pointeur de fonction, l'objet de fonction et l'expression lambda, sont utilisés pour lancer les trois threads simultanément. Les threads 1, 2 et 3 impriment leurs valeurs simultanément, indépendamment les uns des autres, sans être interrompus les uns par les autres. Ils impriment leurs valeurs trois fois. La fonction join() est utilisée pour attendre la fin du thread.
Les sorties des trois threads sont affichées indépendamment et sont répétées trois fois. Chaque thread attend que l'autre se termine en premier.
Conclusion
Le multithreading en C++ est une fonctionnalité qui permet d'effectuer plusieurs tâches simultanément en simultanéité. Le programme multithread comporte deux sections ou plus qui peuvent s'exécuter simultanément, chaque partie est connue sous le nom de thread et dispose d'un chemin d'exécution distinct. Il existe trois appels pour lancer des threads, des pointeurs de fonction, des objets de fonction et des expressions lambda. Ceux-ci permettent le multithreading.