优先级调度算法

杨利霞

优先级调度算法
1 O, G! Y; p" j' W

算法介绍
优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
' \5 ~# T% G, ?6 V1 A5 F- G系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
0 l0 u; J0 ?8 L4 i! h* l* {2）抢占式优先权调度算法
( Q( Q2 l* L8 C, \只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
0 J8 u+ d  w' C2 @% g1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
' v3 d: J# Z- ^# s, ]

2）动态优先权

算法实现

抢占式动态优先权：

# ]+ H' z& t9 J+ X1 qPS：本人认为非抢占式静态优先权没有实际价值。

• 
  ) M2 P, G' H8 z7 ^3 Y
  ! G) z( U& o: k& w/ a7 o#include <stdio.h>
  
  9 n. W! x5 F; \1 r4 ?0 j  Y. E  f
• 
  1 f. Q, D, E6 G' \5 l7 X8 s
  #include <stdlib.h>  
  " v' j0 Z" `* L  z& j5 t
  $ m- v0 i2 z4 S; \# C' N
• 
  
  " A" _+ O* Z' e) o6 X9 x! ]) [( c  D#include <string.h>  
  
  
• 
  
  typedef struct node  
  1 c) I/ \+ @' A% d4 Q% o) S* _
  
• 
  & V' z' L6 ^& ^' B/ _
  {  
  , Y+ b. h; g- o) A7 Y* ]' K
  
• 
  
  ( e7 J* {$ f4 f7 s( w   char name[10];  /*进程标识符*/  
  
  4 W& c% a, [( K. r
• 
  
     int prio;   /*进程优先数*/  
  
  
• 
  ; ]  w0 @$ ~* G. p
     int round;  /*进程时间轮转时间片*/  
  & U" U4 S8 |+ ]5 C+ D1 _# r
  ( J& f, B# y) V  C. O, m
• 
  + ?- E! i5 V4 P3 [0 O% y
  ) Z# p4 J9 s* g   int cputime; /*进程占用CPU时间*/  
  % ~' e  X) n. z1 n7 A% |
  
• 
  
     int needtime; /*进程到完成还要的时间*/  
  , D$ R. _6 c/ }) d1 g( n3 V
  - J" o  @) C1 ^
• 
  
     int count;  /*计数器*/  
  / b, x$ _5 f0 e/ m# k
  7 w- n) j) E+ U2 \
• 
  / G$ S/ o0 V+ ?! {) E3 @0 ^" J
     char state; /*进程的状态*/  
  
  
• 
  
  & J$ ]% a+ P% H' R# r) L# W   struct node *next; /*链指针*/  
  ; s6 G5 _$ |! V& d3 M
  
• 
    Z! L* q1 j- k( l% ?1 c
  }PCB;  
  * K' `# ^5 v  K. |, z
  
• 
  . d+ l5 _% J7 Q' u
  ' D/ ]5 K0 ]. O, M0 `) b0 VPCB *finish,*ready,*tail,*run; /*队列指针*/  
  ' B; D- s/ U' r2 u
  
• 
  
  int N; /*进程数*/  
  
  " v; s8 `# v2 L7 |
• 
  
  : I) \! g7 w0 v* @( f$ [) j/*将就绪队列中的第一个进程投入运行*/  
  
  ' X: W1 G: @( e* M7 e
• 
  + a8 D" y0 }1 _% {8 K' y  s" J
  firstin()  
  3 o+ I* n" k# }2 W& V; i$ K
  * M; u) E& J4 }7 ~! f  a* f# A! _
• 
  
  # a" o8 k" L* j* Z( ]9 N{  
  . T, T) d8 m* q' z5 d
  
