Table des matières
1. L'architecture de Von Neumann
2. Le but de la conception du système d'exploitation
4. Afficher le processus et terminer
5. Obtenir l'identifiant du processus via l'appel système
6. Créer un processus via un appel système - fork
1. L'architecture de Von Neumann
Nos ordinateurs communs, tels que les ordinateurs portables. La plupart de nos ordinateurs peu communs, tels que les serveurs, obéissent au système von Neumann.
Voici un schéma de l'architecture de von Neumann :
Les ordinateurs que nous connaissons sont composés de périphériques d'entrée , de mémoire , d'unités arithmétiques , de contrôleurs et de périphériques de sortie .
- Unité d'entrée : clavier, souris, scanner, tablette, carte réseau, disque, etc. ;
- Unité centrale de traitement (CPU) : Contient des calculatrices et des contrôleurs, etc. ;
- Unité de sortie : écran, carte réseau, imprimante, etc.
Quelques points doivent être soulignés à propos de von Neumann :
- Le stockage fait ici référence à la mémoire ;
- Indépendamment de la situation du cache, le processeur ici ne peut et ne peut que lire et écrire dans la mémoire, et ne peut pas accéder aux périphériques (périphériques d'entrée ou de sortie);
- Les périphériques (périphériques d'entrée ou de sortie) ne peuvent être écrits ou lus à partir de la mémoire que s'ils veulent entrer ou sortir des données ;
- En un mot, tous les appareils ne peuvent traiter directement que de la mémoire .
Nos données doivent d'abord être chargées du disque dans la mémoire, puis lues et calculées par le CPU, charger à nouveau les résultats calculés dans la mémoire, et enfin écrire les données sur le disque à partir de la mémoire, et nous donner les données via le périphérique de sortie.
Pourquoi le CPU ne peut-il pas accéder directement aux périphériques ?
Parce que les périphériques d'entrée et de sortie sont appelés périphériques, les périphériques sont généralement très lents, comme les disques, par rapport à la mémoire, sa vitesse est très lente, mais la vitesse de calcul du CPU est en effet très rapide. C'est comme si la vitesse de lecture du disque était très lente, mais la vitesse de calcul du processeur est très rapide, mais la vitesse globale est toujours dominée par la vitesse de lecture du disque, de sorte que l'efficacité globale est dominée par l'extérieur.
La compréhension de von Neumann ne doit pas s'arrêter au concept, mais approfondir la compréhension du flux de données logicielles. Veuillez expliquer, à partir du moment où vous vous connectez à QQ et commencez à discuter avec un ami, le processus de flux de données. À partir du moment où vous ouvrez la fenêtre, commencez à lui envoyer un message, au processus de flux de données après qu'il ait reçu le message. Et si le fichier est envoyé sur qq ?
Lisez d'abord les informations du clavier et chargez-les dans la mémoire , puis envoyez les données de la mémoire au périphérique de sortie (carte réseau) via une série d'opérations, puis envoyez les données au périphérique d'entrée de l'ami (carte réseau) via une série d'opérations réseau, l'ordinateur de l'ami lit les données du périphérique d'entrée vers la mémoire , puis envoie les informations à l'ordinateur de l'ami via le périphérique de sortie (affichage).
2. Système d'exploitation
1. Conception
Tout système informatique contient une collection de base de programmes appelés système d'exploitation (OS). De manière générale, le système d'exploitation comprend :
- Noyau (gestion des processus, gestion de la mémoire, gestion des fichiers, gestion des pilotes) ;
- D'autres programmes (tels que des bibliothèques de fonctions, des programmes shell, etc.).
Un système d'exploitation est un logiciel qui gère les ressources matérielles et logicielles. Pourquoi le système d'exploitation gère-t-il les logiciels et le matériel ?
Parce que le système d'exploitation doit bien gérer les ressources logicielles et matérielles, et doit fournir aux utilisateurs un bon environnement d'exécution (sûr, stable, efficace, riche en fonctionnalités, etc.).
L'essence de la gestion du système d'exploitation : d'abord décrire, puis organiser .
- Description : décrire diverses données à travers la structure de la structure ;
- Organisation : Organisez et gérez les données grâce à des structures de données efficaces telles que des listes chaînées.
Dans un ordinateur, le système d'exploitation équivaut à notre gestionnaire , le pilote matériel équivaut à notre exécuteur et le logiciel est notre géré .
Tout d'abord, le système d'exploitation ne fait confiance à personne … Tout comme nous sommes banquiers, nous allons souvent à la banque pour économiser de l'argent, mais les banques nous font-elles confiance ? Afin d'éviter une destruction malveillante par certains utilisateurs et de causer des dommages au système d'exploitation, le système d'exploitation n'expose pas toutes ses fonctions mais utilise des appels système pour accéder au système d'exploitation. Comme le coût d'utilisation des appels système peut être élevé, certaines personnes ont ensuite réalisé un développement logiciel secondaire sur cette base, aboutissant à une interface graphique , un shell et un ensemble d'outils .
Appels système et fonctions de bibliothèque
- Du point de vue du développement, le système d'exploitation apparaîtra comme un tout au monde extérieur, mais il exposera une partie de son interface pour le développement de niveau supérieur.Cette partie de l'interface fournie par le système d'exploitation est appelée un appel système ;
- Dans l'utilisation des appels système, les fonctions sont relativement basiques et les exigences pour les utilisateurs sont relativement élevées. Par conséquent, les développeurs intéressés peuvent correctement encapsuler certains appels système pour former une bibliothèque. Avec une bibliothèque, il est très avantageux pour les utilisateurs de niveau supérieur ou Les développeurs effectuent un développement secondaire.
2. Le but de la conception du système d'exploitation
- Interagir avec le matériel et gérer toutes les ressources matérielles et logicielles ;
- Fournir un bon environnement d'exécution pour les programmes utilisateur (applications).
La structure du système informatique est en couches, et il n'est généralement pas possible de sauter une certaine couche
3. Processus
1. Concepts de base
- Concepts manuels : une instance d'exécution d'un programme, un programme en cours d'exécution, etc. ;
- Point de vue du noyau : Agit comme l'entité qui alloue les ressources système (temps CPU, mémoire).
Lorsque nous ouvrirons le gestionnaire de tâches, nous constaterons que ces fichiers exécutables en cours d'exécution sont tous des processus.
2. Décrire le processus-PCB
- Les informations de processus sont placées dans une structure de données appelée bloc de contrôle de processus , qui peut être comprise comme une collection d' attributs de processus ;
- Le manuel s'appelle PCB (process control block), et le PCB sous le système d'exploitation Linux est : task_struct
Un type de task_struct-PCB
- La structure décrivant le processus sous Linux est appelée task_struct ;
- task_struct est une structure de données du noyau Linux qui est chargée dans la RAM (mémoire) et contient des informations de processus.
Lorsque le système d'exploitation décrit d'abord notre processus, puis l'organise, il crée d'abord une structure avec les attributs communs de notre programme, puis crée un objet de structure pour chacun de nos processus.C'est le processus décrit en premier. Ensuite, notre système d'exploitation utilisera des structures de données caractéristiques (telles que des listes chaînées) pour organiser nos objets de structure, ce qui est le processus de post-organisation. Ensuite, la gestion des processus de notre système d'exploitation sera convertie en gestion de structures de données spécifiques.
Par conséquent, processus = structure de données du noyau liée au processus + code et données du processus en cours.
classification du contenu de la structure task_struct
- Identifiant : Décrivez l'identifiant unique de ce processus, qui est utilisé pour distinguer les autres processus ;
- Statut : statut de la tâche, code de sortie, signal de sortie, etc. ;
- Priorité : priorité par rapport aux autres processus ;
- Compteur de programme : l'adresse de la prochaine instruction à exécuter dans le programme ;
- Pointeurs de mémoire : y compris les pointeurs vers le code de programme et les données liées au processus, ainsi que les pointeurs vers les blocs de mémoire partagés avec d'autres processus ;
- Données de contexte : les données dans les registres du processeur lorsque le processus est exécuté [exemple de suspension d'études, pour ajouter des images de CPU, registres] ;
- Informations sur l'état des E/S : y compris les demandes d'E/S affichées, les périphériques d'E/S alloués au processus et une liste des fichiers utilisés par le processus ;
- Informations de facturation : peuvent inclure la somme du temps processeur, la somme des horloges utilisées, la limite de temps, le numéro de compte de facturation, etc. ;
- les autres informations.
3. Processus d'organisation
Il peut être trouvé dans le code source du noyau. Tous les processus en cours d'exécution dans le système sont stockés dans le noyau sous la forme d'une liste chaînée task_struct.
4. Afficher le processus et terminer
Pour afficher les informations de base d'un processus, nous pouvons utiliser la commande ps -axj pour lister les informations de processus utilisées par le système actuel ;
Testez d'abord un morceau de code:
#include<stdio.h>
#include<unistd.h>
int main()
{
while(1)
{
printf("我是一个进程！\n");
sleep(1);
}
return 0;
}
Entrez la commande pour afficher le processus, comme suit :
Entrez ps -axj | head -1 && ps -axj | grep "test" pour obtenir l'en-tête et le processus avec test.
Ici, nous devons également expliquer un concept qui est le concept de PID et PPID, qui fait référence au numéro d'identification du processus dans le système d'exploitation, c'est-à-dire l' identifiant du processus . Chaque fois qu'un programme est ouvert dans le système d'exploitation, un ID de processus, ou PID, est créé. Bien sûr, PPID est le numéro d'identification de processus du processus parent.
tuer le processus
Il existe deux méthodes : la première est Ctrl + c pour forcer la fin du processus, et la seconde est : sous forme de commande, kill -9 PID, spécifiez le processus cible à tuer.
Ici, je recommande d'utiliser la deuxième méthode.
5. Obtenir l'identifiant du processus via l'appel système
- ID de processus (PID) ;
- ID de processus parent (PPID).
#include<iostream>
#include<sys/types.h>
#include<unistd.h>
using namespace std;
int main()
{
pid_t t = fork();
if (t == 0)
{
while (1)
{
cout << "我是一个子进程" << " pid:" << getpid() << " ppid:" << getppid() << endl;
sleep(1);
}
}
else if (t > 0)
{
while (1)
{
cout << "我是一个父进程" << " pid:" << getpid() << " ppid:" << getppid() << endl;
sleep(1);
}
}
return 0;
}
6. Créer un processus via un appel système - fork
- Exécutez man fork pour connaître fork ;
- fork a deux valeurs de retour ;
- Partage de code de processus parent-enfant, chacun ouvre un espace pour les données, une copie privée (en utilisant la copie sur écriture);
- Après la fourche, si est généralement utilisé pour la ramification.
Vous pouvez voir que la fonction fork() est très spéciale. Après avoir créé avec succès un processus enfant, il y a en fait deux valeurs de retour. Elle renvoie le pid du processus enfant au processus parent, renvoie 0 au processus enfant et renvoie - 1 si la création échoue.
Comment comprendre les deux valeurs de retour
Lorsque fork() veut renvoyer la valeur, en fait, le travail de création d'un processus enfant à l'intérieur de la fonction est terminé. À ce stade, il existe déjà deux processus et les deux processus continuent d'exécuter l'instruction suivante. Après l'exécution fork(), naturellement Il y aura une valeur de retour, il nous semble donc qu'il y a deux valeurs de retour. En fait, lorsque nous recevons la valeur de retour, nous avons déclenché la copie sur écriture (la copie réaliste est lorsque l'opération système détecte que le processus enfant a une opération d'écriture. Le système d'exploitation allouera l'espace physique correspondant au processus enfant), et les rets apparemment identiques sont en fait stockés dans des espaces différents.
7. Statut du processus
- R état d'exécution (en cours d'exécution) : cela ne signifie pas que le processus doit être en cours d'exécution, cela indique que le processus est soit en cours d'exécution, soit dans la file d'attente d'exécution ;
- S état de veille (sommeil): signifie que le processus attend que l'événement se termine (le sommeil est ici parfois appelé veille interruptible (sommeil interruptible));
- L'état de veille du disque D (Disk sleep) est parfois appelé état de veille sans interruption (veille sans interruption), le processus dans cet état attend généralement la fin de l'IO;
- T état d'arrêt (arrêté) : Un processus peut être arrêté (T) en envoyant un signal SIGSTOP au processus. Le processus suspendu peut être repris en envoyant le signal SIGCONT ;
- X état mort (mort) : Cet état est juste un état de retour, vous ne verrez pas cet état dans la liste des tâches.
La commande ps -axj consiste à afficher les informations du processus
(1) R running status (en cours d'exécution) : cela ne signifie pas que le processus doit être en cours d'exécution, cela indique que le processus est soit en cours d'exécution, soit dans la file d'attente en cours d'exécution ;
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
while (1)
{
;
}
return 0;
}
Lors de l'exécution, vérifiez que l'état du processus est R+, indiquant qu'il est en cours d'exécution.
Que signifie le signe + après ?
Ici + signifie que le processus s'exécute au premier plan. Lorsque nous utilisons ctrl+c, le processus peut être terminé. Si nous n'écrivons pas +, cela signifie que le processus s'exécute en arrière-plan. À ce stade, ctrl+c Impossible de terminer le programme. Utilisez la commande kill process pour terminer.
(2) État de sommeil S (sommeil): signifie que le processus attend que l'événement se termine (le sommeil est ici parfois appelé sommeil interruptible (sommeil interruptible));
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
int n = 0;
scanf("%d", &n);
return 0;
}Lors de l'exécution, vérifiez que l'état du processus est S+, indiquant qu'il est en état de veille.
(3) État d'arrêt T (arrêté) : le processus (T) peut être arrêté en envoyant un signal SIGSTOP au processus. Le processus suspendu peut être repris en envoyant le signal SIGCONT ;
kill -l : Tous les signaux peuvent être affichés, et le signal SIGSTOP correspond à 19, et le signal SIGCONT correspond à 18.
Lorsque nous entrons kill -19 PID, le processus sera arrêté.
Lorsque nous entrons kill -18 PID, le processus sera restauré.
(4) État de mort : cet état n'est qu'un état de retour et il est instantané. Vous ne verrez peut-être pas cet état dans la liste des tâches, car un processus deviendra un processus zombie après sa mort.
(5) État zombie : l'état après la mort du processus. Après la mort d'un processus, il sera dans l'état zombie. Si son processus parent ne se recycle pas, il occupera toujours des ressources et provoquera des fuites de mémoire.
8. Processus spécial
8.1 Processus zombie
- L'état zombie (Zombies) est un état spécial. Un processus zombie est créé lorsqu'un processus se termine et que le processus parent (utilisant l'appel système wait()) ne lit pas le code de retour de la sortie du processus enfant.
- Un processus zombie restera dans la table des processus dans un état terminé et attendra que le processus parent lise le code d'état de sortie.
- Tant que le processus enfant se termine, le processus parent est toujours en cours d'exécution, mais le processus parent ne lit pas l'état du processus enfant et le processus enfant entre dans l'état Z
Démontrons le processus zombie :
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
pid_t id = fork();
if (id == 0)
{
//子进程
while (1)
{
printf("我是子进程，我的pid :%d,我的ppid: %d\n", getpid(), getppid());
sleep(1);
}
}
else if (id > 0)
{
//父进程
while (1)
{
printf("我是父进程，我的pid :%d,我的ppid: %d\n", getpid(), getppid());
sleep(1);
}
}
else
{
perror("fail");
exit(-1);
}
return 0;
}Lors de l'exécution, utilisez kill -9 PID pour tuer le processus enfant au milieu, et le processus enfant est un processus zombie à ce moment.
8.2 Processus orphelins
- Si le processus parent se termine plus tôt, puis le processus enfant se termine plus tard et entre Z, que dois-je faire ?
- Le processus parent se termine en premier et le processus enfant est appelé "processus orphelin"
- Le processus orphelin est adopté par le processus init n°1, et bien sûr le processus init doit être recyclé.
Regardez le morceau de code suivant, c'est-à-dire que le processus parent s'exécute pendant 3 secondes puis se termine. À ce stade, le processus enfant est un processus orphelin.
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
pid_t id = fork();
if (id < 0)
{
perror("fail");
return 1;
}
else if (id == 0)
{
//子进程
printf("I am child, pid : %d\n", getpid());
sleep(10);
}
else
{
//父进程
printf("I am parent, pid: %d\n", getpid());
sleep(3);
exit(-1);
}
return 0;
}Comparaison des résultats en cours d'exécution :
S'il y a des lacunes dans cet article, vous êtes invités à commenter ci-dessous, et je le corrigerai dès que possible.
Vieux fers, pensez à liker et faites attention !!!