优先级调度算法

杨利霞

# z" h. r$ _3 @/ m0 _0 R4 R! v: @! Y优先级调度算法
7 P/ P/ d. `8 _- b+ z

算法介绍
优先调度算法的类型（用于作业调度）
+ K  n- f) }) z1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权

算法实现

抢占式动态优先权：

. f" v+ R7 g) r- C! E8 O/ o5 cPS：本人认为非抢占式静态优先权没有实际价值。

• 
  
  #include <stdio.h>
  
  / r' v/ r$ d2 d
• 
  
  #include <stdlib.h>  
  / m' I, W& R+ S) K0 w
  
• 
  ) Z+ ?" o& @! h+ v, H' S: Z
  #include <string.h>  
  
  
• 
  
  typedef struct node  
  
  , e- V) u! |9 x' n5 ~$ n
• 
  
  ) c  E8 G' s# w5 _0 n1 k{  
  6 f( G! L5 r" {& f- h4 K
  
• 
  
  2 u, o8 V7 Z5 u" B- }8 i8 X   char name[10];  /*进程标识符*/  
  
  
• 
  
     int prio;   /*进程优先数*/  
  " i- p5 r9 ]& K1 R1 Z, f
    C/ ^2 X0 Z% |* S
• 
  8 ?# g& y: k1 i; o5 g
     int round;  /*进程时间轮转时间片*/  
  " p; N# k  P/ Q5 M6 n
  
• 
  * {' @3 z) l9 y- r+ A
     int cputime; /*进程占用CPU时间*/  
  + Q; s+ a/ w  r2 J
  5 {5 L) o1 ]- N4 z
• 
  5 x+ d6 g0 j) T: _. [9 A+ R1 x
  * c4 S% i) ?! C- x) I  L   int needtime; /*进程到完成还要的时间*/  
  # K# K: P; n  H1 P) L/ n0 p
  
• 
  
  ' i9 g, f6 |8 d   int count;  /*计数器*/  
  ; u. L6 X, \; {0 w% ^: r! b
  
• 
  
     char state; /*进程的状态*/  
  ! d7 e& x! p2 J& k, O$ c6 t$ G
  , m4 M9 r4 K0 j. S# c9 E
• 
  ! O/ J5 X9 R  R$ v
  ; n2 e! v+ L7 o* S: _1 Q2 V   struct node *next; /*链指针*/  
  7 y, z5 v. C1 q& \( C3 O  d
  
• 
  
  9 a8 G9 C( _+ [3 O9 S! }, y}PCB;  
  ) Q% d3 F3 w& I6 K5 u
  ( s. M& A8 d& r8 l( p+ H$ G
• 
  1 @4 H6 D7 Z- [' ]* r4 X( `
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  4 F: s0 M' q/ y5 B8 S
• 
  . {- E' b8 S, b) q# c% f
  int N; /*进程数*/  
    d( u( ]/ ~4 V& _# F' q
  6 a% d  d- X2 _
• 
  
  7 _+ d! t, A# O2 R2 H5 ~/*将就绪队列中的第一个进程投入运行*/  
  4 L4 N( Y1 \$ f
  , l; Q1 Z3 B3 J+ S
• 
  
  firstin()  
  
  
• 
  ) ?+ ]# Q3 C' b3 e! [6 f9 r
  . @/ @: z3 N$ K{  
  9 `9 a8 G4 q* Y7 |' f: c& Z' [
  1 Q' k9 j& |  M! F" C* U' x" h
• 
  
  2 ~) Q$ O3 Z, `3 S   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  - M8 e' K+ D0 e* a) C
  
• 
  
  - `6 n$ K, X, o, T0 p- M   run->state='R';   /*进程状态变为运行态*/  
  8 y  y. Z# D2 D* I) R  m8 n
  
• 
  ( F* e2 l7 Y  i+ ?
  - R2 u3 G: J% c( }6 Z   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  
• 
  / u! ]  ]! c- q& y6 W
  $ [  T+ [7 T, ]) E6 {}  
  6 m: h3 N8 [1 P. n4 E
  
• 
  5 e) ]3 g/ \) A! k2 m( _
  7 M8 x6 n( y# m: J7 {/*标题输出函数*/  
  
  
• 
  $ r* P( f# F; ^. z: `
  void prt1(char a)  
  1 B, O; c7 F8 Y1 ^5 I& p+ p
  
• 
  
  {  
  
  
• 
  ) M/ H/ n8 o5 h
     if(toupper(a)=='P') /*优先数法*/  
  
  
• 
  , f* G9 [1 I4 E$ J% D& p9 e- x: P
  * ]1 v. S! \+ c; b5 d      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  ) L8 d& T; j& ?, ]1 A6 _  J$ ]
  
