Le flux de séquence unique d'un processus peut être appelé un fil. Les threads sont souvent appelés «processus légers» car ils ont certaines caractéristiques avec des processus. Une classe doit représenter des fils d'exécution distincts. Un seul thread d'exécution est représenté par le thread de classe. Plusieurs fonctions peuvent s'exécuter immédiatement à cause des threads. Lorsqu'un objet de thread est créé, il commence instantanément à s'exécuter (soumis à tout retard de planification du système d'exploitation) à partir de la fonction la plus élevée spécifiée comme constructeur de fonction. La valeur définie de la méthode est ignorée et std :: terminer est invoquée si elle sort en augmentant une erreur.

Types de fils

Le flux de série particulier d'un processus est appelé fil. Les threads sont désignés comme des procédures insignifiantes car elles sont similaires aux processus à bien des égards. Bien que les threads soient opérés séquentiellement, ils semblent s'exécuter simultanément. Il existe différents états pour chaque fil.

• un compteur électronique
• un ensemble de registres
• une zone d'étagère

Processus

Essentiellement, les processus sont les programmes qui sont expédiés de l'État prêt et prévu pour l'exécution dans le CPU. Le concept de processus est détenu par PCB (bloc de contrôle du processus). Un processus peut produire ce que l'on appelle des «processus enfants» ou de nouveaux processus. Le processus prend plus de temps à terminer car il est isolé, ce qui signifie qu'il ne partage pas de mémoire avec d'autres processus. L'un des états suivants pour le processus pourrait être présent: nouveau, prêt, courir, attendre, terminer ou suspendre.

Threads

Un thread est un module d'un processus. Un processus peut avoir plusieurs threads et tous ces threads sont contenus à l'intérieur de la méthode. Trois états existent pour un fil: en cours d'exécution, prêt et bloqué. Le thread se termine plus rapidement que le processus mais il n'isole pas comme le processus.

Les caractéristiques communes entre les fils et les processus comprennent

• Un seul thread ou processus peut être opérationnel à la fois.
• Exécution successive à l'intérieur du processus.
• La capacité de générer des enfants.

Les distinctions entre les processus et le fil

• Les processus sont auto-régulés; Les fils ne sont pas.
• Bien que les processus peuvent ou non s'entraider, les fils sont conçus pour le faire.

Thread au niveau de l'utilisateur

Il est mis en pratique dans la bibliothèque au niveau de l'utilisateur; Les appels système ne sont pas utilisés pour les construire. La commutation de thread ne nécessite pas d'appel de système d'exploitation ou d'interruption du noyau. Le noyau les gère comme s'ils étaient des processus à thread unique car il n'est pas au courant du fil au niveau de l'utilisateur.

Avantages

• Les seuls attributs d'un thread sont un espace de pile, un pointeur de pile et un registre shift.
• Puisque le noyau ne fait aucun ajustement, la création est simple.
• En raison de l'absence d'appels du système d'exploitation, la commutation de thread est rapide.
• Il est compatible avec les systèmes d'exploitation qui interdisent le multi-threading.

Un fil de niveau du noyau

Les fils sont gérés par le noyau. De plus, le noyau garde également une trace des processus en utilisant le tableau de processus conventionnel. Le noyau OS a des appels système pour gérer et créer des threads.

Avantages

• Étant donné que le noyau a des informations complètes sur les threads du système.
• Le planificateur peut décider de donner des processus avec un nombre élevé de threads supplémentaires.
• Bon pour bloquer régulièrement les programmes.

Multi-threading:

Un autre nom pour un fil est un processus léger. En divisant un processus en plusieurs fils, le parallélisme est destiné à être réalisé. Par exemple, de nombreux onglets dans un navigateur pourraient représenter divers threads. Plusieurs threads sont utilisés par MS Word, y compris un pour le traitement des entrées et un autre pour la mise en forme du texte.

Définir une fonction thread ()

Un thread de classe se réfère à un thread particulier d'implémentation. En C ++, le terme «classe de thread» fait référence à la classe de threads std ::. Une fois l'objet Threads lié créé, la méthode de niveau supérieur qui a été fournie dans le cadre de l'accord de constructeur de fonction est là où l'exécution du thread commence. Le code d'implémentation qui doit être invoqué recevra un nouvel objet de thread qui a été créé pour démarrer un thread.

Comme cela a été dit plus tôt, le thread STD :: est nécessaire pour démarrer un nouveau fil et le fil doit également être appelable. Un callable est un programme qui doit être exécuté lorsque le thread est actif. En d'autres termes, si un nouveau thread est requis, un appelable doit être fourni comme argument au constructeur d'un objet pour std :: thread. Après cela, le thread nouvellement généré commence et la fonction fournie callable est exécutée.

Processus vs threads

La distinction principale est que, alors que les processus s'exécutent dans différentes zones de mémoire, les fils dans un seul processus partageaient un espace mémoire. Parce que les threads ne sont pas complètement indépendants les uns des autres comme les processus, ils partagent leurs ressources du système d'exploitation, leur section de code et leur section de données avec d'autres threads.

Les threads ont des avantages par rapport aux processus

• Réactivité: Si un processus est divisé en de nombreux threads, la sortie de chaque thread peut être retournée dès qu'il a fini de fonctionner.
• Commutateur de contexte plus rapide: les commutateurs de contexte entre les threads se produisent plus rapidement que les commutateurs de contexte dans un processus. Le CPU doit faire plus de frais généraux en raison des changements de contexte de processus.
• Utilisation efficace du système multiprocesseur: Si un processus contient de nombreux threads, nous pouvons planifier ces threads sur différents processeurs. En conséquence, ce serait une exécution de processus plus rapide.
• La communication est facilitée par le fait que plusieurs threads partagent un espace d'adressage. En cours, nous devons adhérer à une méthode de communication particulière pour la communication à deux processus.
• Partage des ressources: tous les threads dans un processus peuvent partager des ressources telles que le code, les données et les fichiers.
• Capacité du système stimulé: Lorsqu'une tâche est séparée en plusieurs threads, chaque opération de thread est traitée comme une fonction, augmentant le nombre de méthodes effectuées dans un temps donné améliore la capacité du système.

Fonction du thread en C++

Dans un système d'exploitation, ils fournissent (thread POSIX) pour les fonctions, ces fonctions liées aux fonctions. Nous pouvons faire beaucoup de fils de cette façon pour prendre en charge le flux de processus simultané. Il fonctionne mieux sur les systèmes avec plusieurs processeurs ou cœurs, où la vitesse d'exécution peut être réalisée en implémentant des threads au niveau du noyau. Les gains peuvent également être réalisés dans des systèmes avec un seul processeur en tirant parti des IO ou d'autres services système qui ont tendance à en suspendre les processus.

Fonction Créer ()

pthread_create: nouveau thread crée

Paramètres

• Thread: un pointeur vers une valeur entière non signée qui contient l'ID de thread du fil le plus récent qui a été démarré.
• Att: Attributs d'un fil, comme son état détaché, la stratégie de planification, l'adresse de pile, etc., sont définis par une structure appelée att. Pour les propriétés du thread par défaut, réglé sur null.
• Routine de démarrage: un pointeur vers le sous-programme de démarrage d'un thread. La fonction n'a qu'un seul attribut mais une structure doit être utilisée si plusieurs valeur doivent être fournies à la fonction.
• Arg: un pointeur vers un vide qui contient un pointeur vers les paramètres de la fonction tels que fournis par l'argument précédent.

Fonction de sortie ()

pthread_exit: utilisé pour arrêter d'utiliser un fil

Paramètres
Révéler, un pointeur vers un entier qui contient l'état de retour du thread est un paramètre requis pour cette procédure. Tout fil en attente pour rejoindre ce thread doit être en mesure d'afficher l'état de retour car la portée de cette variable doit être globale.

Fonction join ()

pthread_join: utilisé pour quitter le fil en attente

Paramètres

• TH: Le fil en attente l'identifiant du fil.
• Retour du thread: un pointeur vers l'emplacement où le thread décrit dans l'état de sortie est enregistré.

Fonction égale ()

pthread_equal: détermine si deux threads sont similaires ou non. La fonction renvoie un nombre non nul si les deux threads sont égaux, sinon zéro.

ST :: Création de threads

En C ++, les threads sont construits à l'aide de la classe de threads std ::. Un thread est un flux d'exécution unique; Il est similaire d'avoir une aide à une tâche pendant que vous en terminez un autre simultanément. Une fois que tout le code du thread a été exécuté, il s'arrête. Lors de l'établissement d'un fil, quelque chose doit être passé pour être exécuté dessus. Les objets énumérés ci-dessous peuvent être transmis à un fil.

Types de membres

ID: ID de thread (public)
Native_handle_type: native_handle_type (public)

Le thread permet l'exécution simultanée de plusieurs tâches. En C ++, le terme «classe de thread» fait référence à la classe de threads std ::. Un nouvel objet de thread doit être généré pour démarrer un thread et il doit être fourni au code d'exécution qui doit être appelé. La méthode de niveau supérieur qui a été fournie dans le cadre de l'accord de constructeur de fonction est le début de l'exécution du thread après la création de l'objet Threads lié.

Objet utilisable en utilisant

Un objet pourrait être rendu appelable en utilisant cette méthode. Pour cela, une classe est requise et l'opérateur () doit être surchargé dans cette classe. Le logiciel qui doit s'exécuter lorsque le thread est formé est inclus dans les méthodes surchargées.

Pointeur utilisable en utilisant

Un pointeur sera rendu appelable en utilisant cette méthode. Dans l'objet thread, la liste des paramètres ou des arguments envoyés à la méthode apparaît à côté du nom de la fonction.

Pointeur de fonction appelable à l'aide

Le donner à l'objet de thread pour l'exécution atteint le résultat souhaité. Le constructeur de fonction de l'objet Thread reçoit une expression de lambda nommée «LM» comme son premier argument avant de recevoir ses arguments comme deuxième argument.

Discutons de différents exemples de fonctions de thread std ::.

Exemple 1

Dans ce cas, nous utiliserons un fil avec un pointeur.

#inclure
#inclure
test de classe

public:
void Execute (Std :: String Commande)

pour (int i = 0; i < 8; i++)

std :: cout<

;
int main()

Test * testptr = new test ();
std :: thread th (& test :: exécuter, testptr, "valeurs");
e.rejoindre();
Supprimer TestPtr;
retour 0;

Tout d'abord, nous incluons les fichiers en en-têtes et dans le programme. Nous créons la classe et spécifions son nom «test». Ensuite, nous utilisons la méthode publique et exécutons la commande String. Après avoir exécuté la commande String, nous demanderons une boucle et une incrément (0 à 8). Ici, nous employons la déclaration «cout». Ensuite, nous appelons la fonction principale (). Parallèlement à cela, nous appelons le «test» de classe et utilisons un pointeur dedans. Ensuite, le fil passe le pointeur. Ensuite, nous utilisons la fonction join (), supprimez le pointeur de test et entrez «retour 0».

Exemple 2

Dans ce cas, nous utiliserons un fil sans pointeur.

#inclure
#inclure
nom du cours

public:
Test de void statique (Commande Std :: String)

pour (int i = 0; i < 3; i++)

std :: cout<

;
int main()

std :: thread th (& name :: test, "name");
e.rejoindre();
retour 0;

Utilisez des fichiers d'en-tête et . Créer une classe et le titre de la classe est «Nom». Nous utilisons la méthode publique et la ligne suivante utilise une fonction de membre statique et nous passons ici la chaîne. Utilisez la boucle 'for' puis initialisez les valeurs de 0 à 3. La déclaration «cout» est utilisée pour représenter la valeur. Dans la ligne suivante, nous invoquons la fonction principale (), utilisons du thread et passons les valeurs sans utiliser de pointeur. Ensuite, nous utilisons la fonction join () et entrons «retour 0».

Exemple 3

Ici, nous allons appliquer l'opérateur vide.

#inclure
#inclure
Utilisation de Namespace Std;
classe Lab
public:
vide opérateur () (int a)

pour (int i = 0; i < a; i++)
couter << "Number of threads :" << i << "\n";

;
int main()

Thread T2 (lab (), 6);
T2.rejoindre();
retour 0;

Dans ce code, nous intégrons les fichiers d'en-tête requis , . Nous utilisons l'espace de noms standard en tant que MST. Nous ajoutons une classe nommée «laboratoire» et utilisons sa méthode publique. Ensuite, utilisez l'opérateur vide et initialisez une variable «A» dedans. Ici, nous utiliserons la boucle «pour» de 0 à la valeur de la variable «A». De plus, nous imprimerons une déclaration «Nombre de threads» en utilisant l'instruction «cout». Nous invoquons la fonction principale (). Dans ce domaine, un thread ayant la valeur 6 sera déclaré. Lorsqu'un thread reçoit un appel, il exécute un code et affiche le message à l'écran.

Conclusion

Dans ce guide, nous avons parlé du fil dans les fonctions C ++. Ensuite, nous observons différentes fonctions de fil en C++. Nous avons défini le fil et aussi ses types. Nous avons également mentionné différents paramètres du fil. Nous avons exécuté de nombreux types de codes. Dans le premier code, nous avons utilisé un thread avec un pointeur, c'est une fonction membre non statique. Deuxièmement, dans le code, nous utilisons du thread sans pointeur, c'est une fonction de membre statique. Troisième et dernier code, nous avons utilisé l'opérateur vide et lorsqu'un thread a obtenu la valeur, il a montré le message à l'écran.