1. Algorithme de planification du premier arrivé, premier servi
(1) Contenu de l'algorithme : l'algorithme de planification premier arrivé, premier servi est l'algorithme de planification le plus simple, qui peut être appliqué à la fois à la planification de haut niveau et à la planification de bas niveau. Dans la planification avancée, l'algorithme de planification FCFS sélectionne les travaux à entrer dans la mémoire en fonction de l'ordre dans lequel ils entrent dans la file d'attente des travaux de sauvegarde, c'est-à-dire que les travaux qui entrent en premier dans la file d'attente des travaux de sauvegarde sont d'abord sélectionnés pour entrer dans la mémoire, puis créent un processus pour le travail sélectionné et allouer les ressources requises par le travail. Dans la planification de bas niveau, l'algorithme de planification FCFS sélectionne à chaque fois un processus/thread de première entrée dans la file d'attente du processus/thread prêt de la mémoire, puis le planificateur de processus/thread lui attribue le CPU et le fait fonctionner.
(2) Exigences algorithmiques : chaque processus est représenté par un bloc de contrôle de processus (PCB). Le bloc de contrôle de processus peut contenir les informations suivantes : nom du processus, heure d'arrivée, heure d'exécution, heure de début, heure de fin, temps d'attente, temps de rotation, temps de rotation de la délégation, etc. Le processus qui entre en premier dans la file d'attente des prêts se verra attribuer un processeur à exécuter en premier. Une fois qu'un processus prend possession d'un processeur, il continue de s'exécuter jusqu'à ce que le processus termine son travail ou soit incapable de continuer à s'exécuter car il attend qu'un événement se produise avant de libérer le processeur.
(3) Idée de conception : l'algorithme est exécuté dans l'ordre de l'heure d'arrivée des processus, et ceux qui arrivent en premier sont exécutés en premier.
(4) Analyse d'algorithme : définir d'abord une structure de PCB ;
Définissez la fonction d'entrée input(), entrez le numéro de processus, l'heure d'arrivée et le temps d'exécution ;
Définissez la fonction de sortie output() pour afficher différents moments de chaque bloc de processus ;
Définissez la fonction de tri rank() pour trier les processus en fonction de leur heure d'arrivée ;
Définir FCFS () fonction d'algorithme du premier arrivé, premier servi pour calculer différents moments ;
Définissez la fonction principale main() pour réaliser la fonction premier arrivé, premier servi ;
(5) Code de base :
#include<stdio.h>
double atime; //平均周转时间
double awtime; //平均带权周转时间
struct PCB //声明结构体类型PCB
{
char name[20]; //进程号
int arrivaltime; //到达时间
int runtime; //运行时间
int starttime; //开始时间
int finishtime; //完成时间
int waitingtime; //等待时间
int cycletime; //周转时间
double wctime; //带权周转时间
};
struct PCB pcb[100];
/*输入函数*/
int input(int n)
{
printf("请依次输入进程号、到达时间、运行时间：\n");
for(int i=0;i<n;i++)
{
scanf("%s\t%d\t%d",pcb[i].name,&pcb[i].arrivaltime,&pcb[i].runtime);
}
}
/*输出函数*/
int output(int n)
{
printf("\n======================================================================================================================\n");
printf("进程号 \t到达时间\t运行时间\t开始时间\t完成时间\t等待时间\t周转时间\t带权周转时间\n");
printf("----------------------------------------------------------------------------------------------------------------------\n");
for(int i=0;i<n;i++)
{
printf("%3s\t %d\t\t %d\t\t %d\t\t %d\t\t %d\t\t %d\t\t %.2lf\n",pcb[i].name,pcb[i].arrivaltime,pcb[i].runtime,pcb[i].starttime,pcb[i].finishtime,pcb[i].waitingtime,pcb[i].cycletime,pcb[i].wctime);
}
printf("----------------------------------------------------------------------------------------------------------------------\n");
printf("\t平均周转时间 \t\t%.2lf\t\n",atime);
printf("----------------------------------------------------------------------------------------------------------------------\n");
printf("\t平均带权周转时间\t\t%.2lf\t\n",awtime);
printf("======================================================================================================================\n");
}
/*按到达时间进行排序*/
int rank(int n)
{
struct PCB t;
for(int j=0;j<n-1;j++) //冒泡法排序
for(int i=0;i<n-1-j;i++)
{
if(pcb[i].arrivaltime>pcb[i+1].arrivaltime)
{
t=pcb[i];
pcb[i]=pcb[i+1];
pcb[i+1]=t;
}
}
}
/*先来先服务算法*/
int FCFS(int n)
{
/*完成时间*/
if(pcb[0].arrivaltime!=0) //第一个进程到达时间不为0时，其完成时间=开始时间+运行时间
{
pcb[0].finishtime=pcb[0].starttime+pcb[0].runtime;
}
else
pcb[0].finishtime=pcb[0].runtime; //第一个进程到达时间为0时，其完成时间=运行时间
for(int i=1;i<n;i++)
{
if(pcb[i-1].finishtime>=pcb[i].arrivaltime) //如果前一个进程的完成时间大于等于当前进程的到达时间
{
pcb[i].finishtime=pcb[i-1].finishtime+pcb[i].runtime; //当前进程的完成时间=前一个进程的完成时间+该进程的运行时间
}
else
{
pcb[i].finishtime=pcb[i].arrivaltime+pcb[i].runtime; //否则为当前进程的到达时间+运行时间
}
}
/*开始时间*/
pcb[0].starttime=pcb[0].arrivaltime; //第一个进程的开始时间即到达时间
for(int i=1;i<n;i++)
{
pcb[i].starttime=pcb[i-1].finishtime; //从第二个进程开始，开始时间=前一个进程的完成时间
}
/*等待时间 周转时间 带权周转时间*/
for(int i=0;i<n;i++)
{
pcb[i].waitingtime=pcb[i].starttime-pcb[i].arrivaltime; //等待时间=开始时间-到达时间
pcb[i].cycletime=pcb[i].finishtime-pcb[i].arrivaltime; //周转时间=完成时间-到达时间
pcb[i].wctime=pcb[i].cycletime/(pcb[i].runtime*1.0); //带权周转时间=周转时间/运行时间
}
/*平均周转时间 平均带权周转时间*/
int sum1=0;
double sum2=0;
for(int i=0;i<n;i++)
{
sum1+=pcb[i].cycletime; //求所有进程周转时间的和
sum2+=pcb[i].wctime; //求有所进程周转时间的和
}
atime=sum1/(n*1.0); //平均周转时间=所有进程周转时间的和/进程数
awtime=sum2/n; //平均带权周转时间=所有进程周转时间的和/进程数
}
/*主函数*/
int main()
{
printf("先来先服务FCFS算法模拟\n请输入进程个数：\n");
int n;
scanf("%d",&n); //输入进程数 n
input(n); //输入函数
rank(n); //排序函数，按到达时间给各进程排序 （升序）
FCFS(n); //先来先服务算法函数，计算各种时间
output(n); //输出函数
return 0;
}(6) Données de test ou capture d'écran :
(6) Analyse des résultats en cours d'exécution : Selon l'algorithme du premier arrivé, premier servi, triez-les d'abord en fonction de leur heure d'arrivée. Selon les informations d'entrée du processus, l'heure d'arrivée du premier processus a est 0, son temps d'achèvement = temps d'exécution = 1, et le reste des processus Le temps d'achèvement du processus = le temps d'achèvement du processus précédent + le temps d'exécution du processus, (par exemple, le temps d'achèvement de b =1+100= 101, l'heure de fin de c=101+1=102, l'heure de fin de d=102+100 =201) ; l'heure de début du premier processus a = heure d'arrivée = 0, l'heure de début des autres processus = l'achèvement l'heure du processus précédent (par exemple, l'heure de début de b = l'heure d'achèvement de a = 1, l'heure de début de c = l'heure d'achèvement de b = 101, l'heure de début de d = l'heure d'achèvement de c = 102) ; le temps d'attente de chaque processus = heure de début - heure d'arrivée (par exemple, le temps d'attente de a = 0-0 = 0, le temps d'attente de b Time=1-1=0, le temps d'attente de c=101 -2=99, temps d'attente de d=102-3=99 ); délai d'exécution=heure d'achèvement-heure d'arrivée (par exemple, délai d'exécution de a=1-0 =1, délai d'exécution de b=101-1=100 , temps de rotation de c=102-2=100, temps de rotation de d=202-3=199 ); temps de rotation pondéré=temps de rotation/durée de fonctionnement (par exemple, le temps de rotation pondéré de a=1/1=1, le temps de rotation pondéré de b=100/100=1, le temps de rotation pondéré de c=100/1=100, le temps de rotation pondéré de d=199/100= 1,99) ; temps de rotation moyen = somme de tous les temps de rotation de processus / nombre de processus (1+100+100+199)/4=100 ; délai d'exécution moyen pondéré = somme de tous les délais d'exécution pondérés par processus/nombre de processus (1+ 1+100+1,99)/4=26 .
2. Algorithme de planification à tour de rôle par tranches de temps
(1) Contenu de l'algorithme : l'algorithme de planification circulaire de tranches de temps est principalement utilisé pour la planification de bas niveau, et la méthode de planification est en fait un algorithme de planification préemptif basé sur l'horloge. Dans un système utilisant l'algorithme d'ordonnancement à tour de rôle par tranches de temps, les files d'attente de processus/threads prêts sont mises en file d'attente dans l'ordre de l'heure d'arrivée. Selon le principe du premier arrivé, premier servi, tous les processus qui doivent être exécutés sont organisés en une séquence croissante en fonction de l'heure d'arrivée. Chaque fois qu'un processus se voit attribuer une tranche de temps de même taille. Dans cette tranche de temps, si l'exécution du processus se termine, le processus est supprimé de la file d'attente des processus. Si le processus ne fin, le processus est arrêté puis mis dans un état d'attente, et placé dans la queue de la file d'attente du processus jusqu'à ce que tous les processus aient fini de s'exécuter.
(2) Exigences d'algorithme : chaque processus est représenté par un bloc de contrôle de processus (PCB). Le bloc de contrôle de processus peut contenir les informations suivantes : nom du processus, heure d'arrivée, temps d'exécution, heure de fin, temps de rotation, temps de rotation autorisé, indicateur de processus terminé, temps de service restant, etc. Le temps d'exécution d'un processus est calculé en unités de tranches de temps.
(3) Idée de conception : à chaque fois lors de la planification, sélectionnez toujours le processus leader de la file d'attente prête et laissez-le exécuter une tranche de temps prédéfinie par le système sur le processeur. Un processus qui n'a pas fini de s'exécuter dans une tranche de temps revient à la fin de la file d'attente des threads et se remet en file d'attente pour attendre la prochaine planification. La planification alternée des tranches de temps appartient à la planification préemptive et convient aux systèmes à temps partagé.
(4) Analyse d'algorithmes : définir d'abord une structure RR ;
fonction d'entrée input() ;
La fonction rank() trie l'heure d'arrivée du processus ;
La fonction rr_pcb() exécute l'algorithme d'ordonnancement circulaire ;
fonction de sortie output() ;
fonction principale main().
(5) Code de base :
#include<stdio.h>
double atime; //平均周转时间
double awtime; //平均带权周转时间
struct RR
{
char name[20]; //进程号
int arrivaltime; //到达时间
int runtime; //运行时间
int starttime; //开始时间
int finishtime; //完成时间
int cycletime; //周转时间
double wctime; //带权周转时间
int sign; //完成进程标志
int st1; //剩余服务时间
};
struct RR rr[100];
/*输入函数*/
int input(int n)
{
printf("请依次输入进程号、到达时间、运行时间：\n");
for(int i=0;i<n;i++)
{
rr[i].sign=0;
scanf("%s\t%d\t%d",rr[i].name,&rr[i].arrivaltime,&rr[i].runtime);
rr[i].st1=rr[i].runtime;
}
}
/*采用冒泡法，按进程的到达时间对进程进行排序*/
int rank(int n)
{
int i,j;
struct RR temp;
for(j=0;j<n-1;j++)
for(i=0;i<n-1-j;i++)
{
if(rr[i].arrivaltime>rr[i+1].arrivaltime)
{
temp=rr[i];
rr[i]=rr[i+1];
rr[i+1]=temp;
}
}
}
/*执行时间片轮转调度算法*/
int rr_pcb(int n)
{
printf("请输入时间片：\n");
int t;
scanf("%d",&t); //输入时间片
int time=rr[0].arrivaltime; //给当前时间time赋初值
int flag=1; //标志就绪队列中有进程
int sum=0; //记录完成的进程数
printf("\n====================================================================================================================\n");
printf("进程号 \t到达时间\t运行时间\t开始时间\t完成时间\t周转时间\t带权周转时间\n");
printf("--------------------------------------------------------------------------------------------------------------------\n");
while(sum<n) //当完成的进程数小于进程总数
{
flag=0; //标记就绪队列没有进程
for(int i=0;i<n;i++) //时间片轮转法执行各进程
{
if(rr[i].sign==1)//已完成进程
continue;
else//未完成的进程
{
if(rr[i].st1<=t && time>=rr[i].arrivaltime)//还需运行的时间小于等于一个时间片
{
flag=1; //把进程加入到就绪队列中
time+=rr[i].st1;
rr[i].sign=1; //此进程完成
rr[i].finishtime=time; //完成时间
rr[i].cycletime=rr[i].finishtime-rr[i].arrivaltime; //计算周转时间=完成时间-到达时间
rr[i].wctime=rr[i].cycletime/(rr[i].runtime*1.0); //计算带权周转时间=周转时间/服务
printf("%3s\t %d\t\t %d\t\t %d\t\t %d\t\t %d\t\t %.2lf\n",rr[i].name,
rr[i].arrivaltime,rr[i].runtime,time-rr[i].st1,time,rr[i].cycletime,rr[i].wctime);
}
else if(rr[i].st1>t&&time>=rr[i].arrivaltime) //还需服务时间至少大于一个时间片
{
flag=1; //把进程加入到就绪队列中
time+=t;
rr[i].st1-=t;
rr[i].cycletime=rr[i].finishtime-rr[i].arrivaltime; //计算周转时间=完成时间-到达时间
rr[i].wctime=rr[i].cycletime/(rr[i].runtime*1.0); //计算带权周转时间=周转时间/服务
printf("%3s\t %d\t\t %d\t\t %d\t\t %d\t\t %d\t\t %.2lf\n",rr[i].name,
rr[i].arrivaltime,rr[i].runtime,time-t,time,rr[i].cycletime,rr[i].wctime);
}
if(rr[i].sign==1)
sum++; //一个进程执行完就+1
}
}
}
/*平均周转时间 平均带权周转时间*/
int sum1=0;
double sum2=0;
for(int i=0;i<n;i++)
{
sum1+=rr[i].cycletime; //求所有进程周转时间的和
sum2+=rr[i].wctime; //求所有进程带权周转时间的和
}
atime=sum1/(n*1.0); //平均周转时间=有进程周转时间的和/进程数
awtime=sum2/n; //平均带权周转时间=所有进程带权周转时间的和/进程数
}
/*输出函数*/
int output(int n)
{
printf("--------------------------------------------------------------------------------------------------------------------\n");
printf("\t平均周转时间 \t\t%.2lf\t\n",atime);
printf("--------------------------------------------------------------------------------------------------------------------\n");
printf("\t平均带权周转时间\t\t%.2lf\t\n",awtime);
printf("====================================================================================================================\n");
}
/*主函数*/
int main()
{
printf("时间片轮转调度算法\n请输入总进程数：\n");
int n;
scanf("%d",&n); //输入总进程数
input(n); //输入函数
rank(n); //排序函数
rr_pcb(n); //计算各时间
output(n); //输出函数
return 0;
}(6) Données de test ou captures d'écran : (Voir la figure 1 pour la tranche de temps 1, voir la figure 2 pour la tranche de temps 5)
Figure 1 Capture d'écran des résultats en cours d'exécution lorsque la tranche de temps = 1
Figure 2 Capture d'écran des résultats en cours d'exécution lorsque la tranche de temps = 5
(7) Analyse des résultats en cours : l'image du temps d'exécution est la suivante,
Figure 4-24 Image du temps d'exécution
Lorsque la tranche de temps = 1, les temps d'exécution des quatre processus a, b, c et d sont tous plus longs que la tranche de temps spécifiée. S'ils ne finissent pas de s'exécuter dans une tranche de temps, ils doivent tous revenir à la fin de la file d'attente des prêts et attendre le prochain ordonnancement pour continuer l'exécution. . La CPU est affectée au premier processus de la file d'attente actuelle.
Lorsque la tranche de temps = 5, le temps d'exécution du premier processus est égal à 20> 5, et si le temps d'exécution n'est pas terminé dans une tranche de temps, le processus a retourne à la fin de la file d'attente prête à se remettre en file d'attente et attend le prochain ordonnancement ; le temps d'exécution du deuxième processus est égal à 10>5, lorsque la tranche de temps spécifiée est épuisée, le processus b retourne à la fin de la file d'attente prête, attendant d'être à nouveau programmé pour s'exécuter ; le temps d'exécution du deuxième processus est égal à 15>5, alors le processus c retourne à la fin de la file d'attente des prêts, et attend jusqu'à ce qu'il soit mis en service lorsqu'il se tournera vers lui-même la prochaine fois ; le temps d'exécution du quatrième processus est de 5, et il suffit finit de s'exécuter dans une tranche de temps, puis le processus d abandonne le droit d'utiliser le CPU. A ce moment, le planificateur de processus alloue la CPU au premier processus de la file d'attente actuelle, à savoir le processus a.
3. Algorithme de planification prioritaire
(1) Contenu de l'algorithme : l'algorithme de planification prioritaire peut être appliqué à la fois à la planification de haut niveau (planification des tâches) et à la planification de bas niveau (planification des processus), et il peut également être utilisé dans les systèmes en temps réel. Dans la planification avancée, l'algorithme de planification du numéro de priorité sélectionne le travail avec la priorité la plus élevée dans la file d'attente des travaux de sauvegarde et le charge en mémoire, lui alloue les ressources correspondantes, crée un processus et le place dans la file d'attente des processus prêts. Dans la planification de bas niveau, l'algorithme de planification prioritaire sélectionne le processus avec la priorité la plus élevée dans la file d'attente des processus prêts pour lui allouer le processeur et le mettre en service. S'il existe plusieurs travaux/processus avec la priorité la plus élevée, il peut être combiné avec des politiques de planification de priorité premier arrivé, premier servi ou travail court/processus court.
(2) Exigences d'algorithme : chaque processus est représenté par un bloc de contrôle de processus (PCB). Le bloc de contrôle de processus peut contenir les informations suivantes : nom du processus, temps d'exécution, numéro de priorité, état du processus, etc. Le numéro de priorité du processus et le temps d'exécution requis peuvent être spécifiés manuellement à l'avance (il peut également être généré par des nombres aléatoires). L'état de chaque processus peut être ready W (Wait), run R (Run) ou completer l'un des 3 états de F (Finish).
(3) Idée de conception : en utilisant l'algorithme de planification de priorité préemptive, le processus/thread prêt avec la priorité la plus élevée fait exécuter le CPU en premier, et est autorisé à être préempté par le processus/thread prêt avec une priorité plus élevée pendant le processus en cours d'exécution. S'il existe plusieurs processus avec la priorité la plus élevée, une politique de planification du premier arrivé, premier servi est combinée. Avant chaque exécution, son "numéro de priorité" et son "temps d'exécution requis" sont déterminés arbitrairement pour chaque processus. Le processeur choisit toujours le processus leader à exécuter. La méthode de modification dynamique du numéro de priorité est adoptée. Chaque fois que le processus s'exécute, le numéro de priorité est réduit de 1 et le temps d'exécution requis est réduit de 1. Une fois que le processus s'est exécuté une fois, si le temps d'exécution requis n'est pas égal à 0, il sera ajouté à la file d'attente, sinon, le statut sera changé en "fin" et la file d'attente sera fermée. Si la file d'attente des prêts est vide, terminez, sinon répétez les étapes ci-dessus.
(4) Analyse d'algorithme : définir le bloc de contrôle de processus ;
fonction entrée() ;
fonction sortie() ;
La fonction max_priority() trouve le processus avec la priorité la plus élevée dans l'état prêt ;
La fonction psa_pcb() est un algorithme d'ordonnancement prioritaire ;
fonction principale main() ;
(5) Code de base :
#include<stdio.h>
/*结构体*/
struct PSA
{
char name[10]; //进程名
int runtime; //运行时间
int priority; //优先数
char state; //状态，三状态：W-就绪；R-运行；F-结束
};
struct PSA psa[10]; //定义进程控制块数组
/*输入函数*/
int input(int n)
{
printf("请输入PCB的进程名，运行时间，优先数:\n");
for(int i=0;i<n;i++) //i为进程编号
{
scanf("%s\t%d\t%d",&psa[i].name,&psa[i].runtime,&psa[i].priority);
psa[i].state=‘W’; //初始状态都设为就绪
getchar();
}
}
/*输出函数*/
int output(int n)
{
printf("\n==============================\n");
printf("进程号 运行时间 优先数 状态\n");
printf("------------------------------\n");
for(int i=0;i<n;i++)
printf("%s %7d%9d\t%s\n",psa[i].name,psa[i].runtime,psa[i].priority,&psa[i].state);
printf("==============================\n");
}
/*进程在就绪状态时找出最大优先数进程（返回值为最大优先数编号）*/
int max_priority(int n)
{
int max=-1; //max为最大优先数
int m; //m为最大优先数进程的编号
for(int i=0;i<n;i++)
{ //进程在就绪状态时找出最大优先数
if(psa[i].state==‘R’) //进程在运行状态
return -1;
else if((max<psa[i].priority)&&(psa[i].state==‘W’)) //进程在就绪状态
{
max=psa[i].priority;
m=i; //把最大优先数对应的编号赋给m
}
}
//确保最大优先数进程还没结束运行
if(psa[m].state==‘F’) //最大优先数进程已结束运行
return -1;
else //最大优先数进程还没结束运行
return m; //返回值为最大优先数编号
}
/*优先数调度算法*/
int psa_pcb(int n)
{
int max_time=-1,m=0;
int sum=0; //sum为程序总运行次数
for(int i=0;i<n;i++)
sum+=psa[i].runtime;
printf("\n初始时各进程信息如下:\n");
output(n);
getchar();
for(int j=0;j<sum;j++)
{
//当程序正在运行时
while(max_priority(n)!=-1) //max_priority ()为找出最大优先数进程函数，返回最大值对应的编号m
{
if(psa[max_priority(n)].priority!=0)
psa[max_priority(n)].state=‘R’; //由就绪转为运行态
else
{ //当优先级降为0，进程还没运行完时
for(int i=0;i<n;i++)
if(max_time<psa[i].runtime)
{
max_time=psa[i].runtime;
m=i; //返回对应的编号
}
max_time=-1;
psa[m].state=‘R’; //状态转为运行态
}
}
//判断程序状态(对优先数和运行时间操作)
for(int i=0;i<n;i++)
{
if(psa[i].state==‘R’) //当进程处于运行状态时
{
if(psa[i].priority>0) //优先数>0
psa[i].priority--; //每运行一次优先数-1
psa[i].runtime--; //每运行一次运行时间-1
}
if(psa[i].runtime==0) //运行时间完
psa[i].state=‘F’; //进程状态转为完成状态
else //运行时间没完
psa[i].state=‘W’; //进程状态转为就绪状态
}
output(n);
getchar();
}
}
/*主函数*/
int main()
{
printf("优先数调度算法：\n输入总进程数：\n");
int n;
scanf("%d",&n); //输入总进程数n
input(n); //输入函数
psa_pcb(n); //优先数调度算法
return 0;
}
(6) Données de test ou capture d'écran :
(7) Analyse des résultats en cours d'exécution : au début, les états des cinq processus a, b, c, d et e sont tous à l'état prêt (W), parmi lesquels c a la priorité la plus élevée, puis c est le premier à exécuter par la CPU et son temps d'exécution est de 2. Dans l'état d'exécution, le temps d'exécution est décrémenté de 1 et le numéro de priorité est décrémenté de 1. Le temps d'exécution du processus a est 0 et l'état d'un passe de l'état prêt à l'état terminé ; après cela, les numéros de priorité de c et e sont les plus grands, mais selon la politique de planification du premier arrivé, premier servi, c est dans l'état d'exécution en premier, le numéro de priorité est réduit de 1, et le temps d'exécution est réduit de 1 à 0, donc c devient l'état terminé ; à ce moment, seuls trois processus b, d et e sont à l'état prêt, dont e Le numéro de priorité de e est le plus grand , puis e récupère le CPU et le met en service, son temps d'exécution est réduit de 1, et le numéro de priorité est réduit de 1 ; alors les numéros de priorité de b et e sont les mêmes, selon le premier arrivé, premier- sert la politique d'ordonnancement, alors b préempte le CPU et est dans l'état d'exécution. Si le temps d'exécution est réduit de 1 à 0, alors b devient terminé ; à ce moment, il ne reste que deux processus d et e, et e a un plus haut numéro de priorité, alors e préempte le CPU et est dans l'état d'exécution, et le numéro de priorité et le temps d'exécution sont réduits de 1 ; e Le numéro de priorité moins 1 est le même que celui de d, mais selon le premier arrivé premier -principe servi, d obtient le CPU en premier et est en état de fonctionnement, et le numéro de priorité et le temps d'exécution sont réduits de 1; à ce moment, le numéro de priorité de e est supérieur à d, donc e obtient le CPU Run, le le temps d'exécution et le numéro de priorité moins 1 ; les numéros de priorité de d et e sont les mêmes, mais d s'exécute en premier, le temps d'exécution et le numéro de priorité moins 1, puis le numéro de priorité de e est supérieur à d, e obtient le CPU , et le temps d'exécution est réduit de 1. 0, e est dans l'état terminé ; à la fin, il ne reste plus que d pour faire fonctionner le CPU, et le temps d'exécution est réduit de 1 à 0, devenant l'état terminé. En bref, le processus avec une priorité élevée obtient d'abord le processeur dans l'état d'exécution. Après une exécution, le temps d'exécution et le numéro de priorité sont réduits de 1. Lorsque le temps d'exécution n'est pas égal à 0, il est ajouté à la file d'attente prête. Lorsque le le temps d'exécution est égal à 0, l'état est changé en fin (F). S'il y a plusieurs processus avec la même priorité, ils seront traités selon le principe du premier arrivé, premier servi.