优先级调度算法

杨利霞

& X! z. I3 t1 G( A优先级调度算法
1 r' p  Y+ f- Q2 z9 T

算法介绍
8 y$ g% c7 p0 X: q8 l* c; b  G优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
+ M# v7 }2 u1 p5 P" G$ P+ |只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
( q8 C  ^* X$ q* o. J2 H静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权

算法实现

抢占式动态优先权：

PS：本人认为非抢占式静态优先权没有实际价值。

• 
  
  #include <stdio.h>
  
  9 f. c: C  i1 Y( `$ p9 ~- j
• 
  6 V5 R- `& n" X- X) `
  # y. @( P% b3 C* k7 J; A# H#include <stdlib.h>  
  ; `3 ^) j/ p7 y+ K
  
• 
  - _) S) }: \3 }& _% s1 ]$ r
  #include <string.h>  
  
  
• 
  5 M1 j  j$ `1 e9 s
  % B) z& H$ Q, x" w" mtypedef struct node  
  
  2 Z% X' l0 `: ~7 p! P
• 
  
  {  
  ! S7 g; c% A% f- G, a" F) y7 S0 g1 J
  " ~6 r- a, W8 R& }. N! j  U6 l
• 
  
  : m( O, ^+ v9 U$ d3 ~# y   char name[10];  /*进程标识符*/  
  
  
• 
  " y. r, M9 [, l) F0 h
     int prio;   /*进程优先数*/  
  2 u# F) g* t" Y4 r3 I# R
  
• 
  
  , ?, H- r7 c2 J   int round;  /*进程时间轮转时间片*/  
  2 u9 J  X% {& Z2 g8 l+ T7 R# T: D
  
• 
    M- \! k: y& I
  ( L/ P3 x4 D  j4 h   int cputime; /*进程占用CPU时间*/  
  
  
• 
  
     int needtime; /*进程到完成还要的时间*/  
  
  " J, ^% k" t4 M' l
• 
  6 m0 c# \- W; r3 ?
     int count;  /*计数器*/  
  
  
• 
  - b. \+ J/ Z7 A
  & }5 O7 P- N. J2 W   char state; /*进程的状态*/  
  % q. b5 ?) O$ c7 v
  1 q7 {' V: z+ f$ Z
• 
  ; C7 E5 z) @% z+ M- `/ P& u
     struct node *next; /*链指针*/  
  1 |! _% e) }1 |( Q, s! {/ |
  / z" k( `4 c# b0 ~
• 
  
  }PCB;  
    a1 C5 _- \5 Y; M
  + |/ |, N! e4 q7 }
• 
  5 [: x' \! F' P( W
  : _5 ~9 z5 x! w4 @" z' RPCB *finish,*ready,*tail,*run; /*队列指针*/  
  * b4 ^7 ?) b4 Y* c- t" G$ Z
  
• 
  6 z$ D6 W3 {- S' [8 ~
  int N; /*进程数*/  
  
  
• 
  
  + w& S8 C# v' z2 I8 T/*将就绪队列中的第一个进程投入运行*/  
  
  % @4 w; S' E) a& q0 m* D
• 
  % q1 q( v% r9 C& }- D
  5 `- v: i6 n' S! g7 v& cfirstin()  
  
  
• 
  
  {  
  
  % P7 P& f: }  \3 _; v$ X: ^" ?
• 
  3 T! h/ y! z' @1 H2 _
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  % f4 {' r. {1 g- Q
  
• 
  5 y* H# W& g1 B( t3 U0 [
     run->state='R';   /*进程状态变为运行态*/  
  
  1 j' r3 l/ c3 e% ?' \7 u  W
• 
  
  1 D- b$ }6 u$ q0 Y- S# T1 a) ]   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  . E$ @$ X- r$ S
• 
  : |$ H8 c% P- D9 N& j! {5 \
  }  
  
  
• 
    m/ S! \& R  S0 J( i0 ]
  2 h+ O3 |2 T; U5 Z  R1 h& h/*标题输出函数*/  
  ' v; b' J" {$ {9 j5 B- K& u& Z
  
• 
  
  ( l% i+ v/ v) L3 k; x* r) [void prt1(char a)  
  
  
• 
  
  , U3 h- b2 l; \2 b{  
  
  
• 
  5 K9 j/ S( H5 _2 e$ ?7 X4 b4 V
  ' ]$ s6 @- v; R1 B9 q6 U( \$ H5 `   if(toupper(a)=='P') /*优先数法*/  
  2 [* N- d5 v+ V" l! Y- x- `' M! N
  2 Y# c2 k) r3 K2 `3 h6 N) Q
• 
  
  7 n2 W9 S, Y- P      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  ! _# [4 j, x- u7 r
• 
  1 y- h2 ?; Q6 y, F
     else  
  3 e2 `; G' C/ W' i
  
• 
  
  # N' k' Y6 {+ s! }* I      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  
• 
  - e3 O0 H* Z; r4 h* Z) R
  }  
  # c, q( Q# c% C5 S$ x# n6 W5 N* z
  
• 
  , I6 z; D5 x$ R0 W# b. [$ }+ u1 }8 i
  /*进程PCB输出*/  
  
  
• 
  % t3 p) z4 |9 u( H2 t, i
  void prt2(char a,PCB *q)  
  2 K9 n* E- d( A4 B  L; ?/ ~; w
  4 L3 J8 N, |+ w9 i$ ?
• 
  ' @9 x4 i1 p9 A6 l* j' @
  ' p4 Z/ w0 J5 c* m6 u  e{  
  ; r0 F7 u" z- n/ i* {
  
• 
  ' k- C' _2 Z. ]' I$ x9 o9 i* y# r6 c# P0 `
  0 w6 M' }. P! {' R7 I, Y, c   if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  / G5 n( ~; v: Q3 _; d0 |$ l9 u
• 
  4 U) Z% P% A' X0 o- X4 T5 i% O" T
         q->cputime,q->needtime,q->prio,q->state);  
  " p0 w8 K9 p) ^3 G/ N5 O
  # Z% n, \3 F' ~
• 
  
  # S- w9 Y1 e( k: q  f0 G   else/*轮转法的输出*/  
  ( d8 k9 l: g3 e8 |
  ( F% `0 M5 J# h4 Z6 L& o' L
• 
  ! ?  a% h3 A4 K! Q2 u
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  % b* L+ i' p+ D# ]' H' @
         q->cputime,q->needtime,q->count,q->round,q->state);  
  
  
• 
  3 G5 C: I0 W9 H# L
  }  
  
  1 t9 l" Z, F* ~+ v4 O
• 
  
  /*输出函数*/  
  1 e( W7 B" I. m( @! b
  9 H' U* O  G' X3 \% Y
• 
  
  void prt(char algo)  
  
  
• 
  
  {  
  
  5 e" L% f- U0 A0 Q. `! x$ A
• 
  
     PCB *p;  
  
  $ i; p/ {5 w0 `8 |+ F7 q
• 
  7 `' w( q& ?9 i0 V9 W
  # L5 T. y: j5 ]3 a3 ^   prt1(algo);  /*输出标题*/  
  & J0 [" U: o  m- E7 ^8 d
  1 _- a$ c# Q7 P/ ~9 V/ i
• 
  8 D: ^3 x  Y2 F; g! S  T1 N0 r) w5 ]
     if(run!=NULL) /*如果运行指针不空*/  
  " q- @0 ?/ q$ l+ E' |, @- y
  " u% X1 n4 h% o
• 
  - a( C3 ]# F6 N/ b! a1 b
  3 T( o; J2 B5 ?7 ]; B& r3 a      prt2(algo,run); /*输出当前正在运行的PCB*/  
  , \: _1 P1 T( W% `# k
  
• 
  ! u% Z+ V' {9 k
     p=ready;  /*输出就绪队列PCB*/  
  
  
• 
  % v; ^" ?$ j6 o* L' f6 k
  2 u( l( a, q# U* K   while(p!=NULL)  
  
  
• 
  , w. K; a1 f( b" M3 ]$ H
  8 j  W1 f6 ^3 r" X   {  
  
  & V; _+ h1 U7 X3 e/ }
• 
  
        prt2(algo,p);  
  6 A; \6 a4 G# L" C+ U% ?: x
  
• 
  # `( G4 l' K# e- }
  ' O3 [4 q$ {; e      p=p->next;  
  : r: Q3 {  R% C+ |7 n* D
  
• 
  
     }  
  6 A3 O0 P- p6 f) e( c3 x$ _% p
  8 i0 f' A. a8 p" Z9 d2 \* _! }
• 
  
  9 w# `9 `, C4 j; o+ W! ^   p=finish;  /*输出完成队列的PCB*/  
  
  8 ~0 Z' \8 W- M7 B" K# J2 G
• 
  ' C) D: j. w, e& e3 s
     while(p!=NULL)  
  / Z+ i9 ~" k8 ~  Y) J5 }" G
  
• 
  + x' w) A0 a- }8 `. \8 T& M' L
  6 G" A1 |# z: z   {  
  ! {1 t8 d. F5 W, }5 a, p1 C; x
  3 [0 |6 B/ C- v0 R4 G" o! W4 x
• 
  
  1 A. @% z4 V* f/ V. L( t      prt2(algo,p);  
  ( b: c6 B# G7 ~" t2 A
  ' H$ j& x+ Y. ~1 a% I* Z# M2 A8 S
• 
  
  2 O3 `( M& Q- w( S( ^! k; A      p=p->next;  
  
  % O& R* H( S( ]" T8 M
• 
  " @2 i  W8 t8 ?) K3 q: N
     }  
  
  , ~+ G3 S8 X9 |) r# s* s
• 
  # J$ d# P' i7 n3 B
     getchar();  /*压任意键继续*/  
  7 j' J4 ]5 O8 J& U6 O. g
  
• 
  
  * b% P$ ~% l* T/ n3 m}  
  
  
• 
  5 m0 A: U) O! L0 m' T; C6 X
  6 ?& h( s$ t7 J: a" |7 Z% C6 V/*优先数的插入算法*/  
  + T* g; R; e3 U% f  e
  
• 
  ( }6 V: L  q& g- q9 \, S
  insert1(PCB *q)  
  ' S$ y' r/ p. ~1 n
  
• 
  
  {  
  2 i* w- p& L6 Z) @; ~8 S6 Q- K
  
• 
    X$ h# ~# n- D
  & j2 Q0 _2 D1 H; P   PCB *p1,*s,*r;  
  
  & |) ?8 {. D" P. {+ k
• 
  8 C1 [# @. @+ r7 w
     int b;  
  
  
• 
  3 ?. U( O: |- p5 t
  ( y5 A: o0 T2 c" X; f  {   s=q;  /*待插入的PCB指针*/  
  
  
• 
  
    C, E- ~+ x6 _0 B; u) Y4 g- A. Z   p1=ready; /*就绪队列头指针*/  
  
  
• 
  $ G( v7 U# {$ R( o
     r=p1; /*r做p1的前驱指针*/  
  $ q3 s' p4 I; g1 N/ J! }' b/ B
  # ^3 d- d- m  {& X) T
• 
  7 q6 D! U! |  J* v0 X2 f
  ( F0 i! N# s0 o% G8 Z   b=1;  
  
  & e( f! [1 Q0 v" a) S# i) [
• 
  3 J) h/ U+ c1 }* ?" @$ `5 I% {; |
  6 ^: O# v1 A" G2 C; r* [$ e% h& U   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  5 I% k2 J7 P' T' l
  9 w6 X) T% l0 W
• 
  
  1 L( ]4 o4 D4 f  [% N      if(p1->prio>=s->prio)  
  . ?: l6 j9 p: T9 @1 d8 b' `
  
• 
  
  ' F1 D# K+ X% N, K9 l6 @3 }" _0 A, v      {  
  
  
• 
  . [- L1 W# l9 I) h4 B! \1 W3 J% O# U
       r=p1;  
  " p5 [) k5 P1 o- W+ p1 m; j, H
  
• 
  8 y7 C; B, H0 B  ^" \
       p1=p1->next;  
  
  
• 
  ' h: U: m* {! Q% C9 s5 k, ?* c" Q
        }  
  
  9 L; f0 C% R6 T- ?
• 
  ! @  F  N1 p  _) u0 g/ O& U8 x" c
        else  
  
  0 j  ?% _" t4 L: z4 ~# N. t! ~3 A
• 
  
  * O) [9 M1 V0 x. W- {% D     b=0;  
  
  & `+ k8 g2 S* v$ a0 J2 b, ?
• 
  
  & l5 u6 t+ d% Q" ~% M   if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  & m& |1 H% x9 I4 C- m( |
  ' j) t& P/ o# U3 y( Z
• 
  
  + d5 D5 p/ k& i2 A1 N* E6 C   {  
  
  0 \$ I6 b4 m0 i0 C
• 
  & z; N$ F1 f1 t! x. X; \* m
        r->next=s;  
  0 U' R9 {) _/ c( y6 l
  , D' s$ q/ l' r6 G; A4 p. i: s
• 
  
  0 V& M5 H# s% ?! {1 ]  L      s->next=p1;  
  1 E* \- |: R0 U0 l7 q0 |& `
  , u: M5 {. G+ r, G; m$ J
• 
  
  3 k% d1 z: z# m3 b' I   }  
  
  1 B9 D6 X% _- y( m
• 
  % k4 K0 Q# d2 q; e( {% ]
  : h; ~% z% A4 M7 J# j' v   else  
  . M6 U) G4 g. i5 s: J, v. B
  
• 
  / n2 f& Y7 _0 S2 f1 S- x! D+ s
     {  
  
  
• 
  9 ]) y, y" u- v; _0 U& [
        s->next=p1;  /*否则插入在就绪队列的头*/  
  
  , Q7 F& I" C; w: j
• 
  # n# q& e) M: p' ~* [4 _% M9 ^5 q
        ready=s;  
  ( q' }; \# @' B0 ?( l5 G+ A
  
• 
  & [" p' l" p* Q3 g) `) i9 E
  * i6 ?) ~  S3 x* }   }  
  
  
• 
  8 G, |0 t9 T0 ~# N$ _" G1 C
  }  
  
  
• 
  1 w- ]9 {! G6 T
  & J: ~' j, i, V0 b; p/*优先数创建初始PCB信息*/  
  
  & p! S* o! \; |8 T7 z
• 
    [1 J  z- e9 A& }: O7 [
  void create(char alg)  
  
  + R4 T7 g0 `. z. s; ?! Q+ W
• 
  
  {  
  
  
• 
  
     PCB *p;  
  
  
• 
  
  ' E- C% c2 D  ~! G0 c   int i,time;  
  
  1 g( B! c1 M; d% H
• 
  0 C: o& u: l- p5 {1 M
  1 k# M- p' p6 k5 [! n8 s; ~5 G   char na[10];  
  
  
• 
  
  # u0 ]+ p: p% L% a   ready=NULL; /*就绪队列头指针*/  
  * M/ S; c% {2 L! Q* p9 E5 l
  1 Z: d* i" g/ p3 L
• 
  
     finish=NULL;  /*完成队列头指针*/  
  ! u  t+ W# e+ P3 ]  w! h9 T( H: `
  
• 
  6 z* L( q% y, z! i) f
  7 H  x3 u0 D$ E/ g$ y. L& V   run=NULL; /*运行队列指针*/  
  
  
• 
  ) A& `! V* F7 w6 P4 a) b
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  ) U# y# K* X- Y; D
  
• 
  
     for(i=1;i<=N;i++)  
  
  
• 
  
     {  
    V' w6 b0 g' Z
  
• 
  $ U7 c2 [9 b5 S) n+ K- ]
        p=(PCB *)malloc(sizeof(PCB));  
  
  8 D( G. B' |  T' U# d8 e; W7 n/ g
• 
  + Y9 n5 k# H% P# f) c% J) z
        scanf("%s",na);  
  
  
• 
  # W5 P( u: v+ A
  " j6 P7 V, R" U$ M  _      scanf("%d",&time);  
  8 q/ Z% i8 l  n3 H( s7 S6 r  A3 n
  
• 
  7 F" S8 d1 j" H. N! W
        strcpy(p->name,na);  
  7 i# z2 i" J- K* I2 `& K
  
• 
  
  9 u1 P$ e) {( e3 f  n- L      p->cputime=0;  
  
  0 Y0 |9 `  b' O  M6 Z4 D
• 
  5 Z& h  z# A. {7 C- f
        p->needtime=time;  
  / n( ~5 H; o7 z9 B& R0 N
  
• 
  
  $ ?) c' L( I  w5 d- F$ s. W6 U      p->state='w';  
  0 C" M, r  l: w$ r
  $ V$ _$ w7 j3 o) ?6 T1 C; V
• 
    J6 P. ?4 x8 c7 P
        p->prio=50-time;  
  " G9 R* J0 z# N- g
  
• 
  8 v1 Q; y, l$ t( I6 X' G: Q$ R& s
  # o3 ~3 t" S1 R. ^2 D, d      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  ; O0 m. `. G5 ~( j2 {7 r; {  m
  
• 
  
       insert1(p);  
  
  ) \' x9 d7 S. a" n3 z1 E
• 
  ) C3 l0 }8 X4 v' S9 C( F
  6 F9 r# g8 B! L3 N0 d- t( U      else  
  
  3 i  D, e2 t, a9 |6 ]
• 
  - {5 {: ~& b3 |+ e( F$ P
        {  
  
  
• 
  8 u3 g! T; S6 p7 n! u9 X" U' |
  1 v  Z% L  @" H1 B6 Z$ W/ R     p->next=ready; /*创建就绪队列的第一个PCB*/  
  , c. X% h0 ]- i: _7 U
  7 u( Z  r1 H2 ?$ }$ N4 Y$ C
• 
  
  ( H0 s2 Y1 \' P* w: h, A% M! H# u     ready=p;  
  
  5 C& @" Q& K4 u( k
• 
  
  ) D# g) @5 C* s+ ?  J! a: C0 l! t      }  
  
  % _- R$ e! S; s7 B
• 
  
     }  
  
  ( O6 @7 u( m; a+ m
• 
  " D* {  S2 s, u$ L# D4 M: [
     printf("          优先数算法输出信息:\n");  
  6 X' H- e; j+ k% l
  4 ~) e1 S, X* s
• 
  ; O% _/ y) Z: y
     printf("************************************************\n");  
  ! `6 c' d4 v; V* p3 a- d5 {
  * J' j* a/ s1 C3 ?# X: U1 o3 G" H+ S
• 
  
     prt(alg);  /*输出进程PCB信息*/  
  6 G9 Z4 ~6 i) T2 Q  x! o
  ( m& }' C! v4 s8 k, |: \9 N
• 
  
  , b0 A0 d& g  F& V   run=ready; /*将就绪队列的第一个进程投入运行*/  
  + F/ j& ]$ s# [! ^& i7 f! A: Y
  " m6 ~& J( V6 Y3 t: u* f
• 
  
  ; A0 |0 O; c+ a1 G   ready=ready->next;  
  3 q" q" n& W2 i9 r1 F' ]
  
• 
  
     run->state='R';  
  
  * z( `( a/ _, F% O
• 
  
  }  
  ( k; o, d) [& J4 |. @
  3 z! |. `7 }# S; @$ L
• 
  
  * T$ E4 o" D5 c+ L/*优先数调度算法*/  
  ( V6 F( V3 _; X4 k2 ~: ~
  & y6 X' P9 x/ e9 K" e
• 
  
  priority(char alg)  
  4 L. j8 ^* E' l, u' Q" F
  ( V# N5 Y) S0 }- }& n
• 
  
  ( r% U* t# v" K  u/ P, K{  
  - R, A7 Y# K( X3 z4 \1 ^
  + D# v* ]8 P; j& ^" {
• 
  & l& K# B4 Q0 h9 S! T
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  ) }, K6 @1 r( Q  R. |3 ]+ N: ?
  9 U8 A3 c1 ~3 X1 o( h0 P* Z4 G/ W
• 
  
  1 W, n7 ]# m* @; S   {  
  9 |. e  j9 `9 x- r! x& `% n
  - }* r6 F3 [: W6 v
• 
  ; C" a) x% `4 B! e
        run->cputime=run->cputime+1;  
  
  
• 
  
        run->needtime=run->needtime-1;  
  3 D  `) ]1 u2 q, p5 I1 ^9 h
  
• 
  % L8 K0 i! o/ `" }$ f! Q
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  ) o. O3 L+ r. n/ @% E
• 
  
  1 P$ a* l8 w2 i) G) \/ z      PCB *p;
  
  
• 
  , t8 x7 K& o- t' b8 W. i
  " n, j4 N' L. V. W7 V      p=ready;
  - X. E7 a3 |1 d/ S9 a0 L* R
  . @8 }$ x6 d7 @- z/ }0 c( ?' @1 `0 L
• 
  ; k( S9 x  e/ b. f  O5 f
  ; f, l6 ~! t0 j; y      while(p!=NULL)  
  9 k6 ~4 E0 H0 o0 C
  
• 
  # R4 X2 b( z4 M/ }6 o/ H2 ]
        {  
  
  
• 
  
  " P8 h# b6 N9 f+ [0 W6 M' C          p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  2 M4 |) W! A' b0 Q: b3 n' B1 }
• 
  - F  L1 L$ q% G  b3 |
  8 V: Q. H2 f- i- C0 t) t; g4 N% a  }6 r          p=p->next;  
  6 o: z' r& s1 o) V
  ! @: a. c- ~  ^9 ]' J
• 
  
  6 S/ }5 @8 k' m! F      }  
  
  
• 
  
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  
• 
  % n! e+ _) Y1 ~* H  }
  6 K8 q- b# n7 y4 c: e- Q$ L) p& _. ~      {  
  
  9 z" O( q, e4 s1 Z1 y. J
• 
  7 j3 b& {, C: F0 f
           run->next=finish;  
  0 C, V- a. f' e% N- }% \$ y6 o9 D" h" @
  & x0 v. N& u/ O/ Y
• 
  
           finish=run;  
  / `/ m3 b! l" t
  $ F* l! z! Y% {. {+ S0 C5 N/ f
• 
  9 Y" E1 b2 j' ~& k. J9 p
           run->state='F';  /*置状态为完成态*/  
  + q! b2 Y. W, O1 w' V+ r
  
• 
  ; [( B9 d( A2 A) ?
           run=NULL;  /*运行队列头指针为空*/  
  + y1 f7 ?4 Z$ ]6 d) X3 ^6 w9 W9 Y
  : U! ]0 g  \: T! Z
• 
  
  6 ]* h2 K" [# v% Y& O3 ?         if(ready!=NULL) /*如就绪队列不空*/
  
  ( I1 ~: S- W4 q
• 
  
  ; I; h- ~$ H' b. I* u# D4 Q         {  
  
  ) O) D# M/ \& {! B2 X( P8 r
• 
  ) w$ h8 ?1 |. e. s% B
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  $ ^! V; s0 Z# D
  
• 
  
  3 A, H' H3 q8 r8 @4 o) y: K5 }$ V, ?         }
  
  . R# E" s9 o: S$ \
• 
  
  , d1 |$ q+ S) u* l      }  
  ( p7 S7 Q* l; z# g: {* B
  
• 
  
  # o! g0 q  u$ y6 S0 j* A" ~5 p2 H* B      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  7 g8 x8 m+ k+ Q2 J5 s- k
  
• 
  7 z+ G4 A" ?4 ]6 n
       if((ready!=NULL)&&(run->prio<ready->prio))  
  
  + m0 t' }3 P3 {
• 
  
  ) E0 q. @0 ]1 l( f, R3 ?     {  
  
  
• 
  1 H, s& l* |3 o! @" ]7 w
          run->state='W';  
  
  
• 
  
          insert1(run);  
  
  4 j3 [, b. x6 c# b
• 
  
  4 ]" z/ I% W8 k, c" P- v        firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  & f0 P* k. c" {( S! z. n! h9 ]2 o
       }  
  
  
• 
  
  3 W3 L' q9 m4 S8 E- {& ]      prt(alg); /*输出进程PCB信息*/  
  
  ' u1 `) r" c/ u, y1 h# W
• 
  
     }  
  ; F5 A  {  H; e0 [, p8 j* O
  " s# v6 N# Z6 g# m$ ?0 Z% {* X$ t
• 
  : u) h0 H/ `2 v4 ]
  }  
  * F1 A$ J8 b% Q; b
  & N. u* `8 f4 N& c/ G: J
• 
  ) r- ^" V. w5 D& _
  /*主函数*/  
  * \3 Y3 A6 `$ A$ m  A! G
  
• 
  0 D/ B* {% l$ h( W
  main()  
  
  
• 
  5 y) [2 H, S/ \" e# b% D1 u) S3 w
  {  
  - l  n0 q/ i% W5 Y( X
  6 {& y: I( n: l* z
• 
  - \9 ~! d6 L+ n
  & S! A3 U  a5 Z$ f+ v- q   char algo;  /*算法标记*/  
  
  $ z7 P$ t" F& L- J% a
• 
  
  * f. s) E$ `7 F6 W6 U9 V   printf("输入P确定算法：优先数算法\n");  
  
  
• 
  9 W: M4 C8 L8 P' ~- Y* q
     scanf("%c",&algo); /*输入字符确定算法*/  
  % E# m& \) y% i9 F
  
• 
  
     printf("输入进程数：\n");  
  ' S& J( _+ L0 W" p
  . s% V7 j# h" z  h% ^" g1 V" Z
• 
  % {, }; P( m5 H+ @3 G& j
     scanf("%d",&N); /*输入进程数*/  
  
  # w4 q4 A+ n1 \2 R
• 
  3 n7 W! x; ^+ J8 G
  5 U1 L- v4 H+ N   if(algo=='P'||algo=='p')  
  0 f% R) x& y, D, r
  
• 
  
     {  
  
  
• 
  
  $ |2 r6 b; }4 R+ n/ m/ Q- b      create(algo); /*优先数法*/  
  4 r( k; `: n+ I- Z
  " y" S5 }5 r: [- g
• 
  
        priority(algo);  
  
  " U, }/ f3 J/ J' J0 _. }& v/ S; O' ~: C
• 
  
     }
  
  
• 
  8 e# n. v, y* R4 E  `: ~
  ! @# e9 u+ v: x2 ]% i2 D. u}
  ! i8 g2 T$ R0 g* Q" G" U% T2 r$ M
  
  * f6 z2 m' n# I. x9 e+ G& @' \) k

输出结果：
" Y: B  M  ^; R

原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

) t. `1 Q8 d& M& B7 ~& w# I
5 m& `* Y! s* p. K