• 
  
  / @4 [" B9 e5 A. n7 E4 N   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  + ~' X* X) Y2 _9 R
  9 @$ _# s# |+ x3 y' J6 L  ?
• 
  
     run->state='R';   /*进程状态变为运行态*/  
  
  # a) ^! t6 b3 N
• 
  & M" \. P! s3 t2 G# O4 c
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  $ h& j5 j+ B) M1 C$ g8 D
  ( q7 b  \( r5 p+ W3 N- B" D4 D
• 
  
  ( `( w' P0 Z0 k}  
  $ T- E- P9 u0 j
  
• 
  2 ^7 }+ y" v2 f
  /*标题输出函数*/  
    q# Y& X$ O' ~
  
• 
  / b, @* F6 p: [; q/ m" s3 R3 Z# O
  void prt1(char a)  
  
  
• 
  
  {  
  
  
• 
  : @4 T2 B0 D. Z& y, f& ]; J
     if(toupper(a)=='P') /*优先数法*/  
  1 G9 Q* T. I% e' |* q0 `, z* _
  
• 
  # W# ~! `, X7 d7 H; e
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  5 m, @  O5 d; S" m$ q+ i8 \: p2 ?
  
• 
  4 x# u2 V8 v7 m
  ) H* Q2 Q& i& H7 _! v! t4 W   else  
  
  $ Z" Z3 [* [7 A4 ]- N3 o4 L
• 
  , H# W6 V. l4 k3 X
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  + w- p( O  T; d5 L3 W, F) x/ |- b
• 
  
  / K- g* X9 K  l! @}  
  
  6 A# I7 B7 E/ x* I4 v: [$ L
• 
  - m3 @7 K4 z7 [3 ]
  3 @: F( V& N2 C- u, A/*进程PCB输出*/  
  
  
• 
  ( ?. b) ~3 s5 X+ M: K& w4 m
  7 a5 r( Z2 u' s& @4 ~% U* qvoid prt2(char a,PCB *q)  
  
  
• 
  
  {  
  4 h, ?" B+ |3 s, _  u2 D/ O
  
• 
  8 v, o, }1 _# R# G: O1 S, e/ B
     if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  . N- i% u/ x3 t0 b. f
  $ s, t, \6 @& b# U1 j1 s      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  ( h. N' y( u' ?0 i' Z6 k7 ~
  # u4 x* G9 Q8 O8 m! B( C
• 
  + i/ c  F6 z7 B/ b* Q3 x1 B
  ! j8 D6 @7 O2 b       q->cputime,q->needtime,q->prio,q->state);  
  * K8 U* Y4 P5 u+ J5 O7 Q# h( m5 M: L
  
• 
  $ `/ F- A: u: T
     else/*轮转法的输出*/  
  0 x" q/ `# l+ k5 C- I  j+ ^' a. c
  # D0 H5 b9 o8 \& h) E
• 
  
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  : ^( O7 ]; c) c8 F& H
         q->cputime,q->needtime,q->count,q->round,q->state);  
  
  # N1 }6 c5 c) [1 J) }0 m
• 
  ! [! F0 G0 S) Q& |" p# I. `: p( P
  }  
  ! _2 X) W$ Y. R& U' A/ j0 v; d
  - \4 O2 l; D+ c2 R
• 
  
  ' }% g  Q9 y8 H0 s: v/*输出函数*/  
  
  
• 
  
  void prt(char algo)  
  
  5 Z% t- z' m, w: M
• 
  - S: ~. B7 @7 I- a4 |' r1 ^
  {  
  # [/ @* \9 {7 X2 s1 b" j7 b9 I. _
  
• 
  0 r! T  f8 q) S# r7 L  Q- C
  & ]  j6 ~3 f' N4 w3 c) p( }( K   PCB *p;  
  
  
