优先级调度算法

杨利霞

. Y* a; v7 W8 {7 O优先级调度算法
# c3 Q! x  ~9 u0 R. W2 i" o8 L! S1 f5 h

算法介绍
! ~) Z3 Z: q/ G0 D优先调度算法的类型（用于作业调度）
: s5 y+ V& j; ~6 p0 p$ ]1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
2 x/ Y) e- P8 Y& Z0 n; E只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
2 H0 K$ K* A1 t8 u: m4 O4 ?! U& d1）静态优先权
* }! N* R' x4 d静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权
; _  Z; p! n# @. Z: [

算法实现

抢占式动态优先权：

4 g. m- `$ O/ LPS：本人认为非抢占式静态优先权没有实际价值。

• 
  
  #include <stdio.h>
  0 X8 C6 d# w8 |3 `  C- u6 c
  : c+ N3 B: A. b3 Q
• 
  " C- Q. S2 l+ s) s; w3 y' x% L
  " {% Y4 K- a" e" _#include <stdlib.h>  
  
  
• 
  
  #include <string.h>  
  
  ' ?  ^. G9 W. `: w6 @( Y9 l$ H2 \
• 
  
  # Y2 k) c* v9 wtypedef struct node  
  6 o' C+ T( i1 B
  
• 
  
  6 Z( ^6 p6 f8 Z{  
  6 K- z$ x3 o3 f4 A
  
• 
  
  7 T/ V5 T3 w! Z6 }$ \! m: G   char name[10];  /*进程标识符*/  
  
  
• 
  ! {" ~" I& O" C( p8 }
  , q, g2 F" P! ^7 O2 H   int prio;   /*进程优先数*/  
  
  & ~3 ^/ D- H, j  F
• 
  0 w) u" E, _/ p8 o* a1 Y( T. [1 V
  + {' e7 U  N: d0 E   int round;  /*进程时间轮转时间片*/  
  
  % o4 `) C7 `2 t' O% C; j: ?) \
• 
  
     int cputime; /*进程占用CPU时间*/  
  9 I, E% \, I( d
  
• 
  
  3 _( ?9 B! E9 ^( Q3 M0 v   int needtime; /*进程到完成还要的时间*/  
  
  
• 
  
    J6 m( a. m3 s1 W- ]. {2 y   int count;  /*计数器*/  
  
  
• 
  
     char state; /*进程的状态*/  
  
  
• 
  ) x& p3 d) y& J" O
  7 g- v: E# p) Q8 }! [   struct node *next; /*链指针*/  
  
  7 A# D) I. _, a" \; k' X) {, L
• 
  : A/ `8 ]) M0 {5 o: g
  4 r4 v1 {! s! Z}PCB;  
  . a) T6 e! A0 o9 M& T3 L7 g$ _
  
• 
  
  9 d0 t& c; s7 D) a' W* qPCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  $ b7 G9 j( w/ ]8 R
• 
  
  % ~9 ^- M0 I3 A$ ^int N; /*进程数*/  
  0 f4 d5 M) k3 Z( s
  
• 
  
  /*将就绪队列中的第一个进程投入运行*/  
    R! d. f9 G2 c$ J4 m
    @" c% a; C  Z# E- H
• 
  6 }! W# v) A' b1 B& l3 V
  firstin()  
  3 t/ D  s' e3 D  s' B% a3 N
  
• 
  
  " ]/ N( x+ t  P: B& M{  
  - K: Z- y; O+ F2 i6 v( T& b& [
  
• 
  & v/ g. f6 n# u. G4 @2 p9 R$ j
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  ' J; M7 m+ }7 t6 w+ H% \) H
  " [: @# l' d- M
• 
  7 f* r4 c; A2 Y9 o
     run->state='R';   /*进程状态变为运行态*/  
  # g! N/ F% r5 k  Z
  
• 
  6 `3 d1 V$ {- ^+ q8 R6 c0 [5 ^
  6 C: l7 Y& n/ W& ^9 K   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  
• 
  
  }  
  
  ! M- c3 ^( e4 l- N  }% L
• 
  
  4 \9 Q9 H* m  ~9 r8 `0 s+ p/*标题输出函数*/  
  ( C0 m8 y8 d" [5 J
  % ]5 ~! R% ]2 o" I( U8 J8 g
• 
  
  void prt1(char a)  
  
  
• 
  7 D1 |$ E# P# l0 S- Y4 X
  {  
  
  
• 
  3 w* z2 n2 v' e- \: b- w- Y( D0 C: B
     if(toupper(a)=='P') /*优先数法*/  
  
  
• 
  ) I9 {( I+ V0 X5 |" A' Y6 q. H' z
  1 f6 _$ T' y4 i6 ^8 g! P" G      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  3 x6 c! C* M$ m3 Q8 W
  ' M) U4 a3 [1 l) m" b
• 
  : n3 t. ?; {+ ^1 r# `1 R
  - x, c* n* x3 t" [& }- ?   else  
  & @9 H0 ~  s/ p/ `! R" N1 L, _
  / b; k+ h& G. s+ `( I% f" Q4 ^  H5 o
• 
  
  , T- Q. I) D+ @) [4 _      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  
• 
  
  0 }- W$ j2 ?/ }: v, l: T# t+ H}  
  5 _& p0 @* ]' m, C4 k- M9 G
  
• 
  / o) S0 {% q1 V# X
  /*进程PCB输出*/  
  - n$ Q8 I& U2 _  v" }3 U
  , ^2 B) k- V5 k3 f0 u4 X/ y* c
• 
  
  void prt2(char a,PCB *q)  
  
  " y( K: [1 b" `6 Q" m) n
• 
  
  4 s% E; D: H3 A6 s1 n  u9 a- {{  
  9 h  l4 L5 Y- \! b) m1 [. k
  
• 
  " J" l1 D; ]; e- ?6 q. T1 ?
  0 i0 U0 `/ @( k  h2 r$ Q   if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
    W2 X9 y; N8 Z$ }7 ], V  t
    {  v7 X" s1 z* p9 o. J5 S      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  $ s. m; E# m# u- m+ A: B
  
• 
  3 W$ H' p/ W0 D3 b) b
         q->cputime,q->needtime,q->prio,q->state);  
  
  / J: H& U( o! M4 o- c% n
• 
  
  9 U" k' ]& Y# S5 i8 W9 J( c, p   else/*轮转法的输出*/  
  
  + c* A  U& l5 m; S2 L
• 
  
  8 d* Y/ C* Q) a8 n3 [      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  + G6 C5 [2 ?! u6 y- @
         q->cputime,q->needtime,q->count,q->round,q->state);  
  
  
• 
  
  }  
  5 ?8 |& `  W5 Y: G- ~* @5 D
  " ?' f( p0 M9 N# x
• 
  : k  r* _) _( H# ]3 }7 o, t
  /*输出函数*/  
  
  
• 
  8 r$ o! N9 ?# Q& }
  void prt(char algo)  
  
  / R7 q5 Y: E' H2 w: N! i. u, ^
• 
  4 z/ X! J) h6 X' N/ ]$ c, U
  {  
  
  ( S2 G6 i$ h: e# c5 y9 z  P: K4 j
• 
  
     PCB *p;  
  9 ]* O- Q; q' I7 |+ i* }
  6 f9 v! q2 Q- t5 c. ^/ B% e2 j
• 
  
  ! W8 O1 w  j2 s9 F# h4 }9 L   prt1(algo);  /*输出标题*/  
  . s. r$ K& F2 t( q% }7 |  H
  + z# N: @# k0 N, Q5 `
