优先级调度算法

杨利霞

" l% ~4 L# i2 l! w# L! A优先级调度算法
5 M9 h" U* |# @6 s. b

算法介绍
- S) X6 w  H0 T# T- m* b) i% S2 {优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
* c' r5 I2 H7 ]5 W. R0 n4 r4 r系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
7 g$ R: W$ l* _6 {( r/ j- d$ I- C2）抢占式优先权调度算法
. R+ l; H& T9 u7 L# [1 G只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
% b0 V1 L' m6 ]+ F) l2 `/ M  i静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权

算法实现

抢占式动态优先权：

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

• 
  4 U- u' F% h$ z, X: g) R5 Z
  #include <stdio.h>
  % l' b3 @) r8 t; Y
  
• 
  
  0 b9 W8 g: v8 E- W3 h" U#include <stdlib.h>  
  8 G7 l& w  N2 N, t; G  H
  
• 
  ! E% K# w- y* C# ]- ], z6 t9 d
  / ^' F# v# ^! w, g9 K#include <string.h>  
  ; o2 o- a% O- O9 J7 O9 o" R
  
• 
  
  typedef struct node  
  4 Z) O: T7 E% O2 H1 J5 w
  # b4 e7 e6 \8 m& ?
• 
  7 E5 I- ?; t0 n
  {  
  % Z! o9 k4 K( Q- Z8 G& x7 n  s  T
  5 v0 p+ R) g( f! ^; N0 ?
• 
  
     char name[10];  /*进程标识符*/  
  
  ! ?# f7 P/ X, Y( J+ U
• 
  
  ! H: b3 U: x/ N. H2 G" Z   int prio;   /*进程优先数*/  
  
  
• 
  
  ! B" H$ t+ P6 F/ c) b   int round;  /*进程时间轮转时间片*/  
  ! M  [+ a4 |5 Y. w) B
  
• 
  
     int cputime; /*进程占用CPU时间*/  
  2 u, i/ M/ [) g+ q6 n/ i  Q/ a3 m- R
  2 N5 g& X" ?# f7 i; l& j+ a% U
• 
  ! \& \% z( h) D
     int needtime; /*进程到完成还要的时间*/  
  
  5 Y! H, `6 f; |
• 
  
  8 S3 f2 ^7 f& O0 w2 j! I   int count;  /*计数器*/  
  
  . ?3 x; ^. a" o. e3 h
• 
  & d. F& S. z( R' x* }
     char state; /*进程的状态*/  
  
  
• 
  
     struct node *next; /*链指针*/  
  
  + v' S8 }. ]/ J4 d5 x# B$ l
• 
  7 [6 Q2 ?: V  T
  }PCB;  
  
  
• 
  ! l! Z7 J8 M" w; ]( j* t5 D7 T
  $ @$ s5 u0 t# I3 x7 YPCB *finish,*ready,*tail,*run; /*队列指针*/  
  % x! @! K- f6 V! Z  w/ O
  
• 
  
  % c+ a# c) O* _  m0 C2 S5 Uint N; /*进程数*/  
  $ j- ~# {. }/ ^/ w3 ?+ j, X, c
  ' A9 n6 r  Q) R
• 
  
  /*将就绪队列中的第一个进程投入运行*/  
  
  8 @$ Q  Z$ G% X2 V, K. h
• 
  
  firstin()  
  8 }$ ]! n% W8 _, _* G8 y5 C
  , \! U; i  e+ p+ [# ]# n2 k
• 
  ; r7 E! O0 R) u
  {  
  # R* O5 y* M2 s5 c% _/ [- ]
  
• 
  8 P& v' Q$ M7 @$ @
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  
• 
  
  ! o/ h3 X! V# ~# A9 y$ ]8 a$ x   run->state='R';   /*进程状态变为运行态*/  
  
  * z: A2 `/ C' F' O& |7 P
• 
  6 E) S, M; l0 p' N/ x- v# \6 z
  1 v* I" t: J) r! }' b8 j, A" j1 w   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  
• 
  / R, T' m, a- e& S6 A. U) r7 a
  }  
  
  
• 
  
  ) P& G* j/ U! f/*标题输出函数*/  
  + p" s" Q, b6 y% [: o: Q4 O
  % ~% w& d2 e4 _% m$ `
• 
  
  void prt1(char a)  
  
  
• 
  3 C& a% x/ Y1 N2 G! I: B' R+ X# b' J
  9 e7 h( v* T: u7 U+ R{  
  7 V7 v+ ?, ?& r. e3 \8 D! e1 U
  
• 
  ) s! h$ O5 {- K! G& [9 f! T& A
     if(toupper(a)=='P') /*优先数法*/  
  
  
• 
  . F- Q9 @: @$ {, a0 G1 g
  & Q4 R* y0 b7 X; x$ [      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  
  0 _7 V: T) T! H$ x! a   else  
  
  
• 
  , W: T& E8 ]( [6 ^: e/ [6 b/ y& |
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  : f$ k  y# \) X& ]
  
• 
  
  , [/ H/ B0 m# u/ d! {- V" C}  
  
  
• 
  / D: ]  m( t! `2 ^
  /*进程PCB输出*/  
  + i' }, e5 q3 R1 D
  " v! D, ], u& r6 h2 \' S2 }
• 
  
  void prt2(char a,PCB *q)  
  
  : b0 x6 T0 B" C, q
• 
  1 G9 y9 A+ x) Q, B4 y1 H) f
  $ q4 ]1 Y" P- }7 P{  
  , l" s! }2 Q, @) _# Y6 T; Y
  2 w9 }5 f$ G( I8 I- |- S' l
• 
  
  # i$ o6 N* v8 Q! V. |% l   if(toupper(a)=='P')  /*优先数法的输出*/  
  + U; h# F% G: o8 n
  
• 
  
  5 R: E" b6 I! ~8 g      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  4 y. }! b" B8 x/ ^( Q: r* Q
  : U- P# Z+ o+ _
• 
  
  - B2 H! W. y5 j8 k- B+ e       q->cputime,q->needtime,q->prio,q->state);  
  9 T; ^  \  |7 t; q: B
  . y$ ?& W4 ]$ v* S5 ?! Q4 K