• 
  - q1 E' D$ @* Q7 d
  ; z" b4 ~& k; W* m   prt1(algo);  /*输出标题*/  
  1 D: k  C3 v! i  b6 J; `
  ' {; o/ H5 |% Z' b$ `, {# F
• 
  
  - K, `) ~, X9 T2 X3 J; |   if(run!=NULL) /*如果运行指针不空*/  
  ( e$ N0 L7 `. M, C& P" `9 Q
  ! K+ M" _  R. w; V+ h4 N2 S7 a
• 
  % u( P/ c  m% v3 l( G# Y
  " f: C) D% d0 T- a      prt2(algo,run); /*输出当前正在运行的PCB*/  
  * k* F1 c; i! M9 b% x
  
• 
  / z# J$ k  D; v$ b, \# A! }
  / P% `: Y: N( D   p=ready;  /*输出就绪队列PCB*/  
  ( e) z6 O2 G' n) t1 e
  3 }. u! ], a& L* R4 J" t3 U
• 
  
  0 W3 k4 Q- `! d2 I0 w/ L, c9 X   while(p!=NULL)  
  2 l$ Z+ {: W# q( [
  & c8 E6 \; ?: p0 t; s
• 
  8 M% R. ?( ]: U% F& k
  & g" ?8 w  B; Q. r   {  
  % t8 s4 f7 I4 f/ s. `
  2 D8 V+ ]9 o9 ~1 Z9 w+ |% ?" N+ }3 S2 ]
• 
  
        prt2(algo,p);  
  
  # k! T; r  k7 B3 p- x& u+ G
• 
  
        p=p->next;  
  
  6 @, g1 m, C' F
• 
  
     }  
  
  
• 
  ! I# v  J1 s' m) t' t0 c( e
     p=finish;  /*输出完成队列的PCB*/  
  0 F5 I7 x  \. i' o
  
• 
  $ Z0 x) e9 k$ M7 {$ F
     while(p!=NULL)  
  
  
• 
  
     {  
  8 n3 q# i4 _. ?5 G! h  r; w% p
  . v8 c7 @$ R! }. x- f
• 
  5 ?( Q( l6 b$ q: F
        prt2(algo,p);  
  
  ; z  e9 L! u: M- e0 M- u
• 
  
        p=p->next;  
  
  0 s7 q. G5 V" X$ \3 j7 G' _
• 
  
     }  
  
  ; u0 a, @0 @9 A# ~( S
• 
  
     getchar();  /*压任意键继续*/  
  
  
• 
  
    Y# z. g7 q! G* q, A" V}  
  2 Z2 q' J! Z: k* J0 o2 V$ T
  7 L. h3 T2 c/ X
• 
  $ ?. p% G: |& H  |1 q, l
  . i* t2 a& j/ y: @3 V( B9 }/*优先数的插入算法*/  
  9 i2 u: Y2 |$ ]3 U2 k
  ( K5 u1 \; e+ c$ o2 V5 g! K2 Y# f6 W
• 
  8 Y; {# o/ E# r+ L9 P- ^* |
  insert1(PCB *q)  
  : r& n( o1 S; K2 {( b, L  i
  , J$ F# B* H5 t4 H/ h/ B
• 
  ' @6 W' m$ b- v6 [0 n! I' {& P
  {  
  # P) s! l0 ?! F2 r- s, p0 ^
  2 p. A7 R9 [: G
• 
  
     PCB *p1,*s,*r;  
  8 w: j* f2 `, N& H/ l
  
• 
  
  ; J, W( Q: b- g7 `( J& {" L   int b;  
  3 T; h( L* |4 n5 @% q$ x. P
  
• 
  * {0 ?7 W" E" t, E3 x( }
     s=q;  /*待插入的PCB指针*/  
  ) r2 ~6 ]  A$ g( q5 l1 }7 V
  0 E* q/ P" Z4 X7 `0 e
• 
  
  " G# D" x  B  o2 T+ N  J+ D   p1=ready; /*就绪队列头指针*/  
  
    V- _4 _: R- A5 j. K! c
• 
  
  7 w, [) H) U3 D) b' ]   r=p1; /*r做p1的前驱指针*/  
  : A; o& n4 {, t  w4 E
  . E2 v1 o' x6 z7 b; Z
• 
  
  . i8 z6 j" Z4 q. b' ]4 K( ?   b=1;  
  
  
• 
  1 z" |1 ?& W5 p5 r# ~6 `* f
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  5 h2 t  a$ m8 c7 \
• 
  
  ) u4 @% x! p9 v" g8 Y      if(p1->prio>=s->prio)  
  " h" e( l9 [, `5 G* m5 [; r
  
• 
  # z( N! C( C7 p; R" D
        {  
  % ]% X: k' S% p8 x
  
• 
  
  ' Y# O8 V! X# ?% @: i; @+ b     r=p1;  
  , b- j+ A3 g# r+ K* G
  
• 
  
       p1=p1->next;  
  
  
• 
  3 g* ~3 q" u) l+ k" O9 y) _2 L
        }  
  
  
• 
  0 a- P7 w  p# c9 B, \
        else  
  / n6 n- t% I5 {7 Q
    O, e; k4 |& F6 t, n( U+ K
• 
  
  % b# D2 k4 w. D" O     b=0;  
  : N6 o3 S7 r' h6 S3 m" X/ U" _
  
• 
  & S( Q; F% L7 A/ p# u" U
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  8 p) s9 B& }3 @
  
• 
  # ~8 O* E4 h8 j% R" [% i3 @
     {  
  
  
• 
  
  7 r  ~2 @, P' K- I" c: j  ~- d      r->next=s;  
  5 a9 H) _/ C* [0 l5 a  n
  
• 
  
  1 W: G! ]3 X! `) [2 q6 b* S2 P      s->next=p1;  
  , r* \2 \+ O( v2 L8 E" Y
  ! \  ?- L$ f/ Q4 H9 _( O/ c
• 
  ' r! F+ Y. M  m( w2 |0 w
     }  
  
  $ r0 E3 B$ w' [6 k( B
• 
  
  # |5 I& E% m9 D   else  
  
  ( {' ]' A& j7 m8 m9 z% l
• 
  
  & |) I7 X4 I5 o& C8 f5 [   {  
  2 |. P% A( Q$ F6 F- [$ b" H
  ) `; m6 k9 y3 N( D* T, g
• 
  : c! I6 Y: J  m1 ^, g# ?$ e
        s->next=p1;  /*否则插入在就绪队列的头*/  
  7 r7 u5 _, v+ E8 n8 g5 H
  0 q8 }/ P; M& ~: B
• 
  * U4 z+ o' u, X4 h, l1 }$ S8 s; g
        ready=s;  
  + O0 o+ x9 V! d0 s
  $ i3 D3 |7 o9 |) g0 I* K, @+ k" r2 n
• 
  
     }  
  ( R( m- E( I4 T. x: Y& W" K9 ?, i4 [
  ( o. ]8 l( R& m9 \4 T6 c3 z
• 
  
  }  
  
    _& H8 S/ ^3 Z  A7 O/ a, M
• 
  
  /*优先数创建初始PCB信息*/  
  9 g  d2 Q5 N: ^! |
  3 n8 X! [# V! \+ j0 V2 w+ m
• 
  ; i( }0 I" h9 D' ~& \
  % _4 H3 r7 F# w( ~% u! b8 Nvoid create(char alg)  
  2 ~) |& ]. z: l
  , E6 H# f& b: N$ K
• 
  
  {  
  7 P- c7 x# v6 t+ F# V+ y( j9 K
  
• 
  5 p# K* q0 ?4 V9 b/ j
     PCB *p;  
  ' ?7 A( p* b1 b; v" p! k3 W
  * u  }% G! |; w
• 
  
     int i,time;  
  
  
• 
  5 j4 u6 n& u! d/ |
     char na[10];  
  
  
• 
    K. O  d, Y5 J: Y
     ready=NULL; /*就绪队列头指针*/  
  , b; G  `9 Z8 ~9 o4 P6 f( }, a& G
  1 h; ]2 m5 U; J9 \( E* T
• 
  * h0 H5 X8 r9 B
  1 `6 J0 r: f! C; v' S& B5 ^4 H9 `9 Z   finish=NULL;  /*完成队列头指针*/  
  0 ?8 g* v( J. Z7 S
  * d6 Q8 G- ]: [  E* Z6 ~! c
• 
  
  , C2 _7 ]- O6 o/ [5 C$ ^/ u   run=NULL; /*运行队列指针*/  
  % w# W$ a$ g( R# S' C( c
  
• 
  
  , t2 j' i# R6 {& U5 o& i   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  # r# q5 t3 z2 K4 H) j
  
• 
  
     for(i=1;i<=N;i++)  
  5 b+ w- l; ^+ S  C# w
  
• 
  5 N; N! F) ~- g/ H. l
  $ I8 A( O. A) I5 G, |   {  
  
  
• 
  5 o; F' O. t" i) k3 N" C
  6 @3 f6 u, v2 D2 _: Z4 c& O0 c      p=(PCB *)malloc(sizeof(PCB));  
  ; w! o3 s$ s7 R  F7 B
  
• 
  7 @8 l9 H" @# V
        scanf("%s",na);  
    O+ {3 ~. Y" v( H9 ~% k
  # G( J9 f3 O. ^
• 
  , T9 h  v) h* w
  . v7 Z* K4 v6 E8 Q5 ]8 m      scanf("%d",&time);  
  
  , F  \5 M! c, ~6 Q% a6 j& ], }
• 
  7 Z' Y% p& o0 ?. i! t2 J/ W' K# {
  4 e4 q6 Z% L; t6 u" i      strcpy(p->name,na);  
  ) n( m" v) S9 [# `. g, ?& n
  1 Y6 X" H' _# Q) F
• 
  
        p->cputime=0;  
  
  
• 
  3 \! p" i3 l! @4 m$ b
  & C. J% }1 [2 C: Q      p->needtime=time;  
  
  
• 
  1 I; _. {; Z- K1 L2 e1 O$ D
        p->state='w';  
  
  
• 
  
  3 ?$ n: K# B6 o- q4 E2 n. r& F      p->prio=50-time;  
  
  : F$ S# a# F9 N
• 
  
  7 w7 x2 J6 k2 w2 x% K. d& f2 _# j      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  # |" m9 a' c: ~: W6 _4 B6 t
  
• 
  - v: l/ H, Y, M% p
  + W# W# ~- |9 m1 v     insert1(p);  
  
  
• 
  7 ?: O* Z" c  W* F( t/ h9 z
  + ?+ q: m; _6 v  F6 \8 h      else  
  
  
• 
  . ?% ^; ^  @/ c, {8 v) [* w9 r& S
        {  
  
  + ?. {8 n- [) m, r) q0 t
• 
  6 F/ ^! `" |5 w. [. A  O
  0 [5 A: q  r( N" u9 e  _     p->next=ready; /*创建就绪队列的第一个PCB*/  
  ! R7 r/ ^+ s# J) C
  / e6 \7 e! O3 ~" V! M
• 
  4 p8 b! s  R4 |; ^  W' Q% x
       ready=p;  
  2 b- M6 n5 a5 l, ^
  - Y! Y% P# b7 l8 Z: \
• 
  5 R' z) R- j; K4 b; s9 B
        }  
  
  
• 
  . q  E) I5 X1 y2 r
  ( s3 `$ g8 P. f* P3 n   }  
  ; ?" x! t- D3 G; t( n" w
  
• 
  
  ; a# T# a0 h+ s   printf("          优先数算法输出信息:\n");  
  
  
• 
  + m& x9 b- R4 i6 I! Q) I" C
     printf("************************************************\n");  
  ' x" B. ^/ o$ V4 k6 Q+ Q
  
• 
  
     prt(alg);  /*输出进程PCB信息*/  
  & w0 D8 E# L, E. u
  
• 
  
  + H0 ~4 `! ?' h7 \) \& \   run=ready; /*将就绪队列的第一个进程投入运行*/  
  4 P$ I# N4 b$ H; \7 Q, o
  
• 
  . f3 i, e4 m3 P" [5 P" D' x1 c
  ( Q# [% w4 ]; {1 |5 u   ready=ready->next;  
  
  1 R; q, m4 I! y( P( _
• 
  6 d+ g6 h6 m* O: n: a
  ; ?; ?% b+ `. c0 c$ V% h1 Y+ c. e0 v   run->state='R';  
  4 B9 M. g+ q  P" F: Q
  
• 
  
  / u9 s9 ]. [9 Z% Q& ~0 N- u! h' j- R}  
  
  
• 
  / r' }3 ]" ^3 ]4 g3 G, q1 ^
  /*优先数调度算法*/  
  
  " l- G2 v: C* x
• 
  
  priority(char alg)  
  1 E$ t# w3 G/ @3 a
  5 w! h8 J/ P) q( k' b4 ?. B. U
• 
  
  / ~2 F* N: w' d) Z1 f% n( m4 @1 u{  
  $ Z+ y3 @- p% U+ p! I
  ! Q/ L1 y# i% s$ A' B1 Q. x0 O( q
• 
  
  , h' I  o5 {% K. J   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  - i2 ?( y$ C0 X; X1 d8 [
• 
  
  ; _% t7 S/ q2 z' J. W. y% I# P! z   {  
  
  % P+ N- e* Y% r6 w8 C: k8 a
• 
  
  ; S8 I: l( o$ E1 `      run->cputime=run->cputime+1;  
  , v5 ^9 p. [  o0 c$ f% r
  
• 
  2 i! B& A, J# Q& {$ D# Y$ z& D1 b1 H; F
        run->needtime=run->needtime-1;  
  
  
• 
  ( I( j8 A) B9 t- T
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  9 X* d0 D  i' ?
• 
  & A& i7 Q2 w# z
        PCB *p;
  - ^# |" S) z, W9 H5 C
  $ O. y# J2 u7 C$ N* I6 \# P2 j; G
• 
  
        p=ready;
  
    O- N: s5 `+ ~: Q9 c. x. O  T3 F
• 
  $ S0 m9 W# W" {; e1 X
  + a( ^2 r. l0 ~8 O4 I& q" d      while(p!=NULL)  
  
  : l3 |8 K$ p' B1 a
• 
  
        {  
  
  2 Z) j& T# b: i
• 
  
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  
• 
  7 ?6 m1 c' H5 K+ ]" W
  ; B" X. A7 N* g: E! B! L5 D7 _: q          p=p->next;  
  
  3 c1 g( g" o* O4 ?
• 
  * \. j- }9 X) F& `  f+ {- g: ^
        }  
  
  & ^( j5 y5 M; ]8 A# I* l
• 
  
  " z. f  j' s4 F# i* A0 u/ s      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  
• 
  ! ?/ i$ e! v5 O# [. n
  2 r9 I; A- G) k# \9 C      {  
  
    ?0 e2 e/ z. V
• 
  ! M- e7 j  B+ r+ U8 @% W7 K2 O1 U0 q. |
           run->next=finish;  
  
  7 v2 W. ^7 G/ v
• 
  
  3 K( v6 S0 |5 ?% ?0 e+ ^8 g         finish=run;  
  & u0 S4 v4 b7 E% f
  . m, }7 K# K# x6 D  Q) r: o
• 
  + o* `+ ~* `+ q! b) U1 I+ y
           run->state='F';  /*置状态为完成态*/  
  , U8 s; l( V4 \
  ( _% C% m/ N6 A0 d- t- u
• 
  . X4 E# q5 U/ d7 J6 f2 }$ i
  0 m$ J8 Q6 E( ~2 k         run=NULL;  /*运行队列头指针为空*/  
  
  * O7 l3 h4 O# A: {! V/ m
• 
    B: @6 Y5 n  ^* j. Q9 M" ^
  & X) C- V: _) }- e$ Q         if(ready!=NULL) /*如就绪队列不空*/
  
  5 Z9 G9 ~: O4 {- R% C, w1 z! R
• 
  0 b$ X6 b3 {  }0 u# [3 n
           {  
  
  
• 
  5 O& Z2 o2 a5 V: b
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  
• 
  & [% a# H  ^, k
  9 B; P% Z! T; A7 Z' I8 b* C         }
  ; \  e; p' T; k: |' q
  
• 
  
  3 g2 K! G! I$ {6 t8 g- G      }  
  
  6 t! B  [: k4 N& K* R( r4 N( u
• 
  
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  # ~6 q& i  _+ f+ M  O' b- o7 ~& g
  3 w, A0 K6 D: C1 i* `" t* J
• 
  6 u! k, J/ R6 [/ u) v4 s. @( v
  - r! ^; P& c4 N2 A3 u     if((ready!=NULL)&&(run->prio<ready->prio))  
  ' y! C/ m: a; [' d3 X, {
  
• 
  3 ^  G& e0 h, P! a! p9 y/ g
  / \. Y; ]& Q5 Z     {  
  
  0 z7 ~+ @$ N- R' c4 d% i
• 
  8 _1 T; @$ r. O8 o
  2 `+ z  t' g; b  Q) V9 W& y        run->state='W';  
  , @: i4 J- P1 F% b- V/ M
  7 s7 g3 L9 `# k( C/ a
• 
  4 W$ D8 i& J, _- k4 Q- F5 p% m# @& ^5 H
  * \/ f, `7 W% A- \' [2 d+ e        insert1(run);  
  $ G' h# J2 N  K" S9 [
  
• 
  
  7 `& x  g5 b, @+ s, c# [: y        firstin(); /*将就绪队列的第一个进程投入运行*/  
  
    J; z; n& v, H/ X
• 
  
       }  
  
  3 Z/ n' [- e) [# M2 l
• 
  
        prt(alg); /*输出进程PCB信息*/  
  # f2 ~2 ]  g; G. R/ H
  & e) \6 H! j+ M' \5 G, R
• 
  3 j; t7 p0 T) `1 [& Z8 ?
     }  
  
  8 }7 ?1 S8 F6 \: h# y' V: M1 a( N
• 
  
  7 _/ q& Z! {$ G( W& _}  
  
  $ g; `& l6 }- \
• 
  0 H3 f4 L) x: E8 J6 u; `! b
  ' c/ F! l  h; n. F$ m# m8 U$ [; n/*主函数*/  
  % r5 P' R1 N1 Q9 V3 E! r3 y: e
  # c; ?4 Q& e% l" Q8 Z8 U
• 
  
  main()  
  
  ! @- J& F# \8 A
• 
  
  {  
  
  
• 
  
     char algo;  /*算法标记*/  
  
  
• 
  9 w) `& ^8 C/ Y. I9 \
  $ h! {* S+ T: ~% _: t* _   printf("输入P确定算法：优先数算法\n");  
  
  
• 
  ; f, ?* A6 P, b7 e" P
  ' y3 t; \; X6 ?   scanf("%c",&algo); /*输入字符确定算法*/  
  " |2 H, Z2 J2 h! f
  
• 
  
     printf("输入进程数：\n");  
  
  
• 
  7 M1 f. Z6 G0 X# {
  ( z# L& i6 F5 r. s  H" }   scanf("%d",&N); /*输入进程数*/  
  2 @' K& \9 c! \
    S% c( v/ N" w8 e
• 
  2 l' ]& \% o. \: h6 ?) v* u6 F
  4 U- P$ R' d6 O/ a1 r2 @- Z   if(algo=='P'||algo=='p')  
  
  7 o& Q6 q: Z9 p$ c; N8 k* C4 j- N
• 
  
  / s5 U6 j# v6 {2 V; E   {  
  ) `  {* k3 ]: w! ?: Q
  
• 
  ( c6 J  M# S- G
        create(algo); /*优先数法*/  
  
  6 M7 _+ Q/ E6 j) Q9 O
• 
  
  3 o5 c- B% p5 n- ?9 ^! N      priority(algo);  
  
  
• 
  
  1 X# \6 n- [( H/ ]+ b   }
  1 N; Y. Y5 Z$ B4 Q9 Z0 z
  & d) e$ A( g. I4 [8 H
• 
  8 k( Q5 d9 E: g5 V% I& m
  & T" h! d: }1 }& [1 q}
  
  - D9 N0 w2 q& W3 x. r7 {
  

输出结果：

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

0 y0 n, U( I$ f! ~; h
5 z8 F! o- c( M! h2 Y: `