优先级调度算法

杨利霞

, E1 p) K: c) n7 X) i优先级调度算法

算法介绍
) G- Q# V! Q' ^- z$ `* X- y优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
! Q! w7 j1 `* J6 l/ ~2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
# a8 y0 M7 V2 m5 }1）静态优先权
" M' T0 r7 `  \- [2 t静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权

算法实现

抢占式动态优先权：

. B1 C( W' V+ W$ u: hPS：本人认为非抢占式静态优先权没有实际价值。

• 
  
  3 t2 d9 f1 G# t# L  @$ h  T9 {#include <stdio.h>
  
  # O, _+ N+ x% u' q- x2 R# J  t6 Q
• 
  2 E# u5 u) Y/ v- u
  . M/ Q& {+ N& h% S& s% z  K; r#include <stdlib.h>  
  % M# v: F2 c+ p5 q6 F9 C2 n
  % M$ d+ @9 y9 r* _
• 
  
  #include <string.h>  
  5 p4 {# T2 _8 m5 k7 \, I  u
  
• 
  
  ) j1 w/ p' p, {& ^* E: L0 Ftypedef struct node  
  
  : h- L) s' Y3 e
• 
  
  {  
  ; m0 ~& u" }/ h
  
• 
  
     char name[10];  /*进程标识符*/  
  
  7 V6 y: n$ B' _6 T3 D' f+ D
• 
  
     int prio;   /*进程优先数*/  
  
  & T" ~& I+ O$ w1 j5 m6 p# O
• 
  + o) L4 K" S4 a2 I6 f6 |
  ) g+ C$ y  d5 N3 {) P& B   int round;  /*进程时间轮转时间片*/  
  
  
• 
  7 E+ k  A2 t3 p5 S6 j5 l( b2 [4 t4 L
  2 Z1 a4 l; R3 k+ ?* J: [4 Z9 j+ A" m   int cputime; /*进程占用CPU时间*/  
  
  
• 
  ; B1 d4 U) v6 v1 x+ _5 ^+ Y
  ; \! ^' t% Q; ?+ J   int needtime; /*进程到完成还要的时间*/  
  
  $ Z% u* _& F2 K1 Z2 z$ `5 J
• 
  
  ( ~8 Y8 B. x4 d   int count;  /*计数器*/  
  9 S6 S+ U. ]2 |( ?) V
  
• 
  
     char state; /*进程的状态*/  
  8 T; k- p, |& Q5 p1 a* x6 ^5 r0 v
  
• 
  $ A) c  \5 v7 s& u8 I. t4 C! q. U, T
  ! x. J( a! ]; x# d1 c# ~  C   struct node *next; /*链指针*/  
  2 ~& m  p$ d2 @; p4 f/ K. |
  7 b+ j" T/ E/ j% C+ m0 k: t, j2 T- [
• 
  # ^2 j7 P0 ?( t( O7 v2 v
  }PCB;  
  
  
• 
  ' K: c" o9 n  f# ^, ]
  2 l- O+ x: n: k( B' TPCB *finish,*ready,*tail,*run; /*队列指针*/  
    L5 H: d) H) ?2 Q- w5 j' i
  * f6 t/ u: X2 b$ j% e+ `+ k& B% R$ k
• 
  
  int N; /*进程数*/  
  
  
• 
  / l, P$ s3 J3 ?( m: E4 W% J+ i
  $ O0 V+ b6 w/ z. v/*将就绪队列中的第一个进程投入运行*/  
  
  
• 
  3 ~) }) ?' N4 ]6 ^1 w
  % g6 `: l4 V1 s/ U2 A& Ifirstin()  
  
  
• 
  ( |$ a  x. ~2 L
  {  
  
  
• 
  0 Z* N! x: Y5 K/ J" h9 U( I
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  4 T' u8 H: ]! s4 e, ^, b+ v
  * B( T+ [6 x! J
• 
  
  7 `( k# U; l- x) C- z   run->state='R';   /*进程状态变为运行态*/  
  
  
• 
  
  9 w& y+ m# G: U0 L* V1 o   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  * U% u5 I7 u$ H5 ~. V' ^/ P
  
• 
  
  7 I  M3 ]) {% c7 d& `9 c}  
  
  
• 
  ) [( l+ W5 ^) O/ t
  4 p2 Z) z1 w6 R2 N5 V9 \/*标题输出函数*/  
  $ B# \9 Q# f* ~6 [: B8 I4 z
  
• 
  
  void prt1(char a)  
  
  
• 
  + t6 r$ s0 n1 W8 {" V' R
  {  
  3 i' _+ O# |9 b- H8 t$ f, c6 S
  
• 
  8 L  ~4 j! \( q6 J5 k/ ^
  & T# l6 _# [7 G( `+ a# C4 T$ ^   if(toupper(a)=='P') /*优先数法*/  
  
  
• 
  & V1 [% E; Y. e7 R& D* M  y) j
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  ) B. R1 K% [2 z
• 
  
  + Q0 c- B/ m  @2 p, D   else  
  
  
• 
  5 A1 O0 F7 j% {2 O
  - t# J' n* x0 S3 g) \5 P& L" B      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  2 g( p! S$ u; P( [5 Y
• 
  . F' V9 e  i( |- ~. ]6 K
  4 C# W+ W8 {# y9 `! q}  
  0 u0 [) |. W; \; U6 }( y& x) @8 W4 N
  
• 
  5 t+ H" [( X( h0 K, i: t
  & v2 o& o) b& g$ H/*进程PCB输出*/  
  
  3 G, ^5 L1 g; k7 s