• 
  
     else/*轮转法的输出*/  
  / @7 w* g( {4 _8 @8 ~) F3 Z
  0 V1 p+ W6 G( Z3 |8 h, p# v* Y
• 
  2 Z2 T5 B4 J3 n" h# A+ H% v
  # h& D  L: Z0 R& \: y) M      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  4 E# T  u' y/ z& R; J! E
  
• 
  
         q->cputime,q->needtime,q->count,q->round,q->state);  
  9 k! B7 s% u4 S/ C
  
• 
  ; z9 F3 o7 L1 c1 Q- C
  ) @/ a: X  E. c+ S0 r* Z3 }( Y}  
  
  - ~9 u& L) j' S3 Y1 B
• 
  ( I- `- T7 s2 E* F& ]" |
  /*输出函数*/  
  . G% x' H  f+ _7 c( c
  
• 
  . {0 K! y1 C. u; v7 A' M
    E1 C+ d! w- w- T5 q! Uvoid prt(char algo)  
  
  
• 
  
  ! d2 e+ H7 q) `% c6 a( J/ V4 Z$ h) H, k{  
  - S) Q) @  `! @1 I& p
  2 a) x# a) a2 H' v& \9 C
• 
  2 l, L9 m0 X% p0 w5 s2 d0 |' g
  ' l5 Y0 @7 M, S2 M; l1 d, S0 @   PCB *p;  
  
  8 I* M9 o7 _: {. m( n
• 
  
     prt1(algo);  /*输出标题*/  
  4 ?  a+ S# k( Q8 l& M
  
• 
  / T0 a* \5 r, d1 ^# K: ]+ b; g, W2 e3 U
  0 N5 Z9 H, ]9 d) i! X   if(run!=NULL) /*如果运行指针不空*/  
  
  3 H/ B$ I* B+ z( C5 y
• 
  
  4 K/ \; E3 Z/ [, J+ W0 i      prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  + r8 g6 f$ o% A8 n* S
• 
  
     p=ready;  /*输出就绪队列PCB*/  
  , x) f! j7 \! r
  
• 
  9 U6 R! I% e+ v1 M# \& W  J6 Q
     while(p!=NULL)  
  9 s) ?$ b7 w# B% C: W+ v! D
  
• 
  
     {  
  . `3 x7 c8 ^2 r5 g, U7 s
  
