优先级调度算法

杨利霞

) t( i: X) E9 i; I, v' a优先级调度算法

算法介绍
) O, F! n: H2 I. y/ u! _/ P! I优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
6 S: ]5 `0 ]+ M4 W% i1 w6 I  F2）抢占式优先权调度算法
8 S; p; {( K, y. s- A2 D只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
8 Y' z5 ~, T0 d$ \% M; v1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权

算法实现

抢占式动态优先权：

$ Z4 W) ?" r) d! XPS：本人认为非抢占式静态优先权没有实际价值。

• 
  
  ! X4 O$ l9 f. l6 T6 Y1 D+ l4 C#include <stdio.h>
  6 ]( R' V% B4 G6 |" N% v. z" q
  
• 
  
  #include <stdlib.h>  
  
  / ~6 p) C7 v1 H7 g* I
• 
  + {; p2 c2 M! l2 v8 A  Z. s' \5 J
  #include <string.h>  
  
  & p3 P( x# q% A2 H% H! ^
• 
  
  typedef struct node  
  
  $ R! u2 Y; C/ ?9 \
• 
  
  & l6 x( E6 p; z9 ^. W{  
    G6 w: K0 A, W/ [2 T
  
• 
  4 _- V/ T: e" j; R. h& w
     char name[10];  /*进程标识符*/  
  
  
• 
  ; |7 t3 W8 r( B7 {* u- S
  0 M; O- |* l6 o  w$ g' G9 N   int prio;   /*进程优先数*/  
  
  
• 
  # t5 p) l( J* z
  2 V% J+ O& q7 N( N# a   int round;  /*进程时间轮转时间片*/  
  ( P( }  z; U( K$ M, H' b: u( o6 z: a
  - [7 y) R3 q: R/ ]" {3 B5 H6 I
• 
  : J$ b! Z' J% n+ _% |% e# L2 Q+ c9 a
     int cputime; /*进程占用CPU时间*/  
  
  
• 
  
  5 |& s$ g( @- g) Q  K+ w  [   int needtime; /*进程到完成还要的时间*/  
    Y* ~* o& {) E; H7 F2 m6 H
  
• 
  
  ; W9 v: k9 c4 b, J( g! @! W. P   int count;  /*计数器*/  
  3 s% ?8 o& R" I
  ( t: w$ B  Q3 U! a. E; q) ~2 N7 k
• 
  - H% e( I/ @7 a' c5 h, C
  4 q; n+ b9 w9 n. V- f% E4 U   char state; /*进程的状态*/  
  
  7 V# H3 h5 b8 U0 \0 s2 R4 ~) u
• 
  
  * D0 i* s% d: i) _# f+ t) B8 N   struct node *next; /*链指针*/  
  " [7 {/ x. o8 h* X4 T
  - r# i. \+ s6 R2 d9 W7 L. Y
• 
  9 ?: n: l0 ^" z* l: ?
  $ K7 `/ J2 o+ Y: _2 S* W}PCB;  
  . o( a0 c/ |& s" e" V8 a) j
  
• 
  
  . W- A$ F: _3 W) i; P- v( dPCB *finish,*ready,*tail,*run; /*队列指针*/  
    j# Q  \7 ^+ S/ [; H, I6 t
  * z0 M' n6 }0 h7 D/ D: N* f/ n
• 
  
  & p( X9 S, _: i1 Fint N; /*进程数*/  
  " O  A0 s' \# T$ b+ M+ ~! L
  
• 
  0 l, y! `1 U; f: U* |# W
  /*将就绪队列中的第一个进程投入运行*/  
  
  
• 
  
  3 m7 D. `6 i, ofirstin()  
  
  + x* x$ X  v) s, |  ]
• 
  : U2 U& \3 n  W
  9 {1 ]2 C) f3 A3 j! {{  
  
  ) }: t# E+ M% A; s
• 
  
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  ! U7 q9 P1 L. T% L  E- R
  