• 
  ; n4 b+ V( F: R2 ?2 w
  7 @' a: h+ X) E( U  m6 r  n$ l; Mvoid prt2(char a,PCB *q)  
  
  
• 
  
  {  
  4 e( X3 @+ ^5 i" k
  . X7 H/ m' ~2 M4 ?6 ]6 M4 z  Y
• 
  
  * \* D: [9 Q  M   if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  
• 
  
         q->cputime,q->needtime,q->prio,q->state);  
  
  
• 
  
     else/*轮转法的输出*/  
  
  1 W2 X) f9 G" ~- U* |8 o
• 
  , N4 x/ w: l( G$ X$ k, V
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  9 z" i/ M+ @( w# N; O* X
  & N) @# i9 S! G0 n( J       q->cputime,q->needtime,q->count,q->round,q->state);  
  
  . O9 A9 r2 a4 ]( d
• 
  
  }  
  
  
• 
  
  & J6 c7 c: s+ R( a- c/*输出函数*/  
  4 I5 `. ]- ?( Q' a$ [; T! }' `: ?- @
  
• 
  
  ' E3 n/ `- k* |+ v) Qvoid prt(char algo)  
  8 \8 f) i# ?8 P$ T* R1 k0 u
  1 j. l* C1 }! Q5 R7 c6 c0 K
• 
  0 d" B+ p/ a3 \1 s
  , I! [3 H5 Y. C0 K7 R  {{  
  6 C) _7 P' K: e0 h. l" t7 s- }# U
  6 O4 s6 E3 R7 h- \. z3 w
• 
  
     PCB *p;  
  & |: i$ q' @9 L% e1 x
  
• 
  
     prt1(algo);  /*输出标题*/  
  4 {  C" b! A" A( D
  & k0 x$ D6 f  q$ Y0 D
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  ) a/ O$ q: A9 i, {2 A1 K$ ]
  1 H, N5 T& w5 e' g
• 
  ' k6 g) K; B0 R3 d
  $ @7 Y0 ~! d, r, ~      prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  # s' a/ {; V( S7 {: ?9 o8 u: V: M0 T6 r
• 
  + Q) A# r1 b# U6 r
  ! C3 t, [, G7 b; d# T   p=ready;  /*输出就绪队列PCB*/  
  
  
• 
  : L0 U  }+ v: c) W* Q0 V* m
  5 e7 e- x7 K) z/ O$ u/ ?   while(p!=NULL)  
    W$ m' g" S& J, t' z
  