• 
  
        prt2(algo,p);  
  
  
• 
  
        p=p->next;  
  
  * X7 ?% u# d6 |8 F. ^
• 
  
     }  
  : F3 L) ]  ]7 o. o( W
  # \2 d. {/ _' W7 z! R/ K6 d
• 
  0 O7 }  y; o, G5 r; F3 @
  ' ?" a2 T, s3 v3 K( j% p   p=finish;  /*输出完成队列的PCB*/  
  : k* ~: i2 x: x  r. {5 l% g* O
  
• 
  
     while(p!=NULL)  
  : m9 E7 f7 M  Q6 W% ?3 Y7 |) ?
  9 |- X$ I, l  S# L5 w3 q
• 
  
  + e8 {3 o( p! A  ]   {  
  4 S4 R7 X4 r7 a0 K% A
  - Z8 J  ~- z$ W4 n3 v, V" ~
• 
  - y5 T4 Y8 O4 r2 Z( _
        prt2(algo,p);  
  
  
• 
  
        p=p->next;  
  
  
• 
  1 U5 ^& U/ I+ C' C' i$ K/ Y; l
  0 K+ K, E, n% \9 [( P$ O  b4 f   }  
  2 d( `5 [1 H5 X  n& v1 V3 Z
  % u) Z% ^/ u$ V! x
• 
  2 x$ H  n7 J9 G
  : h$ u0 z/ w/ ]6 ~/ k   getchar();  /*压任意键继续*/  
  
  
• 
  
  ( S. e1 l% P9 @}  
  3 F, f1 l* q8 t. k2 {3 E4 L
  7 m3 _, Y% _) U3 S0 L( }% |
• 
  
  /*优先数的插入算法*/  
  
  
• 
  
  0 E+ W! z/ n" G9 |insert1(PCB *q)  
  
  ( }4 c  G( z1 V- @$ L6 H+ h
• 
  % E* b0 E& @; J/ I3 z; {1 u
  + z' T, Q5 z. \- b$ X{  
  
  " L/ ^; T  d$ E; @! o8 _. j
• 
  ( i* X4 v0 a- n" U3 o: l
     PCB *p1,*s,*r;  
  
  
• 
  4 B: t, |; }) O6 w- R
     int b;  
  ' Z" N8 W; l+ F0 r
  
• 
  . B, @& [0 p% k# k2 d  m4 \! y4 ^
  ; r* r2 l( i2 T: A% J% T' F- O   s=q;  /*待插入的PCB指针*/  
  6 W' U% J+ i( J8 _, d% x( x
  
• 
  
  " x- u9 Y# e2 ]- p0 h$ A; I. r5 M   p1=ready; /*就绪队列头指针*/  
  & T0 ]6 D) i7 a) Y) ~3 D( Q
  % u$ K& O0 e' E$ R3 M
• 
  
  - A& I. G1 O7 e0 H   r=p1; /*r做p1的前驱指针*/  
  
  ; R! E6 M( O1 G5 e! L
• 
  
  ! e0 E1 w: D: `3 b) e   b=1;  
  
  
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  
• 
  / Y' f# u$ K$ X* o! Q5 t
        if(p1->prio>=s->prio)  
  ' Y1 y* i8 x: \
  ' K0 y: q" U* z0 r3 v
• 
  
  ( z, r' J& l4 [6 T( r& m% F      {  
  # k& q$ g# w2 n. ?, ?; x
  
• 
  ! f. M1 P' e5 q$ Q
  # @  T7 h$ F. i$ W, q     r=p1;  
  ; k1 C  L* ~* q/ J1 @. F# F
  
• 
  * @/ }! d2 I3 _2 H
       p1=p1->next;  
  
  
• 
  * D. B& [" D; {5 U  W
        }  
  $ B! Z1 i' h- s: u! l
  - X: ]3 e# i, v, e6 B$ R
• 
  
        else  
  2 J2 H7 K* Q4 P6 [2 w
  
• 
  , f& k% Z# {4 t, R. y
  1 b2 x2 c  B) J: c, B! }     b=0;  
  ' b: E5 l( s+ _5 O2 s
  7 s' M  d! z+ v) m& S
• 
  / D7 J# G1 R' A
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  " O2 F* ^- U9 F" H
     {  
  # z- |( Z& r; s: Y
  ; Y, m3 |" ?0 i; Q# i  X
• 
  # m* P6 V3 {8 e: x
  $ Y! `! r: B# B7 s      r->next=s;  
  
  8 O* I* T4 w# ]" t2 B
• 
  ' M3 {2 |* O* C  y7 S' z  s4 D
        s->next=p1;  
  8 u, V: p7 ]6 z1 V
  * |3 ]6 i" w+ u
• 
  
  5 U3 J) x6 H. W# e5 `# f, V   }  
  8 N5 e5 M  c: \% Y
  
• 
  $ s. x- V. o% b7 V
     else  
  
  " X/ [2 f6 s6 n# C( M! O
• 
  
  8 J8 _3 ?. c: r0 X   {  
  3 g( A# T' X6 W8 j* d5 v" G
  
• 
  
  6 k0 R; e& b6 s3 c5 C+ n2 Y/ H      s->next=p1;  /*否则插入在就绪队列的头*/  
  
  
• 
  7 U" F. n  z7 y( {8 h+ F) f0 ^  _
  . `' O" H& C0 A* K7 s" s      ready=s;  
  1 J3 @0 q0 K9 x3 F
  ( \, W  q$ Y) _4 v
• 
  
     }  
  
  
• 
  3 |( _  Y6 E* C8 ]) f  i
  }  
  
  1 p0 ?$ I  {" r0 F8 n8 e( B. J
• 
  
  /*优先数创建初始PCB信息*/  
  
  . V2 ~/ X" Q9 s/ U/ T, q" K8 D, q
• 
  
  void create(char alg)  
  
  6 J/ Q, n9 f% y* o$ C6 K
• 
  
  ( m6 ?5 _5 m/ [0 j  T$ X{  
  
  
• 
  # g+ C2 i  N# ^
     PCB *p;  
  
  
• 
  # y7 e; S' ]3 U& S2 o
     int i,time;  
  # Z& g* n4 }; p
  
• 
  , }% s! @3 @" i- J8 }+ h
     char na[10];  
  , q- V# N1 C' E4 V8 K
  7 @) B% G$ j: b* P
• 
  & i* K; C0 B! w: d6 M
     ready=NULL; /*就绪队列头指针*/  
  ! y, q$ A  J% E. [
    Q6 x: w3 H3 c. C5 n
• 
  ) z! C' Y' Z: t; W- d! _5 I' I
  5 V, U: G( V% ^  `   finish=NULL;  /*完成队列头指针*/  
  ) K$ I6 [. a' D
  ( z1 A* m  @6 `8 T
• 
  
  5 m! b# P4 b4 o7 O' r$ k  t   run=NULL; /*运行队列指针*/  
  5 O6 J8 t) z. y4 x2 ^4 }
  
• 
  6 l# I3 u0 x. w& U* o3 L- X
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  , W- X1 E6 a% l/ B# y& g1 J
  5 g8 ~4 z' o3 S' k+ g8 W4 N. a0 s
• 
  
  6 S3 t5 i/ n$ U6 L0 j9 N1 ~+ V$ G   for(i=1;i<=N;i++)  
  
  
• 
  
  : ^/ I- H( I% K7 h   {  
  
  2 E- w: P- V+ G8 x+ P8 i8 s
• 
  
  : ^  E: W5 c# t5 E( X      p=(PCB *)malloc(sizeof(PCB));  
  
  ; O. v  D# e' U. g! C: z
• 
  7 J- v4 Y6 m2 }5 q3 X
        scanf("%s",na);  
  
  
• 
  ' F2 I) Q( z5 ^; `1 f. L6 g
        scanf("%d",&time);  
  ; |# C8 D# d. P8 S2 S. S
  * u2 |# K5 q2 J1 H
• 
  1 ^# {! m  k. V% l
        strcpy(p->name,na);  
  + d9 O5 k" E' h5 |( u& w
  
• 
  : J3 a/ r7 a  o1 w' H  T1 K
        p->cputime=0;  
  # p9 A: V9 m6 q4 j1 Y
  
• 
  
        p->needtime=time;  
  , ]8 f* k# m/ F% m
  
• 
  
        p->state='w';  
  7 a& F" W! }; z' y7 [! ^# A; f% J! W
  ' V: E% m. o, {* [6 `, O
• 
  8 R  g' A& R8 W# x$ g' t& ~: G
        p->prio=50-time;  
  
  9 y, t8 R5 z+ r
• 
  + T" k+ [/ K8 w% t  Y3 Z0 i
  . k5 \' B7 K/ I5 K      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  & z+ w$ \# L6 N' H2 Q0 O  n( D
  
• 
  
    k* l- r, c9 d5 H' h: Q$ U     insert1(p);  
  
  
• 
  
  & M+ k. }) ?* p3 d+ `5 G      else  
  ( L1 t" B* k3 m
  
• 
  ( h# C# \( U/ p% d% }
  ' g0 g. W" }( l$ q' X      {  
  5 c' s2 F) X. K2 _
  1 L# j1 C0 n1 t" S: ]- _% b" M; I
• 
  # Q' i" V' I; w# U, M: m8 y" a, l
       p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  
• 
  
  5 ?  A0 g7 F7 M8 t7 y4 e+ Y6 E2 R     ready=p;  
  7 |2 b8 \0 d8 ]' I& }
  
• 
  , x1 s. s( s% m- I" _
  ! Y. }. Z9 ^4 W6 q4 W5 V! p      }  
  # c$ m* V" L/ U1 c
  
• 
  ( y0 q8 Y0 q3 z. G& r  A
  $ D$ `) |3 {1 m3 c7 z   }  
  - S3 b" |* ~& K
  
• 
  
     printf("          优先数算法输出信息:\n");  
  " l6 I$ L" F2 v& m/ t, [
  
• 
  9 l2 n% q! {% [: C8 T# a0 t; K
     printf("************************************************\n");  
  ! K) O& b, V1 d/ O' K- d3 C. [
  $ S0 Y/ O0 Z0 D' F4 Y" x$ p
• 
  
     prt(alg);  /*输出进程PCB信息*/  
  
  % z+ W. B$ Q+ c7 d( x9 }
• 
  
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  - t) |1 k- d% ]! J
  * z" T4 s( P$ i5 l3 E+ L1 r
• 
  / l- [) L4 w5 f& }9 |4 a* l
  + q( I. g' f; o   ready=ready->next;  
  
  
• 
  
  . `  N. `/ b- b$ Z5 ~$ J6 ?: R: s   run->state='R';  
  
  - a9 [: N' ^6 q% G
• 
  % }7 W9 _) N+ l! K' E+ r1 l4 p
  }  
    C) ]0 n- J* U
  4 x+ V/ [: |# q4 ~. Q; Q3 K+ d
• 
  
  /*优先数调度算法*/  
  6 }1 @5 `0 ^& g/ b  _1 S$ S8 a, Y
  9 x; i" S) m, M
• 
  3 T4 R& s6 m) Y8 h' |2 Y9 \$ {; N
  priority(char alg)  
  
  " Q4 r9 @, G8 l! T& L
• 
  
  {  
  
  
• 
  
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  ! H1 b# t6 I3 `5 M; P  R9 l6 @/ A
  
