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.
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
Les distinctions entre les processus et le fil
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
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
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.
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.
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.
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
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
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.