• 
  
     {  
  
  
• 
  7 I7 p5 s9 z8 o; M# u
  + d* o2 X+ z& ^/ {: M      prt2(algo,p);  
  
  / F  x6 N% e$ r3 t
• 
  
        p=p->next;  
  6 a/ x7 V, e: o$ [8 H, }& G
  , @! z9 r& {9 Q: n$ v
• 
  8 W' b8 P  ~' y! X$ W5 [
     }  
  
  
• 
  5 h2 ^6 e# a; F" [
  $ B$ B0 m# M$ [0 f  Z   p=finish;  /*输出完成队列的PCB*/  
  6 |0 k- S* X! }% a! F3 Z
  
• 
  
  / n9 p- X4 h; `; {* [/ Q, c   while(p!=NULL)  
  / m+ t1 m# Q' D6 L
  
• 
  ( A1 {+ U" w$ I- w
  4 V  u5 G/ z  c   {  
  + p3 [7 H; w& C* V! Z% R! ~4 F
    _- U. P5 w2 Y
• 
  3 ?8 ?( v2 ]5 Z) x& L
  - z" t2 W7 o8 u+ {; d      prt2(algo,p);  
  2 T. h" M' z# O$ |! B! r( x
  
• 
  ; ], I- t) J4 j& F% C& U  L4 Y' C
        p=p->next;  
  
  + e8 J8 ^" K! O( e# U9 `
• 
  
     }  
  / P4 {- J  j$ B( T" K* N. O- G
  6 u+ l  J5 Q" O0 S$ t: v
• 
  * G2 Y0 a4 G* W% P2 V6 N1 [
     getchar();  /*压任意键继续*/  
  
  ( A- J( S# p; ]. l
• 
  
  6 Q0 ?; n# h( o% E4 g/ r# X}  
  
  4 d: S& w) \! @/ N1 p& x3 O
• 
  
  /*优先数的插入算法*/  
  ( z/ d0 _7 T& f& k% f
  8 D; e3 C) t( z: K( {3 Y
• 
  0 w$ H: I+ V) {* A  `
  insert1(PCB *q)  
  ' Z/ Q2 s, P5 n
  
• 
  
  {  
  
  ' {8 O1 {3 [) \4 D
• 
  8 K7 |# O7 o% l# p/ A8 T" C
  * a# S. D6 ?$ U8 s   PCB *p1,*s,*r;  
  
  ( t/ M0 Z! C" i
• 
  
     int b;  
  
  
• 
  ! r% {2 i. F# k$ ^0 |9 f2 b$ r
     s=q;  /*待插入的PCB指针*/  
  
  # j+ k+ M, ~! y" Y
• 
  
  1 O0 e. c/ O) G  ~5 k   p1=ready; /*就绪队列头指针*/  
  
  
• 
  
     r=p1; /*r做p1的前驱指针*/  
  5 p* c7 Z4 \/ U! \6 }: Q9 V0 n* y9 q
  $ g" [* O7 |$ @
• 
  
     b=1;  
  * j1 r) u" H- q' l8 J" Y+ t
  
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  
• 
  ( h5 V! P$ k& J" \* Q" v  a
        if(p1->prio>=s->prio)  
  ) E# V7 l" f% P0 J4 T9 {
  
• 
  
        {  
  
  
• 
  
  ' o6 I& e, S9 u" T; K! Y     r=p1;  
  
  
• 
  
       p1=p1->next;  
  
  
• 
  - k2 V' h- A- Q5 ]  l, W* d
        }  
  % Z8 C9 U2 ^; M) K# i  S# z; ]
  
• 
  , ]4 n9 |! j/ I8 P- I
        else  
  
  8 ]* f) I7 E# Z
• 
  0 }+ X+ l6 B3 L' F
       b=0;  
  
  
• 
  & H- C* K1 S+ U2 K8 t9 |
  0 A/ L/ s2 {' H1 Y- N   if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  ' y7 E/ _" F2 W, p2 F( R
  % z: V$ K7 b) x$ [# h
• 
  ) b( M: Y1 v- o
     {  
  
  ; }+ [1 Q. j: m0 X# q! y3 t+ h
• 
  
  8 G; Z" f0 {/ P      r->next=s;  
  5 d/ H- [7 k" h2 h8 `* j1 W1 O. s3 T
  " p9 ^7 k: f/ _
• 
  
        s->next=p1;  
  
  
• 
  
     }  
  
  & P# k( c/ y6 [  N: Z! b1 e( d
• 
  4 E; M# ?+ L- y/ [
     else  
  
  : d# J# Q" H8 x4 j
• 
  9 |% e* a2 U8 \: b1 C3 V
  ! A; {' [1 ?" A( w" p   {  
  3 L5 j% Y) J: m# ~! H- O
  - A  m$ z$ n8 X, d
• 
  
        s->next=p1;  /*否则插入在就绪队列的头*/  
  . W5 n$ [8 O5 m6 d
    \* {* v& a6 ^- j6 B* V. P
• 
  9 i0 z! h6 V/ K6 ?1 f9 z
  & X1 j: b6 w2 }5 [      ready=s;  
  
  , [4 S( A( }5 k$ v* y$ f* y7 e
• 
  
  ) |; E3 w, O5 t" Y( r- K   }  
  
  
• 
  
  }  
  2 x; K: G% B7 R3 D( E% ~2 d1 X5 k$ ~
  $ j  s; w: k. V2 G& q1 z
• 
  ! _4 M6 Z! z4 u1 i* j9 O; R
  /*优先数创建初始PCB信息*/  
  $ X( c7 I- V! W, x, U8 \" G
  ( _" n! ~$ ]) k* g
• 
  + a' ?$ t+ e  N
  " u9 k5 y; u' v6 Cvoid create(char alg)  
  % @) \5 z7 ]- k6 S8 }9 D
  8 }- z9 A& q/ }  ]* m  i3 v  C
• 
  
  * Y/ K) E/ W' F2 u6 C{  
  
  0 R: j( u+ r- ^+ J$ Z
• 
  / {. j- P/ t2 _# |/ I0 u9 a
     PCB *p;  
  
  2 b$ z( q! q9 m: D8 t
• 
  ! W6 B0 d6 A5 J) d( t
  $ O' f, Q9 r. ?. \; }% o+ |   int i,time;  
  
  , x8 W, }* ]9 _# x% P$ |. A2 v
• 
  
     char na[10];  
  . h' ~# y6 g$ `1 K
  
• 
  
  : f/ j# N. F) o7 b& l  j4 C) I0 Y   ready=NULL; /*就绪队列头指针*/  
  ( e* R$ X* L  p/ Q* f0 d) {6 @
  , D4 X7 v  g0 d  V2 s
• 
  
     finish=NULL;  /*完成队列头指针*/  
  * \$ r) W* K1 c5 p
  7 y$ ^; F7 c$ C* T( R9 U
• 
  
  5 A, u. x6 z  \+ t1 _7 M5 k   run=NULL; /*运行队列指针*/  
  
  9 G# G' \  {6 p
• 
  . g) Y- H* r; D" d
  8 O1 q" U% V( m* y( g1 w   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  . P; U* h& K. J
• 
  % b* U' _% Q1 D# z8 I
  + ^! D0 q6 v9 i+ G& R# a5 S# y   for(i=1;i<=N;i++)  
  & \( J8 i% |: M4 x  V! f' I3 O
  6 [8 _  j( V  H% `
• 
  
  ; d5 Z& @) r5 r, {" m   {  
  
    c5 U  z8 ^4 s) ^! M5 L
• 
  
        p=(PCB *)malloc(sizeof(PCB));  
  
  
• 
  
        scanf("%s",na);  
  5 I1 T4 w) A3 B! s% d2 i
  ! Z9 F. ^! @0 I3 l# t6 ^  i
• 
  
  # V2 U9 z% q# X9 z0 V2 L7 [4 {% p      scanf("%d",&time);  
  6 B# U2 j7 W7 y2 C
  
• 
  
        strcpy(p->name,na);  
  
  
• 
  
        p->cputime=0;  
  
  
• 
  ' G6 O% J" i9 k  X
  . y+ w( d- J+ {% O5 ]      p->needtime=time;  
  
  
• 
  
        p->state='w';  
  
  % @8 y/ L+ t5 c  g( I- ~, `
• 
  $ ^) z# B: `! b3 K8 ]$ h$ \% F, W
  3 h' h, [. i3 n3 ~      p->prio=50-time;  
  
  9 h. h5 D! p) ^, i# r
• 
  / [) w' C! D$ J$ v
  & T' g3 G8 \; r7 M2 x! p. W. l2 J" F7 R      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  / g/ h# [2 H1 S5 q
  
• 
  * h7 o. o. l; d6 [/ s7 O; B
  4 _$ h/ F" u% P3 S; p0 j& l     insert1(p);  
  
  
• 
  
        else  
  $ t  x, F, _0 H
  0 G7 K, P3 e1 s7 ]/ X; d0 `( P' @( m
• 
  0 d. T" k6 y; ?6 Q$ z8 [% O
        {  
  1 S# o1 m0 Y1 t  B4 y8 ]  w
  : H" E" Y( ^( j* d, g
• 
  $ ^1 H1 ]5 L$ U! {' Q1 }% T
  3 F5 y$ \: ~, @8 j' ~     p->next=ready; /*创建就绪队列的第一个PCB*/  
  , O: l* D! t, `5 Q9 g
  ; K- f, Q9 L. p
• 
  4 @. ]) _, m+ V
       ready=p;  
  4 ~# u7 v( k1 n5 Q  {& c
  / x: E/ `/ N& ~
• 
  8 P7 Q' p1 m+ V3 n, U9 b( s" I  q) R- Q
        }  
  : S- l0 k5 G6 h3 s1 Z8 A, H5 D. q
  + d* @2 R( R$ ?5 _
• 
  * F/ R) ]3 x$ K! I0 j( P7 a& ~
     }  
  
  , _3 H/ k2 B  k: j
• 
  
     printf("          优先数算法输出信息:\n");  
  
  
• 
  5 H' o6 S; ~% H- {' q/ k* I% v
  # V9 [! |7 X4 C0 ?  {   printf("************************************************\n");  
  8 b) [3 s* Q$ K9 B7 Q
  
• 
  5 s, O& O6 a; \! B! w# w: X/ R
     prt(alg);  /*输出进程PCB信息*/  
  
  # h! U$ ^' @1 g- o5 s0 Q2 q1 c
• 
  ) R1 T' _" v& `, d( p; x
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  . b* ?/ P8 ]! D6 d! X& I
  8 q. [( c- b6 X& C! D( [3 \4 I
• 
  
     ready=ready->next;  
  9 w6 {, D# R! @, |
  # E; q  q5 o( l4 O2 T6 b( w% |+ g$ i
• 
  
     run->state='R';  
    N6 \0 U* M  i9 t4 A
  
• 
  
  % T6 ]6 t2 H6 C) B( b8 {}  
  # H9 {, q$ @2 P$ i
  
• 
  5 o1 Y. }: x" b7 T5 [9 S
  ( I- a  d. C7 r  Z9 ~/*优先数调度算法*/  
  7 w, H/ {. h9 j9 D
  
• 
  / P; z) V& J6 C  ~9 {
  priority(char alg)  
  7 \* Z/ D& g1 L% |: }
  
• 
  
  {  
  
  
• 
  
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  2 R  q. L4 x0 O" b, d+ E
• 
  
     {  
  . E3 [9 @/ ]( H$ q- ?2 j1 _# U* z
  
• 
  
  / h$ o# j# g/ _5 y) _" `; X      run->cputime=run->cputime+1;  
  ) n' H( i& E6 V: ]0 X; N
  . f  n7 c+ B5 t1 [. h6 w
• 
  
  % N8 @2 v9 {  A+ L) k6 y      run->needtime=run->needtime-1;  
  ! g, e! ?8 c* p6 Q+ b/ }7 R$ E
  
• 
  
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  
• 
  0 O. I! l( V+ r
        PCB *p;
  2 [, Q5 h/ ^, f7 A$ p3 `
  
• 
  
  7 H* v( j# M9 A1 y2 ~8 z      p=ready;
  " h" p/ Y4 P* C" X( W, O- B8 C
  
• 
  
        while(p!=NULL)  
  ) @  _0 T/ _1 x- V/ T* z
  
• 
  + B) M! t8 p2 T2 ?- Y' k
        {  
  ; l5 Z, Q9 c  H
  
• 
  ! ~* A( m; i' s: V& U5 V) U
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  ' T* r; Z, x1 f3 j8 v1 z* e
  
• 
  
            p=p->next;  
  + @6 |3 B" j/ C" U8 d- P4 s$ Z2 W9 T; q
  
• 
  
        }  
  1 J8 h3 {2 @- c$ s- Z8 J
  
• 
  ( |. [8 y* [: N- Y: j% B
  & ]8 j* F7 k0 {0 l% x8 g; Q" }1 W# [      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  5 ~4 M- C& j! z, L
  
• 
  
  9 t, N9 a  I( e$ V2 o      {  
  
  
• 
  
           run->next=finish;  
  ( J) z& C1 a! ^; F) l. d5 g
  % U. e/ B3 N7 t/ c* S9 H& a; Y
• 
  4 u3 j8 ^2 E. e) k
           finish=run;  
  
  
• 
  
  , [# K* K/ B8 \# h         run->state='F';  /*置状态为完成态*/  
  1 S3 p# @) U) [/ X( p4 V$ M* n
  
• 
  $ N# t$ D" T+ O7 i4 W/ t
  & @' m/ X- x$ G+ P4 e5 I         run=NULL;  /*运行队列头指针为空*/  
  ( x" C9 Y$ Y7 C* X) B0 n! g/ i- s
  
• 
  
           if(ready!=NULL) /*如就绪队列不空*/
  9 ]3 p4 S. c4 M2 D$ K( U
  ' N$ P! e! w1 g6 N
• 
  4 B5 {/ q% {) c0 O3 c& b5 X
  5 y- v7 _$ V' N4 g         {  
  
  
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  9 i+ }" @# V0 O9 [/ P
  9 }  S5 W% v/ }( g- y/ }
• 
  
  5 ]! s8 A5 H" k0 T2 f         }
  6 W1 M0 H5 _9 l
  
• 
  ! \: ~% F* |& D9 j; w
        }  
  
  4 T" F* ]& E3 P) T: Q( f7 {
• 
  
  . Y& T0 O3 G' j+ C" {6 j+ Q' Q2 N      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  / n# j* Y$ N# n5 ?6 U! }* u
  
• 
  ( z- l8 X% b* a3 |9 F5 @" a
       if((ready!=NULL)&&(run->prio<ready->prio))  
  
  " c8 P) |  b9 e
• 
  
       {  
  # O+ ]* u; F* G1 j) i+ \
  
• 
  % m& i2 o1 ?- w  V$ y( W
          run->state='W';  
  
  
• 
  # N) \. C2 q9 H# q8 N
  6 v2 I' J! q5 u1 N        insert1(run);  
  0 T2 h4 }, K) N* N- {. k. b2 [
  
• 
  
  % A9 o' x; K8 s% ~& G; r9 ~        firstin(); /*将就绪队列的第一个进程投入运行*/  
  4 V( K6 t4 a2 H
  5 p$ @& O. x' K' ?- p  L+ x. h
• 
  9 a! Y4 x* o- b7 w5 y' b: M2 f' S
       }  
  " ]- }1 n/ \7 [7 a8 s
  8 g9 E* k0 b( G2 p4 ?$ L2 N- M- h
• 
  
  9 s& v0 v& ], E" b' \& ~      prt(alg); /*输出进程PCB信息*/  
  8 Y8 U0 G: Z7 o/ G
  & j6 m) O) ]  ?/ A1 h- v+ u
• 
  1 o2 B" P, D6 H3 c
  # f6 p9 y( a' Y3 l& \2 z   }  
  5 A& ?. _# e% O( H# h7 C9 O8 a4 j
  
• 
  5 g* ^+ o' H' @# @- B
  $ W# C# F% O2 O5 I2 C}  
  6 R/ Q  {/ r+ j  W* I
  
• 
  % J, C8 u! y. \4 O
  /*主函数*/  
  
  " d0 K  X7 g7 |" Q4 ]
• 
  ) ?! Y% r9 N7 L* \" k
  % Y& }. H7 F  E( |# k9 ^8 omain()  
  
  
• 
  : R( B6 l* x) C- h: Z
  {  
  
  % s! o) K5 _+ _* M4 i3 [) Q; z
• 
  
  & c0 e6 F' H( }9 b6 C   char algo;  /*算法标记*/  
  
  
• 
    z) x# ]' a) D* Q& {+ @8 S* T
     printf("输入P确定算法：优先数算法\n");  
  
  
• 
  ' ^0 S8 ?5 H' q. E9 {0 B. `
  8 h1 M8 M( B! r7 w) {# U1 ~1 a: u   scanf("%c",&algo); /*输入字符确定算法*/  
  0 a0 E; h  k9 P% a2 z8 P; M
  8 V' s8 l& R: N; f3 w& m
• 
  
  8 j1 w- R/ z( w- k+ n/ x/ Z1 G/ s   printf("输入进程数：\n");  
  
  
• 
  / |4 V& j/ G+ k4 _2 {
  2 y+ D& j( {7 ?   scanf("%d",&N); /*输入进程数*/  
  % \" ^; A4 z4 w( z
  + x: b$ X9 U- y
• 
  
     if(algo=='P'||algo=='p')  
  
  4 L3 `, e' U- [8 w# `
• 
  . q7 h/ M6 D: M
     {  
  % W; d; ?; b! m5 `7 O3 }
  
• 
  1 n# {) K6 i- t. @0 _9 [
        create(algo); /*优先数法*/  
  $ F) H7 K3 [! C! X" E
  
• 
  
        priority(algo);  
  
  
• 
  4 c$ @0 I# v7 @
  ! K$ `- V  W5 E5 v; ~   }
  
  - X6 R" E) m3 |" {5 H
• 
  
  # e/ i  f! ?* N1 U% o8 J}
  ) e' G% r! P6 _9 `
  / I" K! D& o- P5 d6 W7 n0 _
  

+ J- H9 {; ~0 s: k/ y; D输出结果：
2 [$ {( y; J+ T. o

8 o" K! _. j" }原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

% V3 B( Y% F3 S! ]
( d4 E4 L" T3 ?) }$ P6 F! I' R