• 
  
  * t1 f. F2 ?( r4 c  E   {  
  ' X0 h+ R. t" D
  ( w7 H  h/ w, [
• 
  
        run->cputime=run->cputime+1;  
  " P9 i6 G, E8 q' [  `
  
• 
  
        run->needtime=run->needtime-1;  
  * ~, w2 O3 n# S5 w: J* r* r! b( b
  
• 
  ! n# T8 |3 N8 B& E
  7 U7 S) d5 f, h; y      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  
• 
  
        PCB *p;
  
  
• 
  
  : ~! }0 {+ I) I4 B+ }, Q9 G9 t( m      p=ready;
  
  $ S! H& N5 {  ?
• 
  
  + I' `: k) Z1 M% t6 k) J; u      while(p!=NULL)  
  ' i7 T$ s- [: R8 N
  . i1 J: r, q- ~  P/ e
• 
  
  , ~; @  h# o- p6 Y- c6 B/ I# o      {  
  
  7 R) p8 U/ M8 z' {
• 
  $ k; ?9 `. d9 L( V8 T9 m
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  * [  ]( d" p  U" b0 a
  
• 
  5 w% S3 g6 z6 ~3 U- O: U
  , N5 E% K" P  Q0 s+ n$ [# J1 |          p=p->next;  
  
    V0 x4 B% w6 ]& Z5 v& t
• 
  
  & A$ g& Y1 f4 t' Z% v, g; O' d$ n      }  
  + Q& k6 ~0 _4 Q7 X6 s$ v$ A$ c
  # [  @  h8 l; J, l6 V5 Z9 j& y
• 
  
  8 `' r+ S# W9 s& u      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  
• 
  
        {  
  
  
• 
  " ~9 \. @$ [4 ~5 M. U8 w0 r
    E3 f# r7 n% H, p$ N# x         run->next=finish;  
  
  
• 
  6 h! d( q/ p% D; S7 X: ?; Y3 _8 R+ \4 |* R
  + N4 H9 j. w9 V* W         finish=run;  
  7 _  B: y& d! W+ P. T7 M6 B
  
• 
  
           run->state='F';  /*置状态为完成态*/  
  ' {( L2 y" r; E
  & m0 ]) c( L  [* u) @/ ^( G
• 
  
           run=NULL;  /*运行队列头指针为空*/  
  0 Y% K; n3 G0 i* y1 E
  / `8 `4 ?, [, U  m& y
• 
  0 Y! b7 o5 @1 h) |% p5 Q. L
  % M' h0 k  H: y- H6 a         if(ready!=NULL) /*如就绪队列不空*/
  
  
• 
    B6 O1 q3 p. g1 J
           {  
  
  
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  . P  z& v; {7 S: V$ l7 S& D+ N3 f
  9 J6 `& m. l/ l* d& }3 G
• 
  9 a8 B. u8 i1 S, h# O
  * b6 a4 [( h1 {) x; Z         }
  . f* h8 j& m3 t( P: E. u# s% q
  4 l9 b3 ?! _$ V2 a& D* O" g( ]
• 
  
  ! m' ]# V/ Y8 M9 ?5 U      }  
  ) B3 S; d6 M4 U
  
• 
  
  4 l$ X1 Z" d3 ?  I      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  + {( a: u  {1 i5 w$ @% [
  ! R0 n, R" Y8 T% I     if((ready!=NULL)&&(run->prio<ready->prio))  
  
  6 [7 X3 P" M9 I" L& ?9 l
• 
  0 }3 T% N7 i& Q$ z) c
  ' O& D; E  r, O+ j: j     {  
  
  ! S' y* f# ^. E1 N& K
• 
  
  3 z; j3 ~8 P! d: ~! g6 \9 E& r3 r        run->state='W';  
  
  7 f. Z- S8 S, W
• 
  
          insert1(run);  
  ; P/ H5 L' `% Q7 {/ r8 V
  2 U* s+ V5 y2 L  i, v
• 
  
  + I  J& Z/ X5 ?4 A0 R+ O+ x        firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  
• 
    ]9 e& n+ A! l5 S$ |
       }  
  
  
• 
  7 p- W0 ~5 _* j4 g; i& h2 s
  : S( k6 i. t! r/ }% p      prt(alg); /*输出进程PCB信息*/  
  
  8 q/ Q! l  ^) [) B5 T* \' i
• 
  6 }! w0 L( [7 j8 D
  ; [2 d5 a- E/ m0 U$ q: R   }  
  0 n8 @" X/ Z" \2 j+ g; r7 U( \0 c
  
• 
  : h% q( Q; w( Y6 j
  " f+ p' y/ d' R) ?; c1 d: b' m0 F}  
    J( t# p0 P3 X
  ! _; R; c3 q3 m/ g
• 
  
  /*主函数*/  
  / P- H! q) }1 `$ N3 v7 }* ]
  + m% @* l7 |. [4 s8 q) a
• 
  
  % Y- x7 E; r$ y4 C8 amain()  
  
  
• 
  
  {  
  
  
• 
  " r7 ^+ h- }7 o& G0 V9 [* g" ~
     char algo;  /*算法标记*/  
  $ e3 B7 z7 i6 Y+ l5 {6 t# o' M. i/ ^
  
• 
  : ^' I$ K; e4 E5 _2 {- H4 i
     printf("输入P确定算法：优先数算法\n");  
  
  5 c$ @& E4 M: m( U# p6 {( Z
• 
  ; s, \! n- t. z8 J+ f
  0 `( i5 ?/ r2 _   scanf("%c",&algo); /*输入字符确定算法*/  
  9 ?0 k; U0 i. ]
  % [; [+ f8 e5 i3 n4 y5 Y; |
• 
  
  ; M; |8 o+ K1 N   printf("输入进程数：\n");  
  
  2 K' ~3 m, E) c2 K( y
• 
  2 j; H5 y  f2 c) W
  4 J, Q. `3 H6 _6 E3 M   scanf("%d",&N); /*输入进程数*/  
  3 t8 a% W- V+ p: R( |
  9 E  l1 S/ y1 m+ L6 `! e) d
• 
  
     if(algo=='P'||algo=='p')  
  
  1 u# G; L& _) x) q9 u
• 
  
     {  
  
  
• 
  
        create(algo); /*优先数法*/  
  
  
• 
  ) h- K, L4 e7 z8 e. B5 S
        priority(algo);  
  
  
• 
  
  ; l, A8 H- ~. K( V+ P7 P( f4 u; a   }
  
    a* J8 [! V6 [1 B: i6 ~( J# Y
• 
  - R. ]! P# l( c# A2 M; ]6 n( m, F
  2 k, y9 z5 d2 L5 a/ ?}
  
  : l4 y: {# c: Y) J  B0 b6 |2 x0 A8 R  }
  

+ o1 d) B- }1 x# ]+ }. M3 Q4 q/ Z( ~输出结果：

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