• 
  / u7 J, A4 x% _% ^# ^, K. a5 C: E
  * }- E$ ?$ n! S3 ]* ?8 n   else  
  ( z/ X0 g5 L/ a5 [1 ]
  
• 
  
  0 y8 n6 o" a) J4 ?- z2 _      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  2 {) G. j  f+ Y7 @+ h
  
• 
  3 N: d: M0 w- o, Z; c: m
  }  
  
  
• 
  , g- }. ]: Y* f8 l
  /*进程PCB输出*/  
  
  
• 
  " Y& U* D5 M) N, C0 S
  void prt2(char a,PCB *q)  
  8 V/ D( }$ z' v+ R1 J% n: U
  
• 
  * X6 T6 z$ Q- M0 x: H
  7 u1 y4 I( \0 G9 Z4 R{  
  3 a2 o/ Z2 C( O* H; V2 M
  1 G. ?9 r8 H% M* n! |. a5 M
• 
  . c" ^3 z* Q. m. r
     if(toupper(a)=='P')  /*优先数法的输出*/  
  
  ! H# F( p$ @- k* O2 R5 w  C5 o; O# ?0 _
• 
  ) P' q" g/ ]8 _* j9 M/ o4 f
  7 i/ W2 f' r, m6 O      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  ) F3 [8 A' r& T
• 
  : u9 {4 v) y0 s% ?
  9 a( `! g  d7 n& {! J       q->cputime,q->needtime,q->prio,q->state);  
  
  
• 
  
  ' c8 x/ T+ t; W9 n! w- e   else/*轮转法的输出*/  
  5 B$ N7 X+ ~# Q2 ]4 E! f
  
• 
  6 Y) B( T. ^! ]8 g4 t/ Q- y
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  0 v1 w' F8 e$ \9 ?" s; _
• 
  
  3 I7 U& P% s) G       q->cputime,q->needtime,q->count,q->round,q->state);  
    c' v/ n% Q, n2 P# I
  3 f( g3 q1 {% W. @3 A
• 
  
  }  
  ! {3 E1 p+ [) K# c
  
• 
  
  /*输出函数*/  
  
  
• 
  1 C+ j* ]+ t% \; O
  " n: U/ i0 {1 m& Q7 P3 x0 \+ Nvoid prt(char algo)  
  ( n$ r7 u. ]5 U* f
  
• 
    v, g; y" O0 U* O
  {  
  
  : j' W2 `! {  @& g8 f/ ]# }
• 
  ' v' Q+ t" _9 D; J# s: G$ H% q
  2 y  \' `( b, m- [# i# U$ ]  J   PCB *p;  
  ( r/ r7 i. D3 [) C- f$ s8 d! ~0 {6 a
  
• 
  
     prt1(algo);  /*输出标题*/  
  
  
• 
  # z4 I4 r% ~4 c7 D& n3 k
     if(run!=NULL) /*如果运行指针不空*/  
  6 H1 l/ y7 ?* V# K3 L; u
  
• 
  
  $ z: |: i5 G- G$ n  I6 K      prt2(algo,run); /*输出当前正在运行的PCB*/  
  3 N6 z& f9 t# e+ h5 n
  
• 
  ) g4 s& K8 S3 C+ c4 K8 g: P2 n3 z
  4 m  M7 g. r: z7 `" U2 \: u8 ^   p=ready;  /*输出就绪队列PCB*/  
  / ?( J% N. {& q# B5 ^
  
• 
  
  3 Z  a7 n3 C) R, T3 @( Z  S   while(p!=NULL)  
  & N- ~% L. k7 U
  
• 
  / \6 b- ?! x: V% w' N) t
  # ]$ Z' J4 X7 R   {  
  * `) T: J8 |" l8 S* B4 d
  
• 
  
        prt2(algo,p);  
  ; m$ T9 P3 o. E& `' p# L
  2 X; G% }" j3 {; G0 c! p0 d
• 
  % M& j+ b8 E4 U8 |
        p=p->next;  
  # o* A. [8 K/ W9 W1 A- g  q  L4 I
  
• 
  
     }  
  8 c# Z4 {/ X! D2 w: z
  
• 
  0 e; u7 B. _: w% H- _
     p=finish;  /*输出完成队列的PCB*/  
  : q  r* k. Y& {$ f! m
  
• 
  ( Q# \7 `) @! ~6 e& W' h# e
  2 K1 @1 [( z) |8 w0 i" j   while(p!=NULL)  
  ! t. u- U& O* I' |* v- J
  8 l0 S1 A- \3 h* t$ j
• 
  
     {  
  . I0 V1 a1 o8 h/ A4 X5 l. X( `) W
  & y( k& w1 ]! D- `- g' T1 b
• 
  $ g+ }& J, P2 Z4 y+ E2 Q5 T
        prt2(algo,p);  
  
  
• 
  ; g1 ]8 h& `% d" p! g, S9 D# w4 C
  : `7 e) j; k$ q( }( H/ M4 P      p=p->next;  
  
  / U1 d2 q! L# P* \6 Q
• 
  
     }  
  5 j% A7 T. x5 {$ V1 k. ~
  
• 
  6 Z( X) K" m- z' r! L
  : {" i& i3 D2 D' p! ~   getchar();  /*压任意键继续*/  
  % g& L! P9 Q4 R; O
  $ x! S& v# K$ B# X9 J2 V' ^- |, a
• 
  . _2 |# T" g5 A  o; B
  ! `; L5 g0 p3 P. r) f. j}  
  
  , G8 Z" D; _+ m0 M6 o
• 
  5 k3 x+ U" ^5 A* l5 m
  /*优先数的插入算法*/  
  9 b7 L4 O& A9 |7 d
  1 h/ ^7 w9 F* N
• 
  
  7 f: j; Z! K0 U3 z' H- ?; rinsert1(PCB *q)  
  9 f0 l5 f" `; {6 @3 b4 e' V
  
• 
  
  {  
  
  
• 
  
     PCB *p1,*s,*r;  
  # |4 L) t' P# f5 C# {* {
  4 a) B2 V! o5 {" G
• 
  
     int b;  
  
  4 a/ H( ?% I% @5 C
• 
  
    U6 |5 g6 d. p7 a8 H: F5 ?   s=q;  /*待插入的PCB指针*/  
  
  % `) T- Z% w* |$ h1 N' x) S/ l
• 
  & u& a0 b& `. Z6 `
     p1=ready; /*就绪队列头指针*/  
  2 Y' C# v$ _$ F0 o# Y! h
  4 b/ u5 C: X3 l$ \5 Z
• 
  0 O0 J' W9 j2 D, c0 S& W
     r=p1; /*r做p1的前驱指针*/  
  
  6 B: ^( t; q4 L2 P0 n
• 
  6 t- {+ O* |! _. `3 U6 ^8 ]3 o" @
     b=1;  
  $ s5 I0 R. h5 \7 ~2 W
  ! L8 A% q; w6 h* g! I
• 
  
  & |; m; C' ^  j   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  " d; E  A: S9 I( w& \0 ^, D
  - h% ?4 W% \* p$ K* F. \
• 
  # V7 W& J1 j9 z
        if(p1->prio>=s->prio)  
  
  
• 
  ( G3 b0 F& z6 m9 @" D8 ?
  4 Y0 f$ k0 l. L8 T4 s2 Z      {  
  
  
• 
  $ T+ y8 [% d  A
  , `% N& G$ ^( S7 c+ U- A+ n5 W' i     r=p1;  
  2 o! B- d7 G/ J* n( h7 ~) ?
  
• 
  
       p1=p1->next;  
  
  
• 
  ( L) ^% g! u2 ]
  ; u7 A% Q/ I# U: e5 [      }  
  
  ! B7 i# e( Y/ S2 V! L4 j
• 
  5 E3 }! S+ N0 k- _+ Q
        else  
  ( v+ ^+ t. r' V6 `$ Y8 a( d5 S
  + J1 ]# w9 @. V% x4 ]. H
• 
  
       b=0;  
  " `/ q9 `% J" W" I- e- Y$ ?, b
  
• 
  % z' g, i1 r/ }$ _! ?- q
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  7 c: L* n& J% t- f4 J; v
• 
  
  ' t+ l) T- W9 K. F   {  
  
  ; \- r+ j. T  D3 p5 @
• 
  9 X% S( Y0 _4 p. C6 I
  7 h7 O; `" N9 N      r->next=s;  
  
  , U" M+ s( i* i0 i
• 
  
        s->next=p1;  
  * F/ R! ]9 n5 q
  
• 
  & D- I0 F6 B: w2 L
  ! [0 T( R$ p! Z+ o' y   }  
  0 b* L0 Y  C6 r8 u$ y
  7 U  r" q6 P3 B3 |9 ~
• 
  1 s- @7 v' x; l& K- k
     else  
  
  
• 
  5 ]# G" M* r4 [0 U
     {  
  3 e7 l; c3 y' o* W( `
  
• 
  ! y9 E9 H, l: Z4 C: j, f
        s->next=p1;  /*否则插入在就绪队列的头*/  
  " d# o0 e$ |+ E  ^( A$ H
  
• 
  , v3 W0 x! s- S
        ready=s;  
  1 \; M2 Z; m2 @6 I
  ! {: \  [& o6 y4 [  ~
• 
  ; a/ Q$ U  B; T
  # a  d3 O% n4 w   }  
  3 @6 |5 S  @  P+ s: G
  . W, j7 b6 x% R6 A4 k$ |
• 
  . O: }5 e: ?; e, ^
  % Q, ?' e. n! ]$ }+ ?6 ]}  
  ' x6 v' l# S* q8 Y- I
  
• 
  
  /*优先数创建初始PCB信息*/  
  $ G, k* t2 [& R' w* k
  1 N% D2 N6 a( t2 B% \
• 
  ! H) R$ i* q& o8 o  O! R$ B
  void create(char alg)  
  
  % D  X5 M9 W2 C. B
• 
  
  {  
  9 d. o& k; U8 W, O% x3 t
  " X% p8 T; G( d
• 
  
  5 A6 m: O2 u4 ?4 Q9 Q   PCB *p;  
  5 z+ `( L& T7 b
  . }% a9 Z3 l2 n" f8 f9 i' K
• 
  
     int i,time;  
  : m# X3 O8 d9 b
  $ \: N' o/ J/ |$ z, }
• 
  
     char na[10];  
  , U2 O6 e8 U1 z; G+ u7 W6 q
  
• 
  + e2 F$ ~1 h, v# |
  ; s2 Z. H* J" d' G" [8 |# U3 o   ready=NULL; /*就绪队列头指针*/  
  . y, u% c$ ]5 {+ @3 N0 f- A3 _
  
• 
  
  $ N  X, u: j% e( x- X" ^   finish=NULL;  /*完成队列头指针*/  
  
  ( R( m; c1 P- W7 u1 c
• 
  
  , `3 x/ D* ]$ W# r( ]   run=NULL; /*运行队列指针*/  
  
  
• 
  4 v5 A+ u$ S- O5 J1 Z" Y
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  ; J3 J9 q# l" e  `
  2 a% V( L7 a5 s5 Q
• 
  . @, S8 D$ i3 ?' H2 Y4 g, H
  7 h2 R0 y) B) W9 q5 {3 G8 q   for(i=1;i<=N;i++)  
  - \( D' V7 e* V" q2 E
  6 I/ M' Z$ b) c  p+ R2 o
• 
  
     {  
  # k- F3 a; X  j; }9 q5 p; N, d
  
• 
  & C* B* d/ O; X, S" U
        p=(PCB *)malloc(sizeof(PCB));  
  
  
• 
  4 `5 m. m6 W( X: ^
        scanf("%s",na);  
  . M5 E: N( _8 l9 C. F1 }
  
• 
  
        scanf("%d",&time);  
  
  # n. r) C9 j+ e+ E4 ]& n2 c3 B  H/ R
• 
  2 F0 d0 ~- R3 A8 O
  2 z6 B8 J/ L) v* G      strcpy(p->name,na);  
  
  
• 
  
  7 l3 Q4 x/ U6 g& z: N      p->cputime=0;  
  2 ^9 Y& m3 E: i' X, m" k
  # A+ q# T7 \+ E5 ~- z7 z" Q) R4 C7 ?2 S
• 
  
        p->needtime=time;  
  & j5 F4 Z3 j+ B. U8 }
  6 K# T2 C" j8 ~+ ~5 }1 K' |& m3 O
• 
  " i9 b! j7 v  e9 C" I6 {
  6 v* N, ~, G" ]      p->state='w';  
  * N8 {8 a3 F4 y; s8 G; n
  $ s" u' `; R9 ^' Z# i! L
• 
  
        p->prio=50-time;  
  
  
• 
  , p1 w4 r' C" ]  s7 w
  1 J9 w& _! p, S" S; ?      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  , f9 l( ~0 N$ J6 k
  
• 
  6 E3 \* c8 C# k, P; l0 `
       insert1(p);  
  ' U1 Z9 p$ ]6 u/ ~* N5 T
  
• 
  7 C4 w5 [' _& T
        else  
  ( `2 K# I; Q- W6 L1 n1 I
  , Y+ \4 p( v; P8 F) X
• 
  
        {  
  8 ?9 ~+ l8 y5 _5 b) {8 s
  
• 
  ! e/ Z. M3 J- x1 d
  5 K% D3 S9 ]6 U' J" @8 N% C     p->next=ready; /*创建就绪队列的第一个PCB*/  
    h7 }2 g& x7 h+ m
  
• 
  
  8 z) V' R. D" m% K# f     ready=p;  
  # D6 B7 E) T0 M' [
  
• 
  $ R2 }" ^* W+ c' \" C! \
        }  
  
  . H1 G. k6 H# w* A
• 
  
  8 O% o7 `8 Z$ k* \! V   }  
  
  1 f+ O6 k$ c3 C/ q/ x
• 
  : f8 `2 J2 p( {* `7 A) `- b9 Z# P+ U- g
  . ~' U* v& m/ i+ F* b3 u) s   printf("          优先数算法输出信息:\n");  
  
  9 a4 a) J% o* W( s  l
• 
  % b+ O+ K0 W6 _" N- ~1 k
     printf("************************************************\n");  
  
  
• 
  
     prt(alg);  /*输出进程PCB信息*/  
  & y8 x5 r+ ]6 ~3 `7 S- S6 I' u1 w
  3 ^. z% {7 c* R( y# k
• 
  
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  % ?3 ?7 h1 _5 n
• 
  9 Z+ h- b! A( s) N9 t+ D
     ready=ready->next;  
  
  2 a  C. o1 d4 e: D+ G; N
• 
  5 O# i& |' j; q* }
     run->state='R';  
  ! O+ `& a, r( X, w/ I( u
  0 I% b: a) e7 C
• 
  
  }  
  5 Y; W; Z' h5 v4 }
  
• 
  
  + h6 W! P/ ^9 M3 Y/*优先数调度算法*/  
  
  
• 
  . u: T' O+ z4 m  ^: G5 [
  priority(char alg)  
  
  
• 
  
  {  
  ' K/ r1 l8 K- a- \
  
• 
  
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  ) l# r$ u+ `: Z3 i6 C9 o6 \/ y2 V
  
• 
  6 [$ Y( R- L1 Q+ E2 J
     {  
  % x! E! P" {  H; ?- m) F, h
  5 d1 `5 E" Y- n" g! Q2 Z
• 
  . U" q# n5 h4 _4 L9 I/ V4 K
    Z) V& M; H6 b4 W* X      run->cputime=run->cputime+1;  
  
  
• 
  $ g0 }" |3 {% \& V5 y8 K$ B- f
        run->needtime=run->needtime-1;  
  
  
• 
  ! t  A2 q8 M; ]2 Z' u7 o
  $ A' ]8 n1 ~3 q" u      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  3 K9 I: F' Z: T. h( e
• 
  
  1 L5 Z0 p' D( Y1 j      PCB *p;
  + \0 n, w* F( Z6 E2 q' j
  
• 
  5 z4 I( O0 {% _7 r
  ' |/ O% @( Q. U7 R7 X      p=ready;
  $ K3 S# [) `% Q! ]
  
• 
  
        while(p!=NULL)  
  
  
• 
  + D  z4 t5 `* p6 c
        {  
  
  
• 
  ; y5 Y: \: c$ z# K: W
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  7 ^4 d4 C. F0 N; E, z1 D/ h
  
• 
  * t3 k2 s/ O' Q; h
  , }$ H7 |- q# P5 X, W          p=p->next;  
  # l, K# l, {2 q; B4 q0 |
  
• 
  9 G8 ^/ k4 z5 w0 a3 f' y
        }  
    {& r1 m0 ^5 X. K0 v1 K9 m
  
• 
  
  + f  f. y. u3 Y, X' `; Z      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  " e+ p* \6 L) t$ I( a. O7 X$ I
  
• 
  $ N$ n' f! Z: |
  7 Z; p" q/ _7 j. Y6 I      {  
  $ F$ {( w& o* Y1 B$ a0 j5 p; p- r
  
• 
  ! C7 ^: W/ z- \! b3 M
           run->next=finish;  
  * c! q6 x* |& F8 ^8 h
  % i! L% t. }) [
• 
  
           finish=run;  
  
  
• 
  
  . C. ^- t; Y; w# L         run->state='F';  /*置状态为完成态*/  
  ( ]3 p4 K+ F3 [( A( }" U0 D; F
  ; i0 i0 F4 y& H- j, I
• 
  
           run=NULL;  /*运行队列头指针为空*/  
  
  
• 
  ' O8 l) m. l/ @% z. V0 Z8 _
  ' E# f* c) E9 [3 J" S) b  `         if(ready!=NULL) /*如就绪队列不空*/
  ! }9 C% J; I' m2 ^
  
• 
  ) n! l! a! p9 q1 z7 j, L
           {  
  
  9 p4 S$ P" w& ^- Y" y. }1 u
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  6 j- O& o0 \  F& a8 M2 g# q
  " T- b/ ~0 V; f( ?1 E
• 
  
           }
  
  
• 
  
        }  
  * U, R- y0 {1 y8 K2 m: h4 A8 Q
  8 `  M$ u% n; c) a9 Q, A, D# s
• 
  ! G8 q* I3 q1 C
  5 Q( A9 d6 V  r1 B( R; A# G( U# z      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  / A. v$ _+ u3 `
       if((ready!=NULL)&&(run->prio<ready->prio))  
  
  ' [1 S5 J9 ]" \" o  s" L1 p0 F# i* q0 J
• 
  
  2 X* x. v% l9 r% m2 Q     {  
  . I) ~: [4 x' j' s" e
  
• 
  
          run->state='W';  
  
  
• 
  
          insert1(run);  
  
  
• 
  
  ) J. D( S* W( a4 R1 g/ [        firstin(); /*将就绪队列的第一个进程投入运行*/  
  ' K% t, k, W; G# e0 h
  
• 
  * e6 y0 a" }+ r. b  o5 K
  2 U7 I) G( C3 X, L     }  
  
  % \  X3 n* m3 G2 z  r: @
• 
  8 V8 P' I2 p+ U1 V6 t$ |
  & N! ~: ^1 q" c& s: X2 U# k3 \      prt(alg); /*输出进程PCB信息*/  
  & s% j* [' T  |
  
• 
  
  . P; A4 d: J8 t" l  ?9 W   }  
  
  
• 
  
  / ^. T2 |/ W; S}  
  % e4 _& [1 |3 h$ X* k/ X- p$ L% n* S
  + H* d8 V5 G& `* [! J3 \
• 
  
  & L" E# w/ w1 t' j/*主函数*/  
  + b/ _8 s9 T3 ^8 m
  * M0 F( t2 `% A' f" e
• 
  
  # j( T. n$ ]! C' P- L& i, omain()  
  & h7 C# o* K- e8 h7 q2 i3 ]
  
• 
  1 |3 H) m* m' R& i
  {  
  
  
• 
  ! }- G% G- ]0 _
     char algo;  /*算法标记*/  
  
  ; ~+ L+ w& f0 x/ {( Y/ @/ d$ m" b
• 
  
  . }5 Q* ~" P+ |   printf("输入P确定算法：优先数算法\n");  
  
    i7 P% [1 f; Z6 P9 Z& \
• 
  
     scanf("%c",&algo); /*输入字符确定算法*/  
  
    i# {7 w" q# [( k: G* S' A  z% S
• 
  
  # {& }* Y% d1 \6 g- J7 V   printf("输入进程数：\n");  
  
  / A0 [! {+ e. N0 [+ u
• 
  * }4 I( w- q- }3 k9 o" D3 j
  8 [' l. V  l3 ]) x5 a* z; Y8 u' `   scanf("%d",&N); /*输入进程数*/  
  
  7 u0 l  K. ^3 z. [2 c( Y1 U8 k2 r
• 
  : n- d/ n1 C  ~+ j
     if(algo=='P'||algo=='p')  
  
  3 y" ]' L" P2 T
• 
  
     {  
  
  
• 
  
        create(algo); /*优先数法*/  
  
  ) F0 U6 Z- c2 U3 T' \; i# [
• 
  - N9 j* B( Z* Q: |
  4 l  [! E$ }$ v( J9 c, y( k      priority(algo);  
  
  4 [" x( p" F9 j0 m
• 
  
  / @! r0 _8 q* B   }
  
  ) F: K8 m' T; b, J5 F$ Y2 m* H( f
• 
  
  }
  
  7 w4 S6 E1 b% M$ p: G
    S  S9 C8 w1 A7 P' ^

. E7 ~! u- D. N( g; s输出结果：
9 }& p- d' f; I! O/ Q9 E

& E& k$ ^% Z; ^3 m) k# ]原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

3 q6 H( x: L0 J& ^
: ^) J' O% e1 ?$ F5 Z8 c% D