1. Algoritmo de programación por orden de llegada
(1) Contenido del algoritmo: el algoritmo de programación por orden de llegada es el algoritmo de programación más simple, que se puede aplicar tanto a la programación de alto nivel como a la programación de bajo nivel. En la programación avanzada, el algoritmo de programación FCFS selecciona trabajos para ingresar a la memoria de acuerdo con el orden en que ingresan a la cola de trabajos de respaldo, es decir, los trabajos que ingresan primero a la cola de trabajos de respaldo se seleccionan primero para ingresar a la memoria y luego se crean. un proceso para el trabajo seleccionado y asignar los recursos requeridos por el trabajo. En la programación de bajo nivel, el algoritmo de programación FCFS selecciona un proceso/hilo de primera entrada de la cola de proceso/hilo listo de memoria cada vez, y luego el programador de proceso/hilo le asigna la CPU y lo hace ejecutar.
(2) Requisitos del algoritmo: cada proceso está representado por un bloque de control de proceso (PCB). El bloque de control del proceso puede contener la siguiente información: nombre del proceso, tiempo de llegada, tiempo de ejecución, tiempo de inicio, tiempo de finalización, tiempo de espera, tiempo de respuesta, tiempo de respuesta de la delegación, etc. Al proceso que entre primero en la cola de listos se le asignará un procesador para que se ejecute primero. Una vez que un proceso toma posesión de un procesador, continúa ejecutándose hasta que el proceso finaliza su trabajo o no puede continuar ejecutándose porque está esperando que ocurra un evento antes de liberar el procesador.
(3) Idea de diseño: El algoritmo se ejecuta en el orden de la hora de llegada de los procesos, y los que llegan primero se ejecutan primero.
(4) Análisis de algoritmos: primero defina una estructura de PCB;
Defina la función de entrada input(), ingrese el número de proceso, la hora de llegada y el tiempo de ejecución;
Defina la función de salida output() para generar varias veces de cada bloque de proceso;
Defina la función de clasificación rank() para clasificar los procesos según su hora de llegada;
Defina la función de algoritmo FCFS () por orden de llegada para calcular varias veces;
Defina la función principal main() para realizar la función de orden de llegada;
(5) Código central:
#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) Datos de prueba o captura de pantalla:
(6) Análisis de los resultados de la ejecución: de acuerdo con el algoritmo de orden de llegada, primero clasifíquelos de acuerdo con su hora de llegada. De acuerdo con la información de entrada del proceso, la hora de llegada del primer proceso a es 0, su tiempo de finalización = tiempo de ejecución = 1, y el resto de los procesos El tiempo de finalización del proceso = el tiempo de finalización del proceso anterior + el tiempo de ejecución del proceso (por ejemplo, el tiempo de finalización de b=1+100 = 101, la hora de finalización de c=101+1=102, la hora de finalización de d=102+100 =201); la hora de inicio del primer proceso a = hora de llegada = 0, la hora de inicio de otros procesos = la finalización hora del proceso anterior (por ejemplo, la hora de inicio de b = la hora de finalización de a = 1, la hora de inicio de c = la hora de finalización de b = 101, la hora de inicio de d = la hora de finalización de c = 102) ; el tiempo de espera de cada proceso = tiempo de inicio - tiempo de llegada (por ejemplo, el tiempo de espera de a = 0-0 = 0, el tiempo de espera de b Tiempo=1-1=0, el tiempo de espera de c=101 -2=99, tiempo de espera de d=102-3=99); tiempo de respuesta=tiempo de finalización-tiempo de llegada (por ejemplo, tiempo de respuesta de a=1-0 =1, tiempo de respuesta de b=101-1=100 , tiempo de respuesta de c=102-2=100, tiempo de respuesta de d=202-3=199); tiempo de respuesta ponderado=tiempo de respuesta/tiempo de ejecución (p. ej., el tiempo de respuesta ponderado de a=1/1=1, el tiempo de rotación ponderado de b=100/100=1, tiempo de rotación ponderado de c=100/1=100, tiempo de rotación ponderado de d=199/100= 1,99); tiempo de rotación promedio = suma de todos los tiempos de rotación del proceso / número de procesos (1+100+100+199)/4=100 tiempo de respuesta promedio ponderado = suma de todos los tiempos de respuesta ponderados del proceso/número de procesos (1+ 1+100+1.99)/4=26 .
2. Algoritmo de programación por turnos de intervalos de tiempo
(1) Contenido del algoritmo: el algoritmo de programación por turnos de intervalos de tiempo se utiliza principalmente para la programación de bajo nivel, y el método de programación es en realidad un algoritmo de programación preventivo basado en el reloj. En un sistema que utiliza el algoritmo de programación por turnos de intervalos de tiempo, las colas de procesos/subprocesos listos se ponen en cola en el orden de la hora de llegada.De acuerdo con el principio de orden de llegada, todos los procesos que deben ejecutarse se organizan en una secuencia ascendente de acuerdo con el tiempo de llegada. Cada vez que un proceso recibe un intervalo de tiempo del mismo tamaño. En este intervalo de tiempo, si la ejecución del proceso finaliza, el proceso se elimina de la cola de procesos. Si el proceso no end, el proceso se detiene y luego cambia a un estado de espera, y se coloca en la cola de la cola del proceso hasta que todos los procesos hayan terminado de ejecutarse.
(2) Requisitos del algoritmo: cada proceso está representado por un bloque de control de proceso (PCB). El bloque de control de procesos puede contener la siguiente información: nombre del proceso, tiempo de llegada, tiempo de ejecución, tiempo de finalización, tiempo de respuesta, tiempo de respuesta autorizado, indicador de proceso completado, tiempo de servicio restante, etc. El tiempo de ejecución de un proceso se calcula en unidades de intervalos de tiempo.
(3) Idea de diseño: cada vez que programe, seleccione siempre el proceso líder de la cola de procesos listos y déjelo ejecutar un intervalo de tiempo preestablecido por el sistema en la CPU. Un proceso que no ha terminado de ejecutarse dentro de un intervalo de tiempo regresa al final de la cola de subprocesos y se vuelve a poner en cola para esperar la próxima programación. La programación por turnos de intervalos de tiempo pertenece a la programación preventiva y es adecuada para los sistemas de tiempo compartido.
(4) Análisis de algoritmos: primero defina una estructura RR;
entrada () función de entrada;
La función rank() ordena la hora de llegada del proceso;
La función rr_pcb() ejecuta el algoritmo de programación por turnos;
salida () función de salida;
main() función principal.
(5) Código central:
#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) Datos de prueba o capturas de pantalla: (Consulte la Figura 1 para el intervalo de tiempo 1, consulte la Figura 2 para el intervalo de tiempo 5)
Figura 1 Captura de pantalla de los resultados de la ejecución cuando el intervalo de tiempo = 1
Figura 2 Captura de pantalla de los resultados de la ejecución cuando el intervalo de tiempo = 5
(7) Análisis de los resultados de la ejecución: la imagen del tiempo de ejecución es la siguiente,
Figura 4-24 Imagen del tiempo de ejecución
Cuando el intervalo de tiempo = 1, el tiempo de ejecución de los cuatro procesos a, b, c y d son más largos que el intervalo de tiempo especificado. Si no terminan de ejecutarse dentro de un intervalo de tiempo, todos deben volver al final de la cola de listos y esperar a la próxima programación para continuar con la ejecución. La CPU se asigna al primer proceso en la cola lista actual.
Cuando el intervalo de tiempo = 5, el tiempo de ejecución del primer proceso es igual a 20>5, y si el tiempo de ejecución no se completa dentro de un intervalo de tiempo, el proceso a regresa al final de la cola lista para volver a poner en cola y esperar al siguiente programación; el tiempo de ejecución del segundo proceso es igual a 10>5, cuando se agota el intervalo de tiempo especificado, el proceso b vuelve al final de la cola de procesos listos, a la espera de que se programe su ejecución nuevamente; el tiempo de ejecución del segundo el proceso es igual a 15>5, luego el proceso c regresa al final de la cola lista, y espera hasta que se ponga en funcionamiento cuando vuelva a sí mismo la próxima vez; el tiempo de ejecución del cuarto proceso es 5, y solo termina de ejecutarse dentro de un período de tiempo, luego el proceso d renuncia al derecho de usar la CPU. En este momento, el planificador de procesos asigna la CPU al primer proceso en la cola de espera actual, a saber, el proceso a.
3. Algoritmo de programación de prioridades
(1) Contenido del algoritmo: el algoritmo de programación de prioridad se puede aplicar tanto a la programación de alto nivel (programación de trabajos) como a la programación de bajo nivel (programación de procesos), y también se puede usar en sistemas en tiempo real. En la programación avanzada, el algoritmo de programación del número de prioridad selecciona el trabajo con la prioridad más alta de la cola de trabajos de respaldo y lo carga en la memoria, le asigna los recursos correspondientes, crea un proceso y lo coloca en la cola de proceso listo. En la programación de bajo nivel, el algoritmo de programación de prioridad selecciona el proceso con la prioridad más alta de la cola de proceso listo para asignarle CPU y ponerlo en funcionamiento. Si hay varios trabajos/procesos con la prioridad más alta, se puede combinar con políticas de programación prioritarias por orden de llegada o trabajo corto/proceso corto.
(2) Requisitos del algoritmo: cada proceso está representado por un bloque de control de proceso (PCB). El bloque de control de procesos puede contener la siguiente información: nombre del proceso, tiempo de ejecución, número de prioridad, estado del proceso, etc. El número de prioridad del proceso y el tiempo de ejecución requerido se pueden especificar manualmente de antemano (también se puede generar mediante números aleatorios). El estado de cada proceso puede ser listo W (Esperar), ejecutar R (Ejecutar) o completar uno de los 3 estados de F (Finalizar).
(3) Idea de diseño: al usar el algoritmo de programación de prioridad preventiva, el proceso/hilo listo con la prioridad más alta hace que la CPU se ejecute primero y se le permite ser reemplazado por el proceso/hilo listo con mayor prioridad durante el proceso en ejecución. Si hay varios procesos con la prioridad más alta, se combina una política de programación por orden de llegada. Antes de cada ejecución, su "número de prioridad" y "tiempo de ejecución requerido" se determinan arbitrariamente para cada proceso. El procesador siempre elige el proceso líder para ejecutar. Se adopta el método de cambiar dinámicamente el número de prioridad. Cada vez que se ejecuta el proceso, el número de prioridad se reduce en 1 y el tiempo de ejecución requerido se reduce en 1. Después de que el proceso se ejecuta una vez, si el tiempo de ejecución requerido no es igual a 0, se agregará a la cola; de lo contrario, el estado cambiará a "finalizar" y se saldrá de la cola. Si la cola de listos está vacía, finalice; de lo contrario, repita los pasos anteriores.
(4) Análisis de algoritmos: definir el bloque de control de procesos;
función de entrada ();
función de salida ();
La función max_priority() encuentra el proceso con la prioridad más alta en el estado listo;
La función psa_pcb() es un algoritmo de programación de prioridades;
main() función principal;
(5) Código central:
#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) Datos de prueba o captura de pantalla:
(7) Análisis de los resultados de ejecución: al principio, los estados de los cinco procesos a, b, c, d y e están todos en el estado listo (W), entre los cuales c tiene la prioridad más alta, luego c es el primero para ser ejecutado por la CPU, y su tiempo de ejecución es 2. En el estado de ejecución, el tiempo de ejecución se reduce en 1, y el número de prioridad se reduce en 1, el tiempo de ejecución del proceso a es 0, y el estado de un cambia del estado listo al estado completado; después de eso, los números de prioridad de c y e son los más grandes, pero de acuerdo con la política de programación de orden de llegada, c está en el estado de ejecución primero, el número de prioridad se reduce en 1, y el tiempo de ejecución se reduce de 1 a 0, por lo que c se convierte en el estado completado; en este momento, solo tres procesos b, d y e están en estado listo, de los cuales e El número de prioridad de e es el más grande , luego e obtiene la CPU y la pone en funcionamiento, su tiempo de ejecución se reduce en 1 y el número de prioridad se reduce en 1; entonces los números de prioridad de b y e son los mismos, de acuerdo con el orden de llegada. servir la política de programación, entonces b se adelanta a la CPU y está en estado de ejecución. Si el tiempo de ejecución se reduce de 1 a 0, entonces b se completa; en este momento, solo quedan dos procesos d y e, y e tiene un mayor número de prioridad, entonces e se adelanta a la CPU y está en estado de ejecución, y el número de prioridad y el tiempo de ejecución se reducen en 1; e El número de prioridad menos 1 es el mismo que el de d, pero según el orden de llegada -Servido principio, d obtiene la CPU primero y está en estado de ejecución, y el número de prioridad y el tiempo de ejecución se reducen en 1; en este momento, el número de prioridad de e es mayor que d, por lo que e obtiene la ejecución de la CPU, el el tiempo de ejecución y el número de prioridad menos 1; los números de prioridad de d y e son los mismos, pero d se ejecuta primero, el tiempo de ejecución y el número de prioridad menos 1, luego el número de prioridad de e es mayor que d, e obtiene la CPU , y el tiempo de ejecución se reduce en 1. 0, e está en el estado completado; al final, solo queda d para que la CPU se ejecute, y el tiempo de ejecución se reduce en 1 a 0, convirtiéndose en el estado completado. En resumen, el proceso con alta prioridad primero obtiene la CPU en estado de ejecución. Después de ejecutarse una vez, el tiempo de ejecución y el número de prioridad se reducen en 1. Cuando el tiempo de ejecución no es 0, se agrega a la cola de procesos listos. el tiempo de ejecución es igual a 0, el estado cambia a fin (F). Si hay varios procesos con la misma prioridad, se procesarán por orden de llegada.