• 
  
  6 i2 o! A* G4 r/ F& d   if(run!=NULL) /*如果运行指针不空*/  
  " p, D) }* o2 S; _: N6 C5 h
  
• 
  
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  ; F( e3 t9 m3 S5 X8 [  H8 x- }
  
• 
  
  " M" T5 m( n) Q3 e   p=ready;  /*输出就绪队列PCB*/  
  , |% c5 {6 |, G* S$ e2 `
  
• 
  + a, ?) I1 D% t8 o# T2 T5 ^
  0 W8 L  x) c1 V% |. c   while(p!=NULL)  
  - f6 x" ?2 W* W5 F; K# _
  
• 
    {2 B% g; t7 E9 L& O. ?
  & \' |  ^$ {( H" L   {  
  
  * U4 y/ d" Y6 w; h* Y
• 
  ; W# |$ [. W7 B7 e1 X
        prt2(algo,p);  
  
  & _1 a1 L$ }: x0 d% u, G, C# @
• 
  
  # _" o3 V3 J6 D( M; s* T& V      p=p->next;  
  # h0 q% g* ^. x
  
• 
  
  ' w3 D4 N$ [* A  Y" [3 J* j   }  
  
  
• 
  9 g6 D) u) G  }: [. e5 R
  ' f4 M6 r$ R  o   p=finish;  /*输出完成队列的PCB*/  
  
  8 ?; D) o& I  \! U
• 
  
  * G  g# m* f5 b- u. E: x. p   while(p!=NULL)  
  8 L  d0 T: n9 s; I  M) T8 F
  
• 
  
     {  
  
  / T8 P& B3 v% d  }9 F
• 
  * w' Z+ q. @  w7 i5 z
        prt2(algo,p);  
  7 Q4 `8 U( k% K7 d( c
  0 z; ^' j1 A. `3 r3 X( [
• 
  & q( }% g; S4 v: J! m8 V
        p=p->next;  
  7 e. a$ Y3 t* ~  |. Y0 `
  
• 
  # P3 Y3 |9 W. S; I
  + m$ L/ k! C/ R( l% \   }  
  
  
• 
  
     getchar();  /*压任意键继续*/  
  3 O& j- f9 `+ C; u6 \: a
  
• 
  , S) V% ~; @$ ?. H
  }  
  , o$ y/ g+ I+ n& a4 u
  
• 
  
  ; K, J7 p( H+ O; l1 o6 B0 r5 w' E% D/*优先数的插入算法*/  
  : m% J/ J2 C6 ?. n' W/ u, j6 b! g
  9 E) X0 x" c! z2 p5 u5 w- N
• 
  
  / H' I/ s- t: `# q% q: N2 a. i) B( V+ tinsert1(PCB *q)  
  " R* y0 T& u( d* t$ v& v
  & ~! H. C/ _- D8 }* [9 }6 `
• 
  
  {  
  : A2 Y. P+ y- w' p. v9 `
  ' W4 @6 K6 }6 G
• 
  ( h, T4 n5 K: Z& B/ {
  % {! S  C; S! v5 \/ x. X& a* E   PCB *p1,*s,*r;  
  
  
• 
  
  ! A2 y8 `* X  q3 b, j1 O; v6 h   int b;  
  ) l) F: U0 t9 o( W; G5 N, g
  / A. _0 X8 r0 V
• 
  
  $ B, D  k- I: {( T1 d0 }   s=q;  /*待插入的PCB指针*/  
  1 e3 P! H3 N3 V# i, V+ U" u
  
• 
  
     p1=ready; /*就绪队列头指针*/  
  
  . i8 U6 O+ F: @! x( |/ C( B. L
• 
  9 b# B/ k' a. T3 o/ T
     r=p1; /*r做p1的前驱指针*/  
  , J0 \' B+ b+ y0 J) _- k( F
  
• 
  
     b=1;  
  
  % n9 W' y* N* n5 j) |) K% y
• 
  
  4 i. a* U; K" O1 a3 \   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  4 k, f; V- j4 a) [9 ~
  
• 
  
  4 ]) G0 j+ `6 p; H      if(p1->prio>=s->prio)  
  & {* a) k7 W4 N# N3 v) y7 n5 w
  
• 
  
  8 H3 @5 W) P# c      {  
  
  " _" ?, X/ c$ B1 ^" w6 A
• 
  
  / @  q7 F1 g/ h/ Q     r=p1;  
  - U4 p/ ~7 w# m0 d6 [& v9 a
  / q# q5 _& J/ b$ U4 N  k
• 
  
  7 e" ~' N# i8 b1 a! B  J, X     p1=p1->next;  
  1 s/ D. b  G4 `/ m
  + ^! ]" v  s4 I# g
• 
  & R4 d1 N+ I8 C9 @
  6 T$ X# T1 m$ _7 g5 \$ t, y* b  j      }  
  : q$ s$ c$ ^, ?. f9 t2 s1 A* m
  
• 
  
  ) K" b9 U2 R) E3 E& b7 L! j; L( d      else  
  $ ~; P, i1 x) J1 ^8 {5 _& ]
  2 J6 l' W% X$ Y% B  @
• 
  - M; E* m/ z- ?8 f  o
  ) x( U5 O/ q" z' P3 q     b=0;  
  
  , v7 e+ Z8 ~# ^# P
• 
  
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  
     {  
  ! H- C. D( g  v0 ~+ ^" {
  ; B$ `8 T1 z- F' m
• 
  
  : S5 c+ U9 u4 w! |5 U, r, g% ?      r->next=s;  
  
  & B1 I/ B9 c4 d* P# n$ i% e3 s8 Z
• 
  
  - \. o( u& G! p% [' P; `* ~      s->next=p1;  
  , i: W2 i# \& E+ ~  R* n/ j
  
• 
  
  ' Y% W" M% N7 S   }  
  , I) O% E' x9 ]) f4 c1 L" _% N
  
• 
  . {' h7 E; s7 Z
  / B/ j" }2 m4 y9 D" u* n1 r. ~   else  
  4 q$ \; x% B. ?- i$ ]
  * a- e  V! G- j$ J
• 
  5 c' k' q- r& p  ]; v
     {  
  . u* D& B" D8 h5 r  `" I5 {6 ~
  
• 
  
        s->next=p1;  /*否则插入在就绪队列的头*/  
  1 n. ?- E2 H. d
  
• 
  " D3 q5 y* z, I7 @# U  b8 P9 ^+ v
  * o/ s6 b$ ?0 r      ready=s;  
  % N* S& k5 \0 k: L* c5 w, L
  
• 
  ' t; {7 [3 F9 b9 s7 \( m$ o
     }  
  # o7 Q: r4 I  P
  
• 
  , f' S* l2 Z* p$ A  n/ t
  - B+ T; @1 i; S8 D+ w}  
  
  % D* X1 S+ G" o6 |/ c- }
• 
  ; _" C1 E, M' y7 n
  2 Q0 T$ W: z* n" M/*优先数创建初始PCB信息*/  
  
  $ {' M* S4 |! T7 j
• 
  
  0 p; O. _" m& L6 l3 jvoid create(char alg)  
  8 T2 w% o5 u; B- z6 K, T9 y' }- f
  
• 
  - g6 A. S2 m# O" K4 L# B8 Y
  {  
  # @( r6 E4 c, P3 h9 W1 b/ N
    U8 O% o5 y. V) v  d+ R
• 
  
  ) `0 w) D+ n% i   PCB *p;  
  % e& [; |$ f  E. ^& Z3 W9 ]
  ; p: S1 y. k6 x8 i( @  Y' H
• 
  ( M7 Z: f5 [. k, D; {2 P: f
     int i,time;  
  7 ~' P/ ~# Z/ X! N% A8 k& |( C
  4 F3 Y/ i# d$ h4 E+ t
• 
  
     char na[10];  
  
  7 C) N. Q2 ~. u: l
• 
  ' S2 g7 y& {- y' c9 j2 M5 B
  7 s5 j0 p6 H! d' W5 v! O1 i7 J   ready=NULL; /*就绪队列头指针*/  
  : I. U& C1 e8 G+ Y4 w
  8 P- l$ B/ P. O
• 
  
  $ p# Q2 g3 }  a8 s   finish=NULL;  /*完成队列头指针*/  
  3 s: E. y- `! y$ w2 }5 Y9 y
  # U% @' M& A1 Q. O; M
• 
  
  - _- s8 r' ?) `& `   run=NULL; /*运行队列指针*/  
  , `+ V. R* g+ }1 k' |
  $ V) @- m3 i# g! G; H$ [
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  
• 
  ' Q0 w: F4 L4 _! Y) e
  ! T: |+ K$ R" R3 B8 M   for(i=1;i<=N;i++)  
  
  2 ?, Y! I# M$ p& f* E
• 
  ) `! v& e5 a- Q8 ^$ {% P# t
    {( c4 q: C4 ]0 J& E1 N   {  
  
  
• 
  
        p=(PCB *)malloc(sizeof(PCB));  
  ' W0 N8 i2 t9 `' g8 M; i
  & r3 K' X9 g0 _  t0 g' _& @6 {, W  W1 r
• 
  
  0 H1 H7 F' h; L7 t. L& x      scanf("%s",na);  
  * S& N2 V* C" w- R1 i
  # |- |$ [- H! }
• 
  
  7 g* ?$ U$ I7 n. y! ?" [      scanf("%d",&time);  
  
  % R8 f; N" e5 F
• 
  
        strcpy(p->name,na);  
  : S% G& {( L6 q# S0 H5 e  `4 T
  1 h! t$ a' E% z% |. Z
• 
  $ R9 V$ ^, z2 _' o  q
        p->cputime=0;  
  
  
• 
  " [6 w3 r2 k1 z( B1 l
        p->needtime=time;  
  ! U7 J- J% t, _' D: Y5 y
  
• 
  
        p->state='w';  
  . b  a" t  Q8 ?+ F
  # M8 \. Z/ N! Q" e! I6 \
• 
  
  , z3 y0 j- u3 f1 u" a+ l2 _, m8 M      p->prio=50-time;  
  
  + B; u. {! K7 W, c6 M! {
• 
  : U$ h6 H! i7 {! g# ]9 N
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  / a/ @: }. K0 M$ |- h2 s
  . t8 B( ]9 G* t! z9 r' E( h, o
• 
  8 Y% O" i$ h7 q% g; X- V
  9 J0 h! z& {, Y     insert1(p);  
  , K$ X6 E2 O3 {6 u2 X" q
  
• 
  ( r! I" p# W$ e1 F$ ~
  - i$ @& ]! r( B, h& n* d: [      else  
  
  
• 
  % v( t% [3 f8 z2 F' k/ x7 n) O
  2 S) [* c) P2 Q$ K: G+ D0 V* ?      {  
  - ^! Y4 L! }8 F7 r
  ; a  H3 c, Z2 z
• 
  
  0 x" Y7 W+ `9 w0 F+ I     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  0 U5 t( `: U. H' ~' Y
• 
  8 T' \7 R- V9 p" j3 O6 L# E% H) C
       ready=p;  
  % m1 S8 x3 I8 N+ i% g" n" {; ?) D! A1 p
  ; |( y8 `5 {* K/ ]9 t6 ?; T
• 
  7 ~4 `4 o, _4 b; R5 z3 R
  6 L1 T7 K) d# ?5 J      }  
  / S* p+ h5 x# s3 X. k
  
• 
  
     }  
  , `+ v8 l6 B5 ~
  
• 
  9 I2 t* {. ?8 L$ @
  : [# p$ J* D4 f   printf("          优先数算法输出信息:\n");  
  : y  Q* I/ j8 r
  2 U6 ?8 I) A$ c; U0 }0 |
• 
  - G/ t* a7 ]  C8 b0 U* D7 l& n* u/ {
  3 z- ^" B, E: E   printf("************************************************\n");  
  
  ; w- c9 E; K% T  [7 X& `
• 
  " e+ }# W+ T, F6 V6 v6 W9 |% e8 z
  1 A$ m' g6 {. v3 p: ]   prt(alg);  /*输出进程PCB信息*/  
  : H* \! R+ g) q0 N" ]2 R
  : O' N7 k9 Q# B. F& h' @
• 
  3 o: `$ b7 P# N4 t# i" ^
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  ; y6 l( J0 o9 y9 f. E" L0 `
     ready=ready->next;  
  : Q0 [9 W# h) v5 w+ ?9 e2 G" b5 r
  & Y) q; ^! Z1 J4 b) H$ I
• 
  
  : Z. U1 x$ S+ ~; k   run->state='R';  
  
  / F  s8 e7 o0 P! u4 X( A
• 
  , e! \; O4 x2 t0 P8 `( S
  }  
  
  
• 
  8 p  e. [3 d0 n$ [! b" `
  /*优先数调度算法*/  
  
  
• 
  
  * L0 o- f9 g7 O4 q2 N7 |priority(char alg)  
  ) h: E. r6 ~1 u; _# B& t6 O
  & {+ X5 N  S+ U$ ]5 S
• 
  
  {  
  
  3 Z5 L0 M. z* b9 s# G* M
• 
  
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  % R  X6 C% S/ x0 D) `, o3 j6 h
• 
  ) Z. ?2 S8 \" B% J6 F8 I
     {  
  8 \5 x+ U( s. q' s; g0 k# y
  + ]; ~5 s9 H! _5 S0 X: ~
• 
  6 p9 W% r+ E; l
  + W( K, K0 ^% r  I/ `2 t      run->cputime=run->cputime+1;  
  
  " A  |2 d% P; s0 p& }. D8 Q
• 
  
        run->needtime=run->needtime-1;  
  
  # _6 I  H$ v( e
• 
  $ h/ \0 e; O! g$ F  K% `: m+ e' A
  8 I4 ^" A7 D) d: Q( B      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  1 ~" k( ~& |) U( X& b# C! y
• 
    C6 e* S% O8 @" `) a9 E
  & q+ m2 Q! \( D9 [      PCB *p;
  
  
• 
  
  3 f) M9 V8 Q$ {      p=ready;
  
  
• 
  
        while(p!=NULL)  
    ]9 x7 I* ~/ u0 j7 n5 b" i6 f+ u) T
  . O; k$ j+ ~9 u9 r, M* \- f
• 
  * A3 P6 y- Z$ h% l* V5 y
  # g/ ]/ o- F, Z/ Q* Z7 ~7 h# k      {  
  6 Q5 j' L4 V5 v8 F
  # v- H$ C# R) b8 h2 A" _; A
• 
  
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
    o/ [, R9 y) Q7 {
• 
  $ A- T# u) G5 l( B' Z# g: K; F# A2 {& X
  / c& x: D, ?  \& T9 v/ V, O          p=p->next;  
  9 n! h9 L* C  L& S. D
  3 o) d5 g7 Q: P: u+ \( c  k
• 
  7 H. q7 Z) b6 {9 H
        }  
  8 U0 {' p* h% g
  : t( ^7 F( I5 Q/ f
• 
  9 C# e& K/ Q# b! L% B! s6 d
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  ; z, l' G' t6 T/ g6 C$ a
  
• 
  6 J8 }4 d/ M7 ~
  $ _% S% X- C3 W1 C      {  
  ) l4 P3 i7 ~1 F$ B' U7 E
  + ?. ]0 V1 l6 u8 f& ~! U
• 
    n. q7 @# P' D( E
  - D1 i- i( a+ S6 T- `         run->next=finish;  
  
  
• 
  
  8 n- |, G) R" j& U6 N& H+ C, X         finish=run;  
    _2 k6 p# N2 Q, D6 Y4 R/ J
  
• 
  * N1 E% N" x8 O5 q$ b2 P* i; t  b
  * K5 G0 z  D3 ?) Z* v% V         run->state='F';  /*置状态为完成态*/  
  " D! |, ^5 `( W, }; B/ {' Q( R
  
• 
  " n7 B3 J+ L. v: ^8 w' ~1 n
           run=NULL;  /*运行队列头指针为空*/  
  8 G- |9 m# H6 s  z4 T! L* `' E1 ?
  3 i; H: G: m5 `
• 
  : e* z$ i; F+ o
  2 y4 N, W7 e" b4 I8 }         if(ready!=NULL) /*如就绪队列不空*/
  
  
• 
  * M$ ]0 u+ u3 z3 L$ n
           {  
  $ i% x; y5 j7 @+ M1 B- M
  0 |- p6 s$ f) g# W9 s: }$ j
• 
  . _$ j9 ]* @" ?" G
  + D5 Q( B7 h0 A            firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  / z5 ?. ]9 t: G; B
• 
  * B( \0 `9 V4 N& c% N
  ) S/ J1 z1 _4 K         }
  8 U3 V7 y" p, M+ N; \5 B0 B
  % V6 w% t% C. S7 ~# [. g2 s/ h
• 
  9 \* x  a0 [' A" v6 L
        }  
  
  & j2 f, ?; [9 X& a8 M4 e/ u; [
• 
  % b) t+ Y. G& k1 c
  ! c- u& P$ E3 m      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  & g/ T; U, |* [# X% z  a
  
• 
  4 I1 g$ \/ z* ?0 l. l& {- @  u. M  z
       if((ready!=NULL)&&(run->prio<ready->prio))  
  
  
• 
  
       {  
  : r: }3 y, x& Z1 _, K
  
• 
  
          run->state='W';  
  + \5 H7 l( O; T/ E
  0 i% m0 y/ X1 b8 d2 q
• 
  7 O$ X" B" z! z
          insert1(run);  
  
  
• 
  
  ) s& T0 W2 I+ f$ U( X: R        firstin(); /*将就绪队列的第一个进程投入运行*/  
  3 W4 ~, H1 D. g) b8 v- M5 f
  - z' w# s$ K7 g, a! {% @9 F
• 
  ; Y; a3 ^* Y! z0 |( _7 B* L, ~8 a: F
  # T+ C! k, Z0 n! b     }  
  
  6 u' }& T0 v& q; ?: K$ q! y! T
• 
  
  6 j# H- g4 `. u' x: G$ r; G      prt(alg); /*输出进程PCB信息*/  
  
  
• 
  
  ) z- N, V. J- m0 b   }  
  
  
• 
  ) W4 Q" |$ Y- F1 Q
  }  
  
  
• 
  # v( p* q4 W9 b; t1 e
  /*主函数*/  
  
  
• 
  
  main()  
  5 [0 g6 f* g+ I: i# h8 z
  
• 
  , z4 T4 Z% J% r
  {  
  * ^9 ]( i& `7 u; X$ y4 P0 l
  
• 
  
     char algo;  /*算法标记*/  
  
  
• 
  
  ) l  l( i0 K( W* e$ m' P   printf("输入P确定算法：优先数算法\n");  
  
  
• 
  
  / h4 }) s/ q1 s* r8 i' \6 C   scanf("%c",&algo); /*输入字符确定算法*/  
  
  
• 
  
     printf("输入进程数：\n");  
    k) G6 f2 v4 L1 h
  
• 
  / X3 J6 t8 y2 o9 A$ `4 {$ M
  : Z: U! i) m  q- O% T  J+ D* j   scanf("%d",&N); /*输入进程数*/  
  
  
• 
  
     if(algo=='P'||algo=='p')  
  
  # [$ ]6 I, z9 O% L' C9 l
• 
  8 m& d$ f+ M, x. V& K# |% f" Y
     {  
  
  ' F: f7 R: V( y; M, a  ~2 \
• 
  
  " l7 Z& |& V( L- m. k; a      create(algo); /*优先数法*/  
  6 [) c- z, k' \3 E' x! }  R
  : b/ S0 B* E. r+ R) ]2 o3 v% v1 C
• 
  ' ~' L5 M1 u$ }: O# s
    Y0 [8 O# ~. @; U2 `/ d      priority(algo);  
  * b7 i  r9 _9 T' a1 C! R+ ]
  
• 
  : r+ t: z3 X9 O9 G" Z# n2 [! p* l3 U
  5 X# N1 M, Z5 {+ L1 d   }
  . E- B( I& O+ C1 U* v
  
• 
  
  }
  
  1 b. \3 W- |; s0 {
  % d; x7 F" T0 w9 |+ O% W6 x: W: D; O

输出结果：
0 q$ _4 T" v! r% p

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