优先级调度算法

杨利霞

优先级调度算法

算法介绍
优先调度算法的类型（用于作业调度）
( H, Q0 Q5 @. o1）非抢占式优先权调度算法
+ k' G' `. A- Z1 ~系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
1 ~- W. O! i) s4 B- o. m2）抢占式优先权调度算法
" y9 g9 H1 d; y8 S% z$ B! X, B3 u) B只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

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

2）动态优先权

算法实现

抢占式动态优先权：

8 _0 e0 r( w; u  @- EPS：本人认为非抢占式静态优先权没有实际价值。

• 
  / F% u6 ]  [/ @+ F, E4 z
  * q- U8 @0 L/ _8 u#include <stdio.h>
  
  $ ]( ^9 t  s/ Q9 _( Y7 }) N- ?
• 
  & S8 m- P/ O" V. p
  #include <stdlib.h>  
  
  6 L* x  r. }8 W9 _9 o
• 
  
  ; l8 `  P3 @0 ^8 ~% [0 _#include <string.h>  
  
  
• 
  ; H' }: i' B, O2 s
  1 R4 ?) e1 ~) t( xtypedef struct node  
  : \6 x0 S& g/ K/ a- m- U; W' f* F: E# m
  7 l- e# G" r+ ]: Y0 u$ t" v
• 
  
  % \  O# ]# W" h* Y8 R9 X2 G& ]{  
  3 Y# W+ [4 Q& P& W; Z1 p
  
• 
  
  8 t0 q! X% h9 b2 i   char name[10];  /*进程标识符*/  
  
  
• 
  9 ~4 X. l( @- V  z5 F  t* i- V" E
     int prio;   /*进程优先数*/  
  
  
• 
  & h$ q( N9 d2 d  r
  7 D0 _6 C7 E2 ?   int round;  /*进程时间轮转时间片*/  
  
  
• 
  6 `( k3 j! d7 F* y% j2 A/ h5 E* f* {
     int cputime; /*进程占用CPU时间*/  
  9 o$ H' U1 O+ Q( ^
  ! J. }' w& W6 T$ W7 w6 x5 u
• 
  
     int needtime; /*进程到完成还要的时间*/  
  
  5 K* H/ C  u. w# n9 `* W( ?" `
• 
  
  7 p7 @" c" x( C! ^6 l' n. q! x   int count;  /*计数器*/  
  
  
• 
  
  ' f8 [9 @9 ~* G1 y% A3 U* u   char state; /*进程的状态*/  
  
  
• 
  
     struct node *next; /*链指针*/  
  $ J! W# _: F0 {3 x& y
  1 @! `! _) K( F$ O
• 
  
  }PCB;  
  5 q3 u6 B( V$ y2 R+ r  [/ i
  
• 
  
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  1 P+ I& p! m1 E- f* E. y7 z# f
  
• 
  2 B$ L0 w1 i* y& I5 D
  8 P! S5 j9 T) _! q* a4 Gint N; /*进程数*/  
  7 d% a- O/ }* b* o  Q, G; M
  
• 
  
  7 T, o- F6 O* L- H, U5 `/*将就绪队列中的第一个进程投入运行*/  
  
  
• 
  8 s7 }0 t4 ]9 B# e; |+ D
  firstin()  
  + o1 M4 T2 [$ W0 k3 R* H2 Q$ t0 {
  & p- N& i/ @3 N5 e, _
• 
  & f( Y% k/ a: C/ m2 f
  / E( |8 ]5 o' m# P  F+ s{  
  
  , U& X! `3 n0 t. B0 j. c/ X: h5 c
• 
  ' Q0 G2 }) D0 m5 `
    }" \) m( Q- C- N$ p   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  ) R% r/ N9 S0 H0 p+ U
• 
  / a- g  w9 v8 ?* W
     run->state='R';   /*进程状态变为运行态*/  
  & T% U  l9 g5 W0 v9 [
  
• 
  
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  * s2 D( A' g6 C% e" m+ Y7 d
  
• 
  
  & `/ K( ~  I$ i0 d0 X. M* |}  
  ! L- T2 _: Y! H+ D- s
    w1 E7 G& S! s( K) X
• 
  
  /*标题输出函数*/  
  4 v& ^5 _9 w( M5 f7 g
  
• 
  ) g9 P7 g: O; y; l+ ?
  ! q! }4 y+ f) o' nvoid prt1(char a)  
  
  
• 
  
  3 l! q3 R3 [+ ^3 y+ v* T{  
  : C" q! M6 W+ M, W" ?' r
  
• 
  , K: o) L. ?$ l" {# s
  . d0 M- K$ |' t1 n   if(toupper(a)=='P') /*优先数法*/  
  8 q9 w9 J4 R# s9 z
  
• 
  3 m5 D2 U2 B% C* B+ g5 s
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  
  ' a0 z+ r( [* o2 s  v' t   else  
  6 |6 g2 H5 A+ ?) k
  
• 
  
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  3 @, w" ^% w  k' k0 T
  
• 
  + J; a" z: i9 h$ @; D3 P
  4 P8 B6 M+ w9 ^# ^4 m}  
  . [+ k+ P" [" F1 I) x0 \2 @, C
  
• 
  
  /*进程PCB输出*/  
  $ |4 o2 E, S! }
  
• 
  + c2 x, m6 O& a  I% E$ z
  8 o! P6 v% W$ K' vvoid prt2(char a,PCB *q)  
  # t- H! v( d' z0 k" R
  
• 
  
  ) q2 b% L/ C& ]$ F8 ^  k{  
  " U* N* F; |5 M7 J6 x8 U  z. x
  
• 
  % h* w# ?+ w! A" L
  2 }3 u3 r' V) k; j! R- h9 l# _, O   if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  , S4 U. i& q4 S1 U8 `
  * l, q" z" J- V+ c0 N; p, ]* O4 p- M      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  6 w  w6 t( I6 H
• 
  
         q->cputime,q->needtime,q->prio,q->state);  
  ! F+ d  {6 i( o0 Z
  
• 
  ( i9 W& C4 w; b
  1 w- R: E1 X! `9 U  n% M   else/*轮转法的输出*/  
  
  
• 
    j5 R4 o: t+ ?+ G/ C$ F
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  
  9 c4 f- r6 w! `" b% L       q->cputime,q->needtime,q->count,q->round,q->state);  
  
  ( \9 _2 [6 Q& t) Z! s/ h# k
• 
  ; T# x2 ~9 u6 I- P* w% i7 c* J
  5 Z( S( d( S6 H  ?& Q0 V/ `}  
  : V8 a2 }' o: O" R3 b
  # f& ]4 I8 x* p; k* j" C
• 
  
  /*输出函数*/  
  1 y% e) u: p( n. T" o5 k1 o
  7 }" N, P) r4 {' l) d
• 
  
  void prt(char algo)  
  ' F( s1 d6 A6 O' z# H
  8 x" I6 L( x7 \: J
• 
  
  8 u8 }9 n+ I4 l# O0 ~: z% H! S{  
  
  - F/ p" C, w& y% N! m
• 
  ' a1 |- Z; ~- w9 H% R3 w" t) ^
  & l& a, g3 {& U5 o   PCB *p;  
  6 I4 p) @0 L' ]5 Z9 y
  
• 
  - J/ {" {" y- ^7 F+ Y4 A
     prt1(algo);  /*输出标题*/  
  
  
• 
  9 e0 l% F) `# |5 r# ]; Q% V" q
     if(run!=NULL) /*如果运行指针不空*/  
  
  ) ~# W$ y+ E9 J/ i
• 
  # `: [" z! p7 k
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  
    y8 V4 f7 h8 E5 H$ C
• 
  7 [$ k; c8 L) w2 J; B/ G: B3 v) @
  1 E; l9 c( ?# x0 ~/ x* x   p=ready;  /*输出就绪队列PCB*/  
  
  4 r  Y: P( o) N# r, g3 q
• 
  * o5 {# Q$ Q, Q) F
  : ~. K9 q$ o5 g2 v! d   while(p!=NULL)  
  
  ; n+ C1 C1 O0 M
• 
  
  * j- v* H) l+ g$ O: v6 w   {  
    z- w( e1 M" r
  
• 
  
        prt2(algo,p);  
  9 v8 I2 p" ~. z9 y
  
• 
  
        p=p->next;  
  
  
• 
  9 V* K" I& r, B- S0 }+ c% u. k
  " P5 t" _& a8 F. A( p+ e+ Q0 J   }  
  0 O1 Y) e7 Z( Z
  9 A+ g/ x$ K" b1 M( I" {
• 
  " h6 o2 b! N( d
  2 ?- o+ J& b. {   p=finish;  /*输出完成队列的PCB*/  
  
  + s: E0 T4 q3 u! k! I5 i7 x9 M  q: ^
• 
  
     while(p!=NULL)  
  $ V( D9 j3 c0 i- _" k, x" X+ [
  
• 
  * w5 J5 z' @* U8 D' ?
  * w/ }. {; K) Q6 j   {  
  
  / x( }9 ~& O7 k$ R* q' O  d
• 
  
        prt2(algo,p);  
  
  ( K* K/ t- z. Q& ~" H$ I9 E
• 
  
  7 A% r6 t2 B2 A- g      p=p->next;  
  
  
• 
  . G7 b7 {) r$ {
  3 O) i: h& Y' D8 ^+ a* q   }  
  
  
• 
  / i+ i7 O3 v' C3 W, E! T
  " }: g# w( a. g6 _   getchar();  /*压任意键继续*/  
  4 l2 l$ u% h  D$ J3 d  l
  2 h  v" y/ a* F' f) Q! }6 T8 }. B
• 
  
  }  
  
  
• 
  9 T6 T! c% j! x
  /*优先数的插入算法*/  
  8 c! A5 i9 n* y  j  x% k" ~/ J
  3 K1 I" W+ S4 f( _9 B) X# _. e
• 
  
  % t/ l/ N0 Z- n( ?' O5 Z) |+ iinsert1(PCB *q)  
  8 [* j. G1 R, j5 R
  5 M6 B, R/ B! X: j! e, [
• 
  
  {  
  
  ) ]9 ^- j0 v; L) Q$ S) W7 G, y
• 
    b8 [0 t5 f$ j: h2 L& P
  % G2 E* A# M$ d   PCB *p1,*s,*r;  
  
  
• 
  
  ' [/ q/ Z1 G" w   int b;  
  
  
• 
  & C2 `( |  J" Z9 F9 B) t2 A4 W
  6 ?& j* Y% |+ q. r8 U   s=q;  /*待插入的PCB指针*/  
  
  8 e/ F( s. }; C/ H: n" U/ p
• 
  * `, Y) S6 U$ s- M
  " ~- w( K, O' s  s/ n   p1=ready; /*就绪队列头指针*/  
  * p& x' T6 j, G% Z; A. N
  8 l% w& Q8 _0 o1 L: q5 M
• 
  6 t" t+ ], G# Y, O9 f: \( F
  ; W: G* {9 E6 X$ F( m   r=p1; /*r做p1的前驱指针*/  
  
  
• 
  ( {8 X% V3 i6 o! Q& J
     b=1;  
  
  
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  % t3 J0 R' c$ Y0 ?8 L
• 
  
  7 z6 _( o' \# H& @$ U, d$ S      if(p1->prio>=s->prio)  
  
  
• 
  
  - Y' M4 M! S( X0 m      {  
  ( k" x5 x2 Q# ~
  
• 
  - J1 }4 @  e% N
  . L  {' [) u* i3 w  {: ~     r=p1;  
  . W' D1 O2 R4 J" P6 b' ]7 B% {
    j4 U( S( |+ S
• 
  
  2 y; R4 V# Q! Q& B' o' m2 ]# x! g     p1=p1->next;  
  3 z9 ^& m' P  G: {9 Y
  ( H4 F% t9 o% T. A4 T
• 
  ' @1 w! [/ X* |5 D# K; j
  . M  D4 t& z7 c% t, D  H9 P$ f      }  
  
  
• 
  / ~5 g) }# z: X& b: h& e( B- y
  8 h7 |( O0 O4 W6 c5 I- q6 G$ ^' e* J3 z      else  
  
  8 s+ O( O6 }( L+ k, s. j, Q
• 
  , G9 K' T* B% @% R2 T9 k" [
  " w  D+ m* s' a$ x1 b: Y     b=0;  
  $ B0 y) k# E& Z* p8 X( |, ]0 K  \
  
• 
  2 v) a5 x1 ~4 y' x' G; J0 U* I9 ]* w
  : k) v4 h/ L7 x, K# N  l9 G) S   if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  
     {  
  
  
• 
  
  8 H( Q( \( [$ ~5 N2 Z! I* R- N& q, }      r->next=s;  
  4 ^- r: y6 Y$ `8 Z2 T
  ' Z2 _0 d! Y1 y' S- u1 n# s, X
• 
  
        s->next=p1;  
  $ j1 r5 Q1 E  U* g- o. y
  * @, j9 p. |5 ?) I
• 
  . ^. R: }+ a/ M& W( j
  8 m! G* h* w$ y3 f   }  
  
  7 s- \& f7 A+ K! F2 R5 V$ z
• 
  % ]1 n" g' C3 M3 L, }8 K
  ( O' M: H! z* k: H6 s1 T   else  
  
  
• 
  
  ) t8 E" U3 j* U   {  
  " M6 ]2 x2 K! d7 Y0 X# U
  
• 
  9 L9 @7 N6 M; r! ?- {
        s->next=p1;  /*否则插入在就绪队列的头*/  
  % ]% v+ v" U  e6 I/ U+ _! |
    h0 V2 E& I5 ~& A4 a+ r
• 
  " v9 j5 C; }: K3 o2 A* w* q
        ready=s;  
  * V! y9 v9 Y* b, U
  7 _/ s1 E) p$ I: }7 X& k- H
• 
  
  ) E: |$ G, C% Q$ f0 r5 A   }  
  
  
• 
  
  }  
  / g2 z4 L, ^; I2 [5 N
  ) U6 d/ c+ D( |5 f- @$ c
• 
  : H% N2 @- Z/ G& e& `0 `
  /*优先数创建初始PCB信息*/  
  
  * h& j( u1 V' K5 V: m. B
• 
  % ~- N4 {* p6 C3 I
  void create(char alg)  
  % A6 T7 z3 [: Z! i
  / {9 @# ?( q' P$ q
• 
  
  " l. s+ b  S3 n# W' D/ A) A8 p{  
  
  
• 
  
     PCB *p;  
  
  7 B) {: v, t# L3 S3 l! V0 n
• 
  4 `) M9 \# p/ B( `1 R8 Z
     int i,time;  
  
  ; S3 b' o2 j5 L! w
• 
  ; G; ^. f# C& e9 `( W8 D8 s  L
  . J2 A% I+ R: D, V" s   char na[10];  
  
  $ ~. g$ F# D/ O' |; Y7 a
• 
  
     ready=NULL; /*就绪队列头指针*/  
  " w1 \  _& E. M2 D
  
• 
  
  & ?! j7 y$ w: y$ `" p( M/ R   finish=NULL;  /*完成队列头指针*/  
  
  # g& ?: A: ^, e$ c
• 
  
     run=NULL; /*运行队列指针*/  
  ( R( l1 q: i/ H$ [
  5 U  C- O: ]5 l3 ]5 d% b2 G  q* z3 L
• 
  
  # a  Z& n8 |- p   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  
• 
  
     for(i=1;i<=N;i++)  
  6 e& _2 M" V) Y% f' b) f. I
  
• 
  
     {  
  
  2 x* h/ s2 }( N: q: W
• 
  0 X  ~: {" G! {4 F7 J! K
        p=(PCB *)malloc(sizeof(PCB));  
  
  8 y$ t1 K! M( [: t/ a/ N
• 
  * P+ T. q  e- u! x8 r: ~
        scanf("%s",na);  
  4 l3 ~1 x' c! t3 o8 h& X
  2 Y8 Z. X' _6 p+ A5 D0 G7 x  ^- o
• 
  0 I$ D# Q; e9 M! @6 s: K8 i: o0 {
        scanf("%d",&time);  
  5 K7 z! T! ]) Z% _$ Z; O6 t" b6 Q# t
  
• 
  9 p$ K2 K. {  y- `' `
  2 f' }  x* e4 _1 h( W      strcpy(p->name,na);  
  2 B7 j( }+ [7 B9 i2 G4 e8 W
  
• 
  , `4 e0 t& ]1 X. M2 `$ [4 L% u
        p->cputime=0;  
  ( `( N9 Q$ T% R5 [& D( F+ y2 ?
  
• 
  ) z! u' s; S; C8 {* J0 |/ l- e) E
  3 ]1 j6 x! e! @4 ?# @) l      p->needtime=time;  
  3 k( s* r3 D, @- t/ e4 p# U: W  T
  5 Y+ {+ m( |" c. ~1 P4 y
• 
  ! N( I% Z9 h4 z7 K8 K& n
        p->state='w';  
  
  ( D$ B) _) Q( P) C4 m
• 
  
  ! V7 N: Q3 H( J; D$ L6 q: T& H# L      p->prio=50-time;  
  
  
• 
  2 n; W) n5 i* @' E
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  8 r# [7 d7 q9 h. ~8 @) t
  " F6 W; h; R8 g2 h1 E9 O8 L/ a
• 
  % g4 v8 S+ u- a; T% ~7 g1 E
  8 M( Y+ E; s8 }0 g: ^1 Y     insert1(p);  
  1 z( n; ]8 d7 O; q' f  ?9 P
  
• 
  " n8 E8 C2 _) f5 g7 b) D$ R
  8 G9 B0 K* A9 A& T2 e5 L; X      else  
  3 W7 d8 ?- M) I! ^. J& `/ S
  5 Q$ i" @: `  y' E2 m+ S% l. e# Q
• 
  
  . S- x% M( u# B9 X/ X; E      {  
  0 N' y8 c, O* ?6 F
  ) i6 S6 u* F  D/ C7 B: e
• 
  
  ) O0 M" R9 ~. X. O$ I5 T     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  
• 
  - g" m0 P9 ?  w& Q7 ~' i0 Z
    o7 M" }4 t0 B3 B/ m3 [( {     ready=p;  
  + I* C! ]# ?4 q' |1 p% `
  0 W& O' h4 S, I5 r7 \; b' e
• 
  
        }  
  7 v: Q/ T1 u, V1 G2 m, i9 s9 s
  7 y# q3 R! [1 m" l
• 
  
     }  
  1 ^+ j8 S% ?) y0 E. ~3 k2 k
  
• 
  ( c! i/ ?' d! i9 X5 P7 M( J
     printf("          优先数算法输出信息:\n");  
  - L2 v& j: V* v- H' P$ Z. e
  4 C. L5 o1 ?. }6 {
• 
  * B* ^. }; m  T" w" I6 z5 D
  $ B* C. N+ i+ C$ f( \   printf("************************************************\n");  
  # X% H/ x! }, L' h
  
• 
  7 _5 T* a- b, ~4 q6 ^
     prt(alg);  /*输出进程PCB信息*/  
  
  , g4 v: q+ B! e$ [5 f7 q# @  J% i
• 
  
  & ^, |" \- _/ ^" ^9 R1 U/ N8 I* [; z' r4 I" M   run=ready; /*将就绪队列的第一个进程投入运行*/  
  - U, h0 ^/ a- v  H' u
  ! S$ i/ K& c3 t! s
• 
  
  0 W2 `6 G& M* ]  K- |/ V   ready=ready->next;  
  & ?0 W1 i" C  W7 L
  
• 
  . G: s& Z* a' T* ^; X: i
  $ P: Z/ F# H6 k1 @: J   run->state='R';  
  - r8 z1 f% w" v6 w3 a6 y. |  ~2 J
  
• 
  7 Q" ]/ Q+ t4 Z8 D' W
  # W, [$ G8 f* ^* g/ k' E}  
  ) O/ {9 R* q. K4 \8 ?
  
• 
  5 ?9 ~  [( @- ]
  9 Y5 v; Y* Y2 H, v* I! Y/*优先数调度算法*/  
  
  ( B$ o* N+ D1 `8 s) i9 A
• 
  
  1 L9 }# h$ ~! {; y0 M9 r; k( E% wpriority(char alg)  
  & N# x! \( a. u8 s: n5 s0 o
  
• 
  
  {  
  
  
• 
  % R& n6 o3 h1 [% o& R5 r& b6 x1 S
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  % ~$ g6 ~6 A# t; S
• 
    w" W0 \! w, Q8 o: z& I
     {  
  * P4 e! S" W% c5 D  d
  
• 
  , ~/ T5 |0 \+ _% K8 k
  + w# O9 y( Q2 W  f2 \      run->cputime=run->cputime+1;  
  
  6 l! u9 }2 h8 w/ p- x7 n5 @: E4 `
• 
  * D: P& I7 q$ W/ m; @. y2 `
  $ A0 j0 u" c, e( ^  \' h! A! f3 i8 d      run->needtime=run->needtime-1;  
  
  
• 
  1 b; C$ M; I& N, n7 W6 S
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  
• 
  ' K5 G' ]* ~$ _! s5 n
        PCB *p;
  
  
• 
  1 {- j6 S$ [0 t9 H
        p=ready;
  
  ) x; ~5 N1 ]! k/ Q
• 
  : k! c1 B3 R5 {2 [4 d
        while(p!=NULL)  
  + c  f3 x  M- F
  # K5 {( @& \; {! t. x# f
• 
  
  8 t- F3 q6 S& G      {  
  
  1 r( {6 S$ `! Z  U% {
• 
  ! k) \$ x/ ?2 o" u! f4 s; u( o% p
  7 j; |( v  H8 B1 m% g( p          p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  
• 
  + F8 w, {/ c4 g0 r# H
            p=p->next;  
  
  
• 
  ! T( T. z4 E8 r5 {
        }  
  / b0 D4 g# ~7 ?7 w" t7 |$ p
  1 q2 V, v) t3 x' k/ }
• 
  
  0 z5 y! J* w- P* \: E9 e      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  , b2 i2 _: ~" s# y: u
• 
  $ X+ R1 K7 f5 f4 ~6 R# R; n
  % {( f( N( b1 a& t      {  
  
  
• 
  
  $ z) L9 n* [; j$ y( T$ z/ B; W$ H         run->next=finish;  
  + `! B! P- S, W5 h8 l1 d9 u0 O
  
• 
  % D6 H( A% W/ H0 y: U: r+ e
           finish=run;  
  . d$ K) N) I7 A% I- O$ n
  
• 
  
  # {. z: K8 q1 t6 F, a2 |* B% Q         run->state='F';  /*置状态为完成态*/  
  9 F. e# H; U) w+ F, g
  
• 
  
  5 b3 A$ _' U5 t9 P7 n         run=NULL;  /*运行队列头指针为空*/  
  
  
• 
  , Q: l' K0 x3 l, o
  " E) T5 J2 M) `         if(ready!=NULL) /*如就绪队列不空*/
  
  
• 
  
           {  
  3 a! a% \1 y3 p" G! m5 I) P3 g
  
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
    K( t2 u5 ^, }
  ' j) a% u* N8 @! T0 ^+ |9 i
• 
  ; ^2 P! \4 A% C4 K) U+ C
           }
  
  
• 
  
        }  
  / o; e: l' u% s/ V+ p
  # H0 _0 s8 S% Q
• 
  
  " F, X$ ~& E4 U0 q7 s% P* ^- D      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  6 d6 B1 _. K3 p
  9 ^8 Z7 N# r5 k8 B4 @1 X8 R7 K
• 
    _) @) G3 n7 w
  3 R- K. @" @5 c7 z2 v8 i     if((ready!=NULL)&&(run->prio<ready->prio))  
    r) X; z: x! D2 m+ n/ x9 t0 V
  9 @! s6 b" u. m( S7 s, @
• 
  6 y/ ?8 _* q4 C& E8 C4 k; r
       {  
  
  ! m2 e8 |+ O7 P& }& R' M5 f- C
• 
  
          run->state='W';  
  
  , f" h% n  k% I3 K# J+ C  ?# \
• 
  
  8 _- E- p8 g7 ^4 D  |- H        insert1(run);  
  
  5 d6 e4 H; t* H$ T$ o
• 
  8 U" Q& v0 t$ ^. P
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  ) l) h4 J  b( w
  
• 
  
  : h% g$ K( ^) t- a$ l- h$ q& `     }  
  - u0 k# T1 i7 b* r, t3 O
  4 z* Y) S: E/ p! V$ [( G2 p
• 
  
  ' B2 {4 g9 C/ H9 t; {- n+ b      prt(alg); /*输出进程PCB信息*/  
  5 t. e* ]& x1 q1 _/ \) P
  - @# ~( E7 e3 ]( y' a% x4 Q
• 
  ; a5 b8 Y6 D1 n) f' x5 r* ]) n+ `
  % }3 s7 Y5 w8 ]5 p9 h6 z0 m   }  
  & C% K, b9 I. [/ i5 g
  
• 
  
  }  
  " q* M5 C1 g4 A& H& v
  # m8 [+ k! @! d/ s( M% k
• 
  
  /*主函数*/  
  / W  Z* `" S8 z5 U; \
  4 W* Q( j  E) I" m' W/ i
• 
  
  % o- Y* X. d& C" bmain()  
  
  2 ^1 O! h9 x' t' s
• 
  . w6 S' L; h  H" s
  7 J! F9 W8 {# h, _, Z7 H{  
  
  
• 
  " Y4 Y2 d1 V$ {( N0 N; g) G
     char algo;  /*算法标记*/  
  
  
• 
  
  # N( m% i$ s  S7 }9 i   printf("输入P确定算法：优先数算法\n");  
  1 T' d2 x8 l: h( C: j) j6 H
  , ?- {6 u: j7 N2 m
• 
  
     scanf("%c",&algo); /*输入字符确定算法*/  
  - W0 v( R: Z# a% O, Q$ A1 g
  
• 
  
  $ B; J9 r# s! ~& w   printf("输入进程数：\n");  
  2 R; _) i4 ~, _: G
  * A+ X5 w, g0 e, Q6 t4 E1 C1 M
• 
  
     scanf("%d",&N); /*输入进程数*/  
  
  - ]% ]( M- l8 V$ B, [
• 
  
  # s5 a4 N$ x( r  D   if(algo=='P'||algo=='p')  
  
  0 L7 Z/ c( h2 S/ g' i6 B% }  h. X
• 
  
  ; w' H# C) q$ j4 ]- u* w3 e$ E& X1 c   {  
  
  ' N7 _$ Z' M% h) ~0 a+ x
• 
  
  $ q( F7 j; J$ C2 O4 o: E      create(algo); /*优先数法*/  
  - t6 @: j- ^  t( X; R
  6 V4 P2 F. G3 M
• 
  
  2 ~- `. w0 t  i. ]/ q7 d* z3 T1 B      priority(algo);  
  / \! l0 I1 F0 }
  / g) i& y1 z; s7 Q, R7 m. Q" U
• 
  
  1 x2 L$ b) r" U6 k# t, p/ E- q/ d  }   }
  
  ) w7 n# S1 P" Q- x( n, A
• 
  4 p( h2 I8 ^" l! e/ R' X
  ! M1 r; m8 ~" H4 `1 F}
  
  
  

输出结果：
5 @! m( h; E7 q

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