• 
  ; {% A8 ?, F2 G0 Z
     run->state='R';   /*进程状态变为运行态*/  
  9 G  u5 h  b1 _; L/ J5 m
  7 X- f& O; e* C0 G
• 
  
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  3 t# L' Z. ]1 M
  # Y+ [/ X; D, e
• 
  
  2 j1 f2 ~* Q: h}  
  ( \0 x2 U" u" i2 G  }# z- x
  ( c3 L/ b1 T& d0 a
• 
  
  1 L  x- E0 O, J% y/*标题输出函数*/  
  
  
• 
  , s* [3 x. p5 ?2 y
  void prt1(char a)  
    C4 a4 \# d% b! f: b  ?% y" i
  
• 
  
  {  
  3 G6 S& n  x! P7 U, a8 j6 h
  
• 
  , U: X& P. u8 r9 Q
     if(toupper(a)=='P') /*优先数法*/  
  
  
• 
  
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  ( I1 W; c. a7 e, C% S3 X) J& B0 I
  ' u% b2 s% f; u. b4 y# E% I( m3 j& ?   else  
  ! i  U5 r5 e0 `6 h5 N
  ) A0 p$ ~9 _$ X# m( E0 s& k5 p
• 
  
  7 ]# ]2 g) M1 Y8 U  [/ n5 c3 w, j      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  $ e. Z1 Z/ d- l& W
  6 Q5 x% A3 c7 Y) N1 A
• 
  
  }  
  5 s. `% k( c% o% B9 M/ L/ [* ^
  - M# M% D. @4 t& H  e( ^( C, o- n
• 
  
  /*进程PCB输出*/  
  4 @# ^4 R+ Z) k7 y
  
• 
  , p" C* N+ |; X: O
  void prt2(char a,PCB *q)  
  
  4 P7 @$ Q) V- I' h
• 
  " s3 m1 k  _/ t$ a1 H7 p* ~
  6 l+ R1 }3 A; X. R: T% x6 s{  
  
  * p, P' [" I9 S% b4 ]: x5 y
• 
  
     if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  , |0 Y" @% ~+ s2 {
  : Q. k- g2 G! H      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  7 m# @7 i/ Q4 W5 i2 e
• 
  
  1 J/ L! m+ k' A( z; X3 p" G       q->cputime,q->needtime,q->prio,q->state);  
  ) K8 B4 [/ M# g2 W5 a" N9 e
  + Y  i- T  r& P9 F  P
• 
  
  0 H, H, J$ [& |4 j. W7 H   else/*轮转法的输出*/  
  
  ! [4 r8 j/ Q6 O+ N4 a7 |8 a, z
• 
  4 {+ Y. N( f' x6 M9 D
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  % K' g8 D( [2 p6 t* B; `$ u
  % y5 ^0 j- Q7 U! D4 U1 |2 X
• 
  8 V: S* v. z5 s, X6 m4 I
         q->cputime,q->needtime,q->count,q->round,q->state);  
  ; ^- E. h3 @5 x, X- I
  
• 
  % Z4 a/ T) \+ [5 a) \
  }  
  
  
• 
  9 z; I0 r( \: }6 X( M
  / P% C: _1 l7 l8 }/*输出函数*/  
  
  - s% S) G% x! C: j( ~1 j2 |" S& I
• 
  5 f2 ?) ]0 m3 Z5 X5 t" |
  % r5 ?+ A; i& k. X# p8 Gvoid prt(char algo)  
  
  
• 
  4 ]5 g7 c8 ?) N5 l! J0 X# H
  . |( `1 G9 P2 c4 J9 u& H{  
  
  
• 
  
     PCB *p;  
  
  
• 
  
     prt1(algo);  /*输出标题*/  
  3 Y3 F+ l7 Y7 u/ i* V
  1 S; C( G6 Z4 W6 u
• 
  
  , p' _4 D7 L7 @4 a' r* O   if(run!=NULL) /*如果运行指针不空*/  
  1 p4 H. |- @$ x& {# a
  
• 
  . ^1 s  Q7 d' k0 }
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  * {' O9 x9 C* C7 J2 J/ h
  4 o5 U1 K0 b+ N! w- m5 M
• 
  
  0 L2 u; k1 I$ V( F4 ?, B9 p   p=ready;  /*输出就绪队列PCB*/  
  
  
• 
  
     while(p!=NULL)  
  * y: P: G8 S/ N! O
  - A6 H0 U* w# A: _* a) q; v
• 
  , P- K4 H+ Q5 q( v2 J
  - p8 k$ n; R) f3 b# G1 \  U& ^   {  
  : Z0 F: {8 M) w' b. b) W
  ) j& U4 B( B2 V. q. {5 S" @# e
• 
  2 z) Z( C3 F3 G& E
  7 w% B9 d' q) H      prt2(algo,p);  
  
  
• 
  
        p=p->next;  
  2 P8 [$ s, ^( I: [
  # u7 b" {0 [6 \& d5 A
• 
  6 f6 c/ \. z: f# N0 G
     }  
  
  
• 
  
  4 `7 d- R9 C% E7 t' w7 b   p=finish;  /*输出完成队列的PCB*/  
  % j5 H- O, a: `% m0 D  u7 A
  8 K; v; |# Y4 H2 T0 L2 Y1 n, _
• 
  
  . M7 h5 J" f3 _  p" q& }   while(p!=NULL)  
  
  
• 
  
     {  
  / p3 C3 C1 Z, M) [* {* a4 X
  / a' c! Z' S! v: \' d
• 
  
        prt2(algo,p);  
  9 c4 e% l5 q8 M" D# e% L' `) R
  4 N( B4 |* ^. p) j. q5 J
• 
  
  4 J$ ^- V' z0 ~6 W9 T; X      p=p->next;  
  
  
• 
  $ ]/ m# l+ \  p7 f3 o4 y
  5 |9 P0 x) K  {, X6 m+ I3 ^   }  
  9 y0 {' {, Y+ @: r
  , X; H; p# p$ h5 }
• 
  ( j3 G: `5 T" J! `, D
  ' r! i5 g( |2 m! Z   getchar();  /*压任意键继续*/  
  # c3 _! z- [  B9 [' D4 H+ {
  
• 
  
  }  
  + `' P7 n( u7 F- U
  
• 
  
  /*优先数的插入算法*/  
  
  + ?! N' ?8 a% O4 j( o( k
• 
  
  ! ~% J" M0 W4 j! X$ |insert1(PCB *q)  
  
    Q% o1 o* M6 E! p6 h5 e5 U
• 
  0 W) ^: U9 G* Y- a3 a6 B$ E
  {  
  
  
• 
  . w  l' u" |; u4 _* d9 ]( m
  ( G6 b, H3 F4 j( R: V0 T6 {   PCB *p1,*s,*r;  
  
  / R3 c$ N0 k& Y
• 
  9 f" n$ c, ]; p& l; S: ^
     int b;  
  
  
• 
  
     s=q;  /*待插入的PCB指针*/  
  
  
• 
  - A# t0 M. Z7 O4 I- R
     p1=ready; /*就绪队列头指针*/  
  4 A. ?! [8 M" w" b4 w. X
  0 l7 S& _# d+ K! H! }$ @1 G
• 
  5 S0 v% L0 A0 l: b9 X! _2 O* B3 B* Q5 z
  , @3 ^) }& Q! r   r=p1; /*r做p1的前驱指针*/  
  ! {2 x) r& @+ |2 D+ e4 y2 q
  - w6 f7 [: q1 C. l6 {9 U
• 
  5 i' L! V0 j* A. b2 C! a. J: I
     b=1;  
  
  7 Z3 Z  N( `6 N! }
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  
• 
  
  8 |  `3 ]7 d& @' V  ^# `      if(p1->prio>=s->prio)  
  6 Z; G+ T7 Y/ Z+ A: X
  9 q3 ]. K1 n: c- i( Z: w5 U
• 
  
  * h1 Q8 T, m; V0 y- P      {  
  
  
• 
  
  ! T' ?3 h! P% J. i4 B7 D% n1 g  M     r=p1;  
  
  ' W5 _0 U, n7 K
• 
  ! Q8 N! q9 k! ?; d4 ^% S
       p1=p1->next;  
  ! e: y, V& B3 Q! \' h
  
• 
  - J+ ?( `& ?/ c
  # Z2 _+ H) T! a& f      }  
  
  + N: n1 E; o0 X, M9 e4 G
• 
  
        else  
  
  
• 
  : B4 S0 J! }' C" N* S& d/ x
  3 z8 ?: v3 @$ |+ U$ F+ b0 C     b=0;  
  
  ; y) Y8 h, I' N. l% N& k
• 
  
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
    D/ P8 p) ^% |( D# H
  ) T5 J7 |' |+ \
• 
  
     {  
  
  
• 
  
        r->next=s;  
  6 H, c/ j5 }' m; k! }" N- T% Q
  4 O7 g7 T' \7 A) {3 |* I# _& o
• 
  
  1 ?" b* U0 y# m1 e2 u" b      s->next=p1;  
  
  
• 
  $ f( G! e! }6 ~
     }  
  0 l/ a; f' Y8 E* B8 A
  & N) Y& d9 F2 z
• 
  
  0 p( d! i: m( m( P  m   else  
  
  
• 
  ' _& \" s0 @. C2 C- n5 b
     {  
  
  
• 
  
  + V$ X% @! \0 a5 @0 i8 Z      s->next=p1;  /*否则插入在就绪队列的头*/  
  
  
• 
  
        ready=s;  
  , k" g7 x  L# l) Q& U
  
• 
  
  ) d: c1 {9 c, }! @; ~   }  
  
  
• 
  
  9 J$ a) l) b; p, |/ [4 ?( Q}  
  ) o2 q7 u  M2 A- ~7 s6 J
  
• 
  2 o2 k! B' G$ g9 x& K& S8 a; ~- Z
  + a5 c9 ^- h% |; l9 W3 x. G/*优先数创建初始PCB信息*/  
  
  6 n0 s, Z: F0 T2 i/ u
• 
  
  void create(char alg)  
  % \+ ~" m, c" T. O
  ) j( V0 g) ^1 e" {
• 
  
  {  
  
  2 e. K3 W/ s7 Y7 }/ B
• 
  ! q6 f1 q  Y. a: ?9 @# v5 N1 E
  9 c5 h& ?& b7 c   PCB *p;  
  " g4 r2 X+ ~' }. V- t3 l  Z9 I  j
  
• 
  # E# c7 R, ~; B* ]
     int i,time;  
  " S; k- s9 Q1 ]$ u3 k0 @
  
• 
  
    E/ u' [" J1 C1 R7 L' C   char na[10];  
  
  & J. q" Y- O" c- X7 i9 W3 e
• 
  3 k4 D, P! i% {8 a5 o) f
  8 r  [+ v3 p7 @  @. \* L   ready=NULL; /*就绪队列头指针*/  
  
  * Q, z) B" O6 Y# t3 C
• 
  
     finish=NULL;  /*完成队列头指针*/  
  : x* y- j( y( k0 l
  
• 
  ) S$ ~* M9 q/ P" q9 ]2 z$ w
     run=NULL; /*运行队列指针*/  
  
  
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  5 ?8 O8 ]( K' M; H% B" c
• 
  
     for(i=1;i<=N;i++)  
  
  , \& b* c5 O! o- z" e& j$ z
• 
  ! R8 O' `& P' l$ O) D
  1 O( K; o  `. d1 E! @& T6 y. X   {  
  
  . [' ?0 |( f. |* Y8 Y8 V7 b7 f
• 
  
        p=(PCB *)malloc(sizeof(PCB));  
  
  ! T( S  W) E% e  L% v& \- h
• 
  
  4 k" t# H) F0 f$ }      scanf("%s",na);  
  6 m1 Y( d5 O. y4 M& `( g
  
• 
  
        scanf("%d",&time);  
    O. f7 c* D( j, k. F. |4 `  G
  7 G+ N+ A0 P9 F! {9 D/ o
• 
  ' Q1 W+ |/ o4 H0 t+ T) ^
  ( N- c2 A( q9 D4 ?$ ]      strcpy(p->name,na);  
  
  
• 
  + r' l+ v1 Q- M
  1 N& X1 _" ^& v      p->cputime=0;  
  5 L$ m8 j* \" x% c2 d4 q
  
• 
  ! f( u& C+ _, P* O; Y
        p->needtime=time;  
  
  
• 
  2 `9 H. C: M4 E# s
  0 c* J, J2 f9 O! ]" U' z      p->state='w';  
  % e: [+ X9 B) T: `4 m
  
• 
  
  + a; j0 u- w$ r      p->prio=50-time;  
  
  8 ~7 V$ ^/ j) a* `" Q
• 
  # M) F- h# _6 b
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  
• 
  
       insert1(p);  
  
  ' s1 e  e4 B9 r# }
• 
  : N4 \2 n/ z( s3 W+ |9 j' A  O! {
  4 Y3 l* _; w, M1 q$ Y* R      else  
  0 G1 h# `1 O; c6 `5 H! X
  
• 
  0 w* p6 s% ~" a& e( w( D
  2 G, e. `. N: e; w. R4 e4 L; P. N      {  
  
  
• 
  , f6 T6 Q7 t& M! B$ X
  + k# _$ w1 K* U+ e! d     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
    u7 P* q# ~: ^2 A% `+ A# `
• 
  
  3 f8 j& N3 [; Y& o     ready=p;  
  1 C* q5 I4 u- k/ p$ ^: O- M
  7 p6 c  \3 C$ b( _6 c
• 
  
        }  
  
  
• 
  7 H8 ^! |* {1 c$ }# ^
     }  
  
  # [" @9 Q* a4 S/ N& k
• 
  
     printf("          优先数算法输出信息:\n");  
  
  
• 
  
  9 G; U( {: `! K4 ?" ]5 |) k   printf("************************************************\n");  
  - P/ |+ ~$ D3 b
  5 m" o) N& Q2 u# T8 |
• 
  
  , ?; w5 @1 y  D* T6 U9 _; N   prt(alg);  /*输出进程PCB信息*/  
  
  * h  k( R, A* [# T5 j7 R+ s
• 
  : {. _8 r: e' d" o$ l. Y2 F  h
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  " n* y: D, H6 |8 z; D4 _
  % N# v4 {& k4 m3 e  B9 m! _
• 
  5 v+ x. ]4 ]8 P9 r' H6 A0 l
     ready=ready->next;  
  
  9 I3 C' R; u* z" d/ M
• 
  ) m- N  n& @( w" P. M* Y+ x
  , d# c) y, I9 P& c5 }* Q   run->state='R';  
  
  
• 
  5 l: A4 D9 Y* E( K
  }  
  
  0 ~, ~5 V7 x$ M; D
• 
  
  7 Z% s. K5 D; H/*优先数调度算法*/  
  1 h' P3 f5 a: @- b* K
  
• 
  
  priority(char alg)  
  
    S5 Y+ B+ m& s0 X
• 
  
  # {  t; A8 h) a4 W9 ?{  
  ) n/ c7 G% k( D: b
  & `2 Q2 c2 I( Q; ?. ?) {' c
• 
  4 w$ q4 Y  n  O% j5 z2 c" i; Q  |
  , l5 A' V! B9 L5 |$ `* [) ~   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  
• 
  6 e3 t) {* B6 K
     {  
  
  
• 
  
  2 ^! r: N9 h5 x: U3 g) `$ D* k' O      run->cputime=run->cputime+1;  
  5 d! I6 A- `8 u
  3 F: p% B& @8 u# g0 m4 G7 g  G
• 
  / I* R5 A! r# X6 T1 M" ?5 K% h
  - a9 s+ m9 S1 E) U/ p  A3 w1 x! B1 O      run->needtime=run->needtime-1;  
  ' `) ]* y% l7 G8 [8 F: P" S
  ! T$ i7 t" q7 m0 a  E
• 
  
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  # m- O4 q. O7 s) F6 e* B1 `
  ; t% S1 \9 F! ?: n6 G- M
• 
  
        PCB *p;
  6 T; D2 E/ B6 o6 K! C2 B
  . P% X) f% A0 V/ [3 m7 T
• 
  & |* A( B' @, L) a5 I; G! f( ]
        p=ready;
  
  
• 
  
        while(p!=NULL)  
    z" `  Y  x5 c# A4 Q" Z
  
• 
  
        {  
  
  ' p8 y( Y  Z1 ?5 G  l
• 
  8 d+ |6 _" K+ t5 @
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  ( c, e3 d" z) E- z# _
• 
  
  % }( i8 n+ }5 F0 v6 i! A6 C7 l          p=p->next;  
  
  
• 
  * Q% W" e/ g: I. h( O- [
        }  
  
  
• 
  1 _, Y! g- Q; E: v: F/ e5 o
  . C: I$ G, H2 A1 z6 a4 P4 X- j      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  % D; M" p: I( {
  
• 
  
    q* f* L7 u# g' u      {  
  
  
• 
  
  ! F; Z: ], w7 X2 z3 F' @& Z# V/ h         run->next=finish;  
  ' ^- J( B) |# v: O# d; H6 f' L
  
• 
  + k% n1 f' X- @; j1 C; a
  ) E4 p4 l# P& I0 g2 c         finish=run;  
  
  
• 
  
  ' t! T7 ^7 M" Z- [         run->state='F';  /*置状态为完成态*/  
  
  
• 
  * I2 Q7 a& [# Y  z
           run=NULL;  /*运行队列头指针为空*/  
  # b7 ^+ k5 B! O
  
• 
  
           if(ready!=NULL) /*如就绪队列不空*/
  
  / M- u2 _$ P: _( n0 n/ y
• 
  ! ]5 x3 B! y$ v4 i9 I( {
           {  
  
  
• 
  # B6 S7 _4 G  v
  , p! A0 m! m  z5 Y0 h( w* U  p! e  ?1 t$ C            firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  ! c$ O' L0 m* b# Z2 l
• 
  
           }
  7 \8 I1 ~* f5 i( y  ~
  
• 
  ! t9 t7 U- a8 q# O- ?& \
        }  
  7 ?- s  ]. x% d  v8 p
  
• 
  & t' N) ]  |) c2 ]: C
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  . w5 f8 X0 J( h8 H# M; k8 i% }( B
  + z! ~7 q  `/ O9 ?$ T$ {
• 
  
  % m6 w1 ~/ z& s7 M5 m2 Q     if((ready!=NULL)&&(run->prio<ready->prio))  
  
  , ]# b  m. {$ h* V% y8 i
• 
  
       {  
  
  
• 
  % S- `8 R# N, e4 p0 w
          run->state='W';  
  
  ; W( [4 Y- |- B& r  T3 I# D" F: H
• 
  
  / j- X+ M( C/ Y% r' C+ w- ]        insert1(run);  
  2 t6 a+ U; h7 ^1 k
  ) ^& O0 y, S$ r( B4 L: W
• 
  
  % V+ @1 f, T; V% s        firstin(); /*将就绪队列的第一个进程投入运行*/  
  / X, U+ J; n8 z, _6 f/ l9 v3 J( R
  
• 
  , H, r1 {* a8 q; p5 A
  # C* M8 k/ x$ K7 D1 T  i% v0 A     }  
  9 |- e+ z0 v6 q! O
  
• 
  
        prt(alg); /*输出进程PCB信息*/  
  " D' @5 i  W0 J9 W0 [. l
  6 _. f" a. x3 w
• 
  1 P8 u5 G' K' S3 ^* w$ c1 E
  / K5 v) z7 k+ Q6 M9 d& ?   }  
  
  ! A* n1 q4 D. {$ o9 I5 ?* |; d% i
• 
  , J$ L& E( I8 i6 |# ^* y, U; C
  ) A  ~7 v; D( b) T}  
  ! q1 R7 x* R# p' M' c  J" J
  
• 
  
  /*主函数*/  
  
  9 p) w* y3 O. @( v
• 
  
  9 ?, r# _- N" Amain()  
  3 m5 O" Q- ~6 C3 d2 r
  
• 
  9 c5 E2 g! M- ]' g4 x/ u5 H
  {  
  ' r; z& a7 b7 ?- z, v) {/ H* u# Q6 M
  
• 
  ! F& a* o* M) F! O  C, [
  & @% F! o. V# U( }2 d9 P3 H+ p   char algo;  /*算法标记*/  
  % _4 f- F5 t" R7 O. Y8 z
  " f8 i5 r* R9 m3 w/ i
• 
  
  ( e1 I$ r% M. n" R   printf("输入P确定算法：优先数算法\n");  
  
  & k. n9 S7 [' f4 w, u% Q4 G
• 
  
     scanf("%c",&algo); /*输入字符确定算法*/  
  / \/ x3 W7 i( }+ x% |
  ; T% M1 b* _- K8 h) }8 K& W. C8 o
• 
  7 W1 q1 y5 S6 d1 Z5 K
  " {/ D  J$ R7 \2 y   printf("输入进程数：\n");  
  
  , L& p" p: u8 I- @- D9 L" `
• 
  % {$ \5 A  W& k2 W
     scanf("%d",&N); /*输入进程数*/  
  2 w  t+ C9 N; d5 i
  
• 
    z  B8 ^0 L8 C8 V& j, Y
     if(algo=='P'||algo=='p')  
  ( d* C7 }9 Z$ _* S- [% G
  
• 
  . I. m: `2 g0 N
     {  
  0 C6 c) Y5 j/ T
  : f5 t1 ?& E0 N: f2 z* A9 x
• 
  / o( O+ }+ ^0 j  [$ C; g
  0 z8 Z; r) R0 w" K+ {      create(algo); /*优先数法*/  
  
  * f" r5 S3 D1 K& D
• 
  : ^' E1 `8 L* g
  ( \6 u( J- r$ t- j0 e      priority(algo);  
  
  5 B$ Y2 ^/ ]+ \! W. V6 L5 Y- X+ o/ X
• 
  ' ~( ^# j" m* T+ p7 O$ O
     }
  + C8 N" I# q$ z' }: F. ^2 \8 O( F; K
  
• 
  
  }
  $ B3 ?+ Z9 V% ?9 N0 K) C' t
  
  ( U& w5 @2 D$ S0 d$ s: I- P

输出结果：
9 h7 W0 b5 Y- C: g( x! U

3 K% v4 c; `# N% q原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

" ]' _1 z+ l; a( ~2 ]' T