Comment utiliser le multithreading en C ++

Multithreading est le concept d'exécution de plusieurs threads d'exécution dans un seul programme. Il s'agit d'une fonctionnalité très utile dans les langages de programmation comme C ++ car il nous permet d'effectuer plusieurs opérations simultanément. En c++, multithreading peut être réalisé via le Bibliothèque, qui fournit un ensemble de classes et de fonctions qui permettent aux développeurs de créer, gérer et contrôler plusieurs threads.

Multithreading est comme le multitâche. Cela signifie que deux fils ou plus s'exécutent simultanément. Dans un tel programme, chaque composant est appelé thread, et chaque thread spécifie un chemin d'exécution unique. Il n'y a pas de support intégré pour multithread Programmes avant C ++ 11. Cette fonctionnalité est plutôt totalement fournie par le système d'exploitation.

Multithreading peut également être appelé diviser un programme en threads plus petits qui exécutent simultanément. La classe de thread, qui est utilisée pour multithreading En C ++, vous permet de construire de nombreux threads et de gérer leur exécution.

Créer des fils en C++

Pour créer un thread en C ++, nous utilisons le Std :: Fil classe, qui est incluse dans la bibliothèque de threads intégrée. UN appelant est fourni comme argument au constructeur d'un objet de la classe Std :: Fil Afin de générer un nouveau fil. Le code exécuté lorsqu'un thread est actif est connu sous le nom appelant. Lorsque nous construisons un Std :: Fil objet, un nouveau thread est établi, qui provoque le code fourni par appelant à courir. Appelant peut être défini en utilisant ces trois méthodes.

Méthode 1: pointeur de fonction

Appelant Les fonctions utilisant un pointeur de fonction peuvent être définies comme celle-ci.

void function_call (paramètres)

Lorsque la fonction a été construite, un objet thread contenant la fonction est généré comme suit:

std :: thread thread_obj (function_call, paramètres);

Méthode 2: objet de fonction

Tout en utilisant l'objet de fonction, nous profitons de l'idée de surcharge de l'opérateur. Le code qui doit être exécuté pendant la formation du thread est contenu dans la fonction surchargée.

class object_class
void opérateur () (paramètres)

// code à exécuter

;
std :: thread thread_object (object_class (), paramètres)

Méthode 3: Expression de lambda

Appelant Les fonctions utilisant une expression de lambda peuvent être définies comme celle-ci.

auto f = [] (paramètres)
// code à exécuter
;
std :: thread thread_object (f, paramètres);

Exemple de multithreading en c++

#inclure
#inclure
Utilisation de Namespace Std;
void func_thread (int n)

pour (int i = 0; i < N; i++)
couter << "Thread 1 :: callable => En utilisant un pointeur de fonction \ n ";


classe thread_obj
public:
void opérateur () (int n)
pour (int i = 0; i < n; i++)
couter << "Thread 2 :: callable => En utilisant un objet fonction \ n ";

;
int main()

auto f = [] (int n)
pour (int i = 0; i < n; i++)
couter << "Thread 3 :: callable => En utilisant une expression lambda \ n ";
;
thread th1 (func_thread, 2);
Thread Th2 (thread_obj (), 2);
thread th3 (f, 2);
TH1.rejoindre();
TH2.rejoindre();
TH3.rejoindre();
retour 0;

Dans le code ci-dessus, nous avons développé trois threads avec trois callmables-un pointeur de fonction, un objet et une expression lambda. Chaque fil est démarré comme deux instances distinctes. Trois threads sont actifs simultanément et séparément, comme indiqué dans la sortie.

Sortir

Avantages et inconvénients du multithreading

Plus de travail peut être fait plus rapidement grâce à multithreading. En effet. Multithreading permet aux programmeurs de faire des activités de réseau, de traiter des photos ou des vidéos et d'effectuer des calculs complexes sans ralentir le reste de l'application. Multithreading aide à rendre les interfaces utilisateur plus réactives. En exécutant le code qui modifie l'écran dans un thread séparé, le thread d'interface utilisateur est gardé pour effectuer d'autres tâches, comme répondre à l'entrée de l'utilisateur. Il en résulte des interfaces utilisateur plus lisses et plus rapides.

Cependant, il y a quelques limites à l'utilisation multithreading. L'un des principaux défis lorsque vous travaillez avec multithread Les programmes évitent les conditions de course. Une condition de course est une situation où deux threads ou plus essaient d'accéder à la même ressource partagée en même temps, conduisant à un comportement imprévisible. Pour éviter les conditions de course, les développeurs utilisent des techniques de synchronisation telles que les mutex, les sémaphores et les barrières.

Conclusion

Multithreading En C ++ est un concept puissant qui permet aux développeurs de créer des programmes qui peuvent effectuer plusieurs tâches simultanément. En utilisant la classe de threads fournie par la bibliothèque, les développeurs peuvent créer, gérer et contrôler plusieurs threads. Multithreading Peut être utilisé pour améliorer les performances, augmenter la réactivité et surmonter les limitations des ressources du système. Cependant, en raison des défis liés à travailler avec multithread Programmes, les développeurs doivent être prudents et utiliser des techniques de synchronisation appropriées pour éviter les conditions de course.