Linux a beaucoup évolué depuis sa création. Il est devenu le système d'exploitation le plus largement utilisé en ce qui concerne les serveurs et les travaux critiques. Bien qu'il ne soit pas facile de comprendre Linux dans son ensemble, certains aspects fondamentaux de Linux méritent d'être compris.
Dans cet article, nous discuterons des processus Linux, des threads et des processus légers et comprendrons la différence entre eux. Vers la fin, nous discuterons également des différents états des processus Linux.
Processus Linux
Sous une forme très basique, le processus Linux peut être visualisé comme une instance en cours d'exécution d'un programme. Par exemple, ouvrez simplement un éditeur de texte sur votre machine Linux et un processus d'éditeur de texte sera né.
Voici un exemple lorsque j'ai ouvert gedit sur ma machine :
$ gedit & [1] 5560 $ ps -aef | grep gedit 1000 5560 2684 9 17:34 pts/0 00:00:00 gedit
La première commande (gedit &) ouvre la fenêtre gedit tandis que la seconde commande ps (ps -aef | grep gedit) vérifie s'il existe un processus associé. Dans le résultat, vous pouvez voir qu'il existe un processus associé à gedit.
Les processus sont fondamentaux pour Linux car chaque travail effectué par le système d'exploitation est effectué en termes de et par les processus. Pensez à n'importe quoi et vous verrez que c'est un processus. En effet, tout travail destiné à être effectué nécessite des ressources système (qui sont fournies par le noyau) et c'est un processus qui est considéré par le noyau comme une entité à laquelle il peut fournir des ressources système.
Les processus ont la priorité en fonction du contexte du noyau qui les bascule. Un processus peut être préempté si un processus avec une priorité plus élevée est prêt à être exécuté.
Par exemple, si un processus attend une ressource système comme du texte à partir d'un fichier texte conservé sur le disque, le noyau peut planifier un processus de priorité plus élevée et revenir au processus d'attente lorsque les données sont disponibles. Cela maintient le bal pour un système d'exploitation dans son ensemble et donne à l'utilisateur le sentiment que les tâches sont exécutées en parallèle.
Les processus peuvent parler à d'autres processus à l'aide de méthodes de communication inter-processus et peuvent partager des données à l'aide de techniques telles que la mémoire partagée.
Sous Linux, fork() est utilisé pour créer de nouveaux processus. Ces nouveaux processus sont appelés processus enfants et chaque processus enfant partage initialement tous les segments comme le texte, la pile, le tas, etc. jusqu'à ce que l'enfant essaie d'apporter des modifications à la pile ou au tas. En cas de modification, une copie séparée des segments de pile et de tas est préparée pour l'enfant afin que les modifications restent spécifiques à l'enfant. Le segment de texte est en lecture seule, de sorte que le parent et l'enfant partagent le même segment de texte. L'article sur la fonction fork en C explique plus sur fork().
Threads Linux vs processus légers
Les threads sous Linux ne sont rien d'autre qu'un flux d'exécution du processus. Un processus contenant plusieurs flux d'exécution est appelé processus multithread.
Pour un processus non multithread, seul le flux d'exécution est le flux d'exécution principal et, par conséquent, il est également appelé processus à thread unique. Pour le noyau Linux, il n'y a pas de notion de thread. Chaque thread est considéré par le noyau comme un processus séparé, mais ces processus sont quelque peu différents des autres processus normaux. J'expliquerai la différence dans les paragraphes suivants.
Les threads sont souvent mélangés avec le terme processus légers ou LWP. La raison remonte à l'époque où Linux ne prenait en charge les threads qu'au niveau utilisateur. Cela signifie que même une application multithread était considérée par le noyau comme un seul processus. Cela posait de gros défis à la bibliothèque qui gérait ces threads de niveau utilisateur, car elle devait prendre en charge les cas qu'une exécution de thread n'entravait pas si un autre thread lançait un appel bloquant.
Plus tard, l'implémentation a changé et des processus ont été attachés à chaque thread afin que le noyau puisse s'en occuper. Mais, comme indiqué précédemment, le noyau Linux ne les considère pas comme des threads, chaque thread est considéré comme un processus à l'intérieur du noyau. Ces processus sont appelés processus légers.
La principale différence entre un processus léger (LWP) et un processus normal est que les LWP partagent le même espace d'adressage et d'autres ressources comme les fichiers ouverts, etc. Comme certaines ressources sont partagées, ces processus sont considérés comme légers par rapport à d'autres processus normaux. et d'où le nom de processus légers.
Donc, effectivement, nous pouvons dire que les threads et les processus légers sont les mêmes. C'est juste que thread est un terme utilisé au niveau de l'utilisateur tandis que le processus léger est un terme utilisé au niveau du noyau.
Du point de vue de l'implémentation, les threads sont créés à l'aide de fonctions exposées par la bibliothèque pthread compatible POSIX sous Linux. En interne, la fonction clone() est utilisée pour créer un processus normal et léger. Cela signifie que pour créer un processus normal, fork() est utilisé et appelle ensuite clone() avec les arguments appropriés, tandis que pour créer un thread ou un LWP, une fonction de la bibliothèque pthread appelle clone() avec les drapeaux pertinents. Ainsi, la principale différence est générée en utilisant différents drapeaux qui peuvent être passés à la fonction clone().
En savoir plus sur fork() et clone() sur leurs pages de manuel respectives.
Comment créer des threads sous Linux explique plus sur les threads.
États des processus Linux
Le cycle de vie d'un processus Linux normal ressemble à peu près à la vie réelle. Les processus naissent, partagent des ressources avec les parents pendant un certain temps, obtiennent leur propre copie des ressources lorsqu'ils sont prêts à apporter des modifications, passent par différents états en fonction de leur priorité, puis meurent finalement. Dans cette section, nous discuterons des différents états des processus Linux :
- RUNNING - Cet état spécifie que le processus est soit en cours d'exécution, soit en attente d'exécution.
- INTERRUPTIBLE - Cet état spécifie que le processus attend d'être interrompu car il est en mode veille et attend qu'une action se produise qui puisse réveiller ce processus. L'action peut être une interruption matérielle, un signal, etc.
- UN-INTERRUPTIBLE - C'est comme l'état INTERRUPTIBLE, la seule différence étant qu'un processus dans cet état ne peut pas être réveillé en délivrant un signal.
- STOPPED - Cet état spécifie que le processus a été arrêté. Cela peut se produire si un signal tel que SIGSTOP, SIGTTIN, etc. est envoyé au processus.
- TRACED – Cet état spécifie que le processus est en cours de débogage. Chaque fois que le processus est arrêté par le débogueur (pour aider l'utilisateur à déboguer le code), le processus entre dans cet état.
- ZOMBIE - Cet état spécifie que le processus est terminé mais qu'il traîne toujours dans la table des processus du noyau car le parent de ce processus n'a toujours pas récupéré l'état de terminaison de ce processus. Le parent utilise la famille de fonctions wait() pour récupérer le statut de terminaison.
- DEAD - Cet état spécifie que le processus est terminé et que l'entrée est supprimée de la table de processus. Cet état est atteint lorsque le parent récupère avec succès l'état de terminaison comme expliqué dans l'état ZOMBIE.