优先级调度算法

杨利霞

% B( W: {5 r2 `) h! E+ T2 S7 \" M% m优先级调度算法
5 ]! J! n( L0 d. B0 ]

算法介绍
) J; s( Q' S1 i优先调度算法的类型（用于作业调度）
: s: M4 B4 f$ x/ B# c, v1）非抢占式优先权调度算法
* }. N4 N5 P, |  [3 X系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
2 m+ Z, f/ \0 J8 M- k7 [只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
$ [3 F2 a6 w6 r# [' l: J1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
. }& m: S8 ]; u3 L) S

2）动态优先权

算法实现

抢占式动态优先权：

. j1 h% _, g# D5 P4 ]" rPS：本人认为非抢占式静态优先权没有实际价值。

• 
  
  ; i( J+ h# D7 O. v% T. L1 |#include <stdio.h>
  
  
• 
  3 Z4 l' c/ D" o3 r
  #include <stdlib.h>  
  
  7 \' u- s4 i6 ^0 j( Z
• 
  . p$ R5 b$ T6 R4 H, H. z
  4 Z) B3 c% C/ x4 J8 f! }  G#include <string.h>  
  
  
• 
  ) x* ?$ N! F- Y- k
  typedef struct node  
  
  $ ]; N( J0 [4 g) L
• 
  : E! J5 R& r* x/ @9 P. Z
  6 E/ [' N' \+ H$ g; T3 M{  
  
    z+ k% W& D6 U3 D
• 
  
     char name[10];  /*进程标识符*/  
  
  + i7 G( c7 [  }! }6 n& \
• 
  . h8 C- r' S# E" ?
  3 u5 A8 @, l3 V& z/ X( z   int prio;   /*进程优先数*/  
  
  
• 
  # A7 B) O0 H( o+ p- C
     int round;  /*进程时间轮转时间片*/  
  
  
• 
  
     int cputime; /*进程占用CPU时间*/  
  
  
• 
  . h( P# `( n9 D7 Z% e# H2 w
     int needtime; /*进程到完成还要的时间*/  
  $ N5 ~5 Q5 E4 U- K: m! W! w- o
  - z, V. Z5 X" a5 Q
• 
  
     int count;  /*计数器*/  
  
  
• 
  
  : ]: _+ o. y! g' V/ m   char state; /*进程的状态*/  
  & D! g& {0 w% ^/ r; e& W' y4 V# p
  & X: F& a( F( {& Y
• 
  
  9 }) `/ J4 I5 \* `# B   struct node *next; /*链指针*/  
  
  
• 
  
  }PCB;  
  
  6 K: p; ~! h8 P0 X
• 
  3 K. U7 I( M6 o8 N5 J* |
  # T/ M/ B% l0 b5 R- s, s6 c0 }9 QPCB *finish,*ready,*tail,*run; /*队列指针*/  
  6 D. F& P- a. k
  0 Y" W2 w: G% t) f1 |
• 
  : q* ]# L8 _9 L# b
  - f7 K' t# k6 i; {int N; /*进程数*/  
  4 \3 I. r, K$ a: ~  `
  
• 
  2 z8 D* g2 o7 w
  + R6 t: O9 L9 S1 u- n7 h" y/*将就绪队列中的第一个进程投入运行*/  
  & {) T7 {9 ?7 G! A3 v# B
  / I! t3 c9 B# K" g" |9 ?
• 
  
  4 K0 l- O  C6 D2 ]firstin()  
  ) Q' i" m) D) K; t; i: O
  
• 
  
  9 B/ {- M/ w; F' E) F5 l{  
  $ I/ k* m- d4 F, u, k9 x
  
• 
  
  ' S  z4 i  l2 G( Z   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  9 S9 x/ s1 M1 d$ K7 i) b
• 
  ) R/ ~+ y' Q9 x3 x( A% j+ v
     run->state='R';   /*进程状态变为运行态*/  
  + t7 {( K+ ^' ?1 t+ O
  
• 
  7 w, j) B, h+ G# j/ b
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  
• 
  
  3 K$ b5 q# E; N}  
  - n3 I. x: x2 X  ]
  
• 
  
  /*标题输出函数*/  
  
  
• 
  8 r" E2 p1 C* l! `" f# A
  void prt1(char a)  
  
  ' p7 E2 }; C# [( }- x- U( u  A0 a" R
• 
  
  , t) W8 B1 ]( @5 Y, J1 X{  
  
  * P# D4 Q, P8 k  T. h3 O. y
• 
  
     if(toupper(a)=='P') /*优先数法*/  
  4 Z! @/ h- O2 n
  ; `* S/ c& e# y4 i6 E5 r* s
• 
  0 j) e; b3 j! l. Q* F) b
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  0 d3 h8 M7 C" o  I) Q
  - H! l9 R% P& h5 b   else  
  
  
• 
  
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  
• 
  
  0 U: {. Z, M; T5 l! N}  
  9 @% t" @4 c% g' _! T! f' @8 D2 i: k
  
• 
  . G6 C+ \0 _; P$ A2 f$ {
  /*进程PCB输出*/  
  
  
• 
  7 Q! J1 X1 g  J+ I+ i& d7 O' R8 J
  void prt2(char a,PCB *q)  
  2 {8 E/ r& J5 g1 I& k' n
  
• 
  & E4 c% |$ J7 C: B3 X
  6 X1 e- }' `5 H# z: h$ y) n{  
  & Y  V0 Z& b* b, l
  ; k( [  }5 B" C+ ?
• 
  
  0 T) x# H4 W4 K1 Q6 W  t" I3 j   if(toupper(a)=='P')  /*优先数法的输出*/  
  1 w- m, M2 _! e- F7 E
  
• 
  
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  - Z) I7 f& m, o! u  b
  
• 
    V) ^; T: {$ W( l( k& z
         q->cputime,q->needtime,q->prio,q->state);  
  
  
• 
  
  ; {' C- F2 ~7 t4 o, r   else/*轮转法的输出*/  
  
  
• 
  ! z4 O0 v) a1 S( Y/ }* n
  1 p2 S  [7 v5 R/ M, h4 ^  B      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  
  / n# _1 u4 ~& c( [; v3 O3 X       q->cputime,q->needtime,q->count,q->round,q->state);  
  6 L4 |( F" H! ^& s* `2 ?
  5 N: S* g( z& h( G$ C
• 
  & h6 O3 O8 Q  @2 h
  " x. D, t6 z" p0 t& W. S- r}  
  " Y! d9 ]! H( E) c6 I, s0 Z' G
  " `! z: a. a& Y5 r' @
• 
  8 P7 G; m& h1 l& o
  6 B2 F! @: T6 i7 j9 X/*输出函数*/  
    e# @( r2 j4 i6 I0 P
  0 `& C( \4 X8 c2 G2 E  s
• 
  ! f9 E6 U0 {5 R7 A0 |" `
  % g0 Y( S4 ~, u9 t2 |& l% bvoid prt(char algo)  
  2 e- }! F/ U3 O: n4 Q
  
• 
  4 H- v3 p0 j3 n- a: s
  {  
  - t* N+ Q" d/ ~% x, A+ s3 r+ L& X7 y
  7 D" @" l5 r5 o  [# R: L/ R
• 
  ! M' ]/ ]5 K/ P8 ]& s
  6 n; A$ [* z( N% ?   PCB *p;  
  
    H+ f9 l) ]8 m9 Q) ^' h6 Z/ v
• 
  
     prt1(algo);  /*输出标题*/  
  : B% k! \) ?! M# d9 Z
  
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  $ n$ u/ T- N* x5 j  c4 r7 H
  % k1 _0 k% n4 P3 I
• 
  
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  
• 
  
     p=ready;  /*输出就绪队列PCB*/  
  
  
• 
  
     while(p!=NULL)  
  
  - s7 }. x" f3 ?1 Y# i
• 
  
  $ P9 ?3 G: m5 q, j' f2 u7 u7 l6 P   {  
  
  8 t9 Q, |  K; F9 x
• 
  6 R" C' }5 j0 C/ o3 }# V" t
  " E( y5 Y' N4 W! K4 m) H2 g8 J      prt2(algo,p);  
  4 ?4 H7 d3 h% I: y0 G% v5 I
  
• 
  % B" w$ j- V+ A" L  v
  0 Q& r( k* |8 s% p4 q      p=p->next;  
  ' ?& D2 a& W1 n( v; {" @6 G" x3 X- e
  
• 
  ( m4 B4 g$ p1 j$ ~, o* I; b
  # n: c( h$ Z% r2 n4 I   }  
  ( O" m' v' t  d2 R8 B5 }5 ^
  
• 
  
     p=finish;  /*输出完成队列的PCB*/  
  
  
• 
  1 `* X8 |3 ~* s* J. r: w: `( F
  , ~7 {& R# a  U; z   while(p!=NULL)  
  5 N- j) D, P6 j- A( F5 H6 O. B
  
• 
  - k0 @, B$ H: e. z! ]) M
  - w2 X0 i: [4 H: |3 [$ g& j   {  
  9 b+ p) L* q6 d  P' k; G
  
• 
  ) T3 Y3 X; M+ r$ Y
        prt2(algo,p);  
  6 m/ ~, `: W. @, u4 z+ c
  
• 
  $ R& r' H6 @+ U! g$ U2 g
  " [0 X/ P+ k* H( t, \6 @2 ^      p=p->next;  
  
  
• 
  
     }  
  
  6 m" W7 h+ E% Y6 x
• 
  ( V9 c" s* I9 `& J
     getchar();  /*压任意键继续*/  
  
  
• 
  
  }  
  
  
• 
  
  % R: d, q  x* d% c/*优先数的插入算法*/  
  / ~) M9 `6 v8 D) w
  9 W0 w0 u* s: X
• 
  + N/ v$ Q# X. D2 Q9 N1 x
  insert1(PCB *q)  
  $ ^( O, X6 [, ?! W: \9 D, @
  & g5 \0 R1 t9 T# {
• 
  
  7 c" z, i6 l) u4 b# O$ O0 r{  
  
  
• 
  ' M+ n  ~% M! W: l
  " K7 |* n/ I7 \5 q5 T, F; i4 B   PCB *p1,*s,*r;  
  ' ~* Q/ t$ a& k, d0 w
  
• 
  
  . ~1 s+ u# C5 q5 p' m' C; \   int b;  
  $ ?$ d& p1 ]' ]$ Q" w
  , \* d, F6 Z; c2 @4 m. U$ ?# K: k
• 
  
     s=q;  /*待插入的PCB指针*/  
  
  5 S) Q6 E, L& o! |5 Q5 a+ w1 A
• 
  9 V4 n5 V1 ~0 Q& m
     p1=ready; /*就绪队列头指针*/  
  / E5 N' ^* x" I
  
• 
  1 J0 H9 @  L$ v) m
  / f# ]( Z. W) D   r=p1; /*r做p1的前驱指针*/  
  
  . R- F7 v0 Q; Z2 S
• 
  0 S1 [' w  ^$ L- R& @" |
     b=1;  
  3 {2 e( c3 D' [/ M( G6 y
  4 k3 I; m  _7 R5 f; E4 R; u
• 
  ) _1 @, G' R# k, }! L( l
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  
• 
  
  5 I7 y. u) e# p' ?( i/ R      if(p1->prio>=s->prio)  
  7 C5 O  @$ j* a1 O( u; f* F
  
• 
  
        {  
  0 r: D- G! H8 N: \! ~' q  r
  
• 
  2 @! u$ h3 p* b& n) C. E4 U
       r=p1;  
  
  
• 
  : @, M4 U: f  Y2 l; @8 B2 x) h
       p1=p1->next;  
  4 t, w% Y" |& W
    l  ?2 v, P2 q9 h4 F+ S& J
• 
  2 A8 h: h1 B4 b0 F
  2 R0 e2 x. H6 ]      }  
    l0 b# b1 P" d7 D) }% n7 [) t- @
    g0 b# W& c& c2 f; N' w- L
• 
  
        else  
  
  
• 
  
  $ B. A5 V; |. M, f, t& J! m     b=0;  
  
  
• 
  8 E8 S* Y* p: e5 C' M
  1 `' K( s+ S  P4 B   if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  ! W% m' _' k/ r$ C8 i- F
  1 T( P4 ]% i7 J' O3 @9 A/ z   {  
  
  7 Q: v' N: j0 Z2 B& ~1 Q
• 
  
        r->next=s;  
  
  5 f% G' |$ k5 L# V+ u
• 
  5 s7 \% E  d# j, p( a- |. P
  9 ^$ f9 V% }7 M& V- m      s->next=p1;  
  ' p( e0 ?+ Y+ T/ f! k9 T3 q, C9 g0 g7 Z
  
• 
  
  5 ^  g0 r8 a5 R3 [! `   }  
  ; q2 h  j* e9 q
  
• 
  
     else  
  
  & [! z0 K4 L+ T3 y, Z& |- s
• 
  
  . X( p( z  t; s7 V, J, Q+ T   {  
  2 d" v& G0 G: j# M+ k& ~: s: [
  
• 
  
  & M# u  x, S4 _3 a2 e1 g      s->next=p1;  /*否则插入在就绪队列的头*/  
    w; P9 S* n- z: g+ @
  ' i! f( J/ Q9 ]$ Q
• 
  
        ready=s;  
  
  
• 
  $ D% e4 M( x' \& W. f3 T
     }  
  
  
• 
  
  6 l6 T4 C5 M  |( G" w" S8 m' @% e}  
  
  ; [* q& @1 h$ c9 P; `, ^7 X8 d4 W: T
• 
  , M0 d. v( l, Y  \$ _# k" Q
  /*优先数创建初始PCB信息*/  
  . M( Q) e. b1 z4 X- m
  : |( c. i4 S/ c$ \( \$ ?
• 
  
  void create(char alg)  
  ; k  E. t) F( b1 `# ]5 `
  / s* r: U* a2 e# C  Y/ w
• 
  ; Z- U. j4 l( e4 h. w
  9 |8 H7 s( P; {7 o* p: q{  
  
  : h2 ^3 W7 J% M
• 
  + _4 ^6 F% Y% H0 U  H6 e) a& G
  . `$ ~+ c7 u" o( K: Q* {   PCB *p;  
  
  : k$ P- m9 J4 ?; Y% j: V
• 
  
     int i,time;  
  
  
• 
  # K5 H1 A0 J, }6 g9 F
     char na[10];  
  . P5 \5 C  m4 g0 A
  
• 
  7 ~" k. c( H( ~5 t6 G
     ready=NULL; /*就绪队列头指针*/  
  ; Y1 K. u) B' L9 N. u- Z7 m$ W5 @
  
• 
  6 i. R5 N/ g0 V7 K
  ! }! d: }* ^: j! L7 M! ~) V   finish=NULL;  /*完成队列头指针*/  
  
  
• 
  ! g" X1 ?( Z1 ?: z5 D
  & a; A% q, `* z+ B# A- k5 Q5 B   run=NULL; /*运行队列指针*/  
  ) ]$ @5 z! a# F8 [( o, ~$ y3 H" K
  / Z( Y/ t9 T$ b: r
• 
  
  8 C6 x# O# y$ L" z# Q  s   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  , F* ], _- M6 m4 f/ ]# w4 M; k
  
• 
  
  ! }" I. Y+ w. t: I( m+ M   for(i=1;i<=N;i++)  
  ( M! e  Q& a& M
  % I6 R# E6 \6 R/ u4 ?. |. f6 |
• 
  , m# p7 C$ F, U$ l% v* h  J( l
     {  
  
  
• 
  . V6 o: U& ]4 `
  ! s/ v8 ]) ]3 [3 {3 D# C% b% }      p=(PCB *)malloc(sizeof(PCB));  
  
  6 p: ^" P% j, }, h4 x1 m8 p. e7 n
• 
  
        scanf("%s",na);  
  + ~! ?" W1 h- {( s: Y
  
• 
  : K  w1 |8 [2 k+ C/ Z, c& a
        scanf("%d",&time);  
  
  : i+ Q& W0 m, y4 J
• 
  8 `  C' K6 q) ~. X
  " _8 d( J7 G0 ]) h; T7 ?9 X3 a      strcpy(p->name,na);  
  ) X/ g* |9 B" r/ H- l
  - z/ u8 _1 I4 c8 p0 G+ q5 @8 r& r
• 
  
        p->cputime=0;  
  
  
• 
  
        p->needtime=time;  
  * H% _: c3 l! w' e. W6 N, H4 ]: [
  
• 
  / N  C- |- s- b+ I
        p->state='w';  
  : Z4 k: m; q$ \6 R( ^
  ! c$ o+ z; m  \" f
• 
  / g3 s7 o) j5 y1 U2 w
        p->prio=50-time;  
  & o5 ~# \3 r+ N  j: {
  1 @% K  w3 a- R' j( y
• 
  ) \. k7 k! @2 C" R9 ^# c1 T9 c
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
    M4 v6 t7 ]6 x& Z3 C* d
• 
  
  : M3 S% {8 I* K7 w     insert1(p);  
  
  
• 
  ' @. R" ^: G1 z# f
  8 Q' u5 t& c+ O6 n6 k6 c( w      else  
  9 z3 e# [$ P5 s
  2 }7 k, c" x' x" |) G$ j' T
• 
  ) s, P8 r" R$ a* ?7 h  b2 d# W: t
        {  
  
  
• 
  . _9 G/ ?7 N2 B) N
       p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  
• 
  
       ready=p;  
  
  
• 
  1 b" J9 ~8 i5 \9 `
  ( b- f* a2 d7 Y# B; r      }  
  
  
• 
  
  ; Q* Q" t. w# ]" H; _' o4 z   }  
  , E4 ]' F9 d. y5 o, e+ ^
  
• 
  
     printf("          优先数算法输出信息:\n");  
  
  
• 
  # c* }: V0 q  I4 f. f
  " H; t' {4 R- Z0 N  Q7 @   printf("************************************************\n");  
  
  , S" _7 A, R: X; O" y8 E) k7 {. I& X
• 
  
  0 [1 z; G/ m) K8 P- t( p+ G. n   prt(alg);  /*输出进程PCB信息*/  
  2 ]: }7 O3 v) V  f4 l1 X$ Y2 i
  
• 
    s" c& @9 b: a! b
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  # a" c9 n7 A; ~) {! I+ ?
• 
  - g' Q" V% A# P1 ~3 |3 Y6 d. o
     ready=ready->next;  
  & N7 j( r5 }7 W% h$ I1 N
  
• 
  5 `  Z# J, K! ^( u0 K: T
  ! M, n8 Y' P( d, \7 L   run->state='R';  
  
  
• 
  
  : A: Q* `1 _; B( Y9 A% D0 a}  
  , R6 w1 e# `  Z& k, S6 m$ f
    R  n: H1 z$ f6 }0 c
• 
  : j& V4 ?: g" B
  /*优先数调度算法*/  
  $ e3 C! ~' K; h- S( X* ?4 e! i
  + @/ m8 J/ @2 F; Q( M
• 
  
  priority(char alg)  
  
  0 x2 ]8 A( i; s+ J
• 
  
  8 J: ~7 e' Z) V& G3 W; A{  
  9 s2 V6 I( w5 P- `  m. R
  / H. N6 x* N1 F% I: k
• 
  
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  
• 
  
     {  
  ' ~, s- h  k% N1 [& f  T# V- p: `
  
• 
  
        run->cputime=run->cputime+1;  
  
    _. t/ l& h1 s. ~+ d. R
• 
  
  2 o+ ?, d( q; C3 r/ F" g      run->needtime=run->needtime-1;  
  
  6 g7 N: p0 A0 L  j
• 
  
  , f- ^6 i) L. H/ p5 \8 ~, y      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  ' N& X0 g) K' N. G: G8 _
  
• 
  
        PCB *p;
  0 W, p$ b( j- b- C
  
• 
  # x1 q* L! j: v1 v- ^+ ?
  * r& v+ J' r9 J5 _5 e      p=ready;
  
  4 [4 e" W; J; o% R# }# E
• 
  
  8 `* P  G- P3 b0 Q" ]      while(p!=NULL)  
  
  $ g- {: ?. M! _0 v, l" o/ X
• 
  
  ) [2 J) U( H4 h" P6 W% D" o      {  
  + T) O' d7 C% ~: K7 N$ w
  ' U" b& s% K, x" d, g
• 
  / g  t( @* u" }% v% c0 d+ {
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  3 q# W. |: p/ ~) O# ?  ~
  
• 
  
  * f. s' ^+ K* v# h7 j' U          p=p->next;  
  
  0 l9 {7 J8 q8 {$ K
• 
  ) l. `$ K9 x+ Q. {3 v1 `
  - l6 f* t7 ^  n! P. q' o7 Q: u      }  
  
  # V) |1 b  r( b1 |4 e0 ]! e+ A) W
• 
  
  4 ^' c+ m2 e( I9 m# j* G      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  6 O+ L: ]( d3 R# D- N3 h
• 
  
  5 G3 t; ^! k  u$ r" V      {  
  
  
• 
  8 r( n* g9 ]3 t( m8 v
           run->next=finish;  
  % x5 E) i2 i7 g- F+ h
  
• 
  ; \' C. L: b& I$ m
           finish=run;  
  8 U* e7 ?& ~( m3 m. i
  
• 
  9 c0 R% F/ M! B5 e
           run->state='F';  /*置状态为完成态*/  
  ' h7 Y4 |0 {' l5 C1 L6 x4 U
  
• 
  
           run=NULL;  /*运行队列头指针为空*/  
  
  
• 
  0 m) F( ]" ?% @* w
  # f4 I, `% r3 ?% P9 C& _. R$ K         if(ready!=NULL) /*如就绪队列不空*/
  
  % k& G: [6 h+ h: x  k4 ~3 ^8 x; g
• 
  
  # T/ S( r) E8 e5 g( |& E! Q8 l         {  
  
  4 z# D5 Z& C( a
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  
• 
  : C1 ]* N- w; M3 B. B2 o* X
  6 D, M$ t- `& n+ m8 J  v1 k         }
  - i) _2 y# X2 x8 c2 t6 \4 l
  / c) k: {) Y7 L) h4 h
• 
  
  % p: ?1 h! l5 I# s) C. ?% r# u      }  
  ! p7 d2 N3 n# T* k
  ) S7 @7 t( n% p2 H4 }2 [
• 
  ! }( D9 c2 Q" v# q4 z
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  9 c# K' L; s# ?
       if((ready!=NULL)&&(run->prio<ready->prio))  
  9 C8 F0 B" P% D9 m3 T) C" P
  
• 
  / L- I% ^% n7 @& {
       {  
  . i1 S/ ?7 t/ P6 [/ O
  
• 
  
  6 J0 J) @% I1 z3 p' S- v        run->state='W';  
  ' \8 F; \- c! t) c' o( I- n/ A8 Q
  
• 
  
          insert1(run);  
  6 v: C& H: w& N! e+ @7 w
  
• 
  + Q9 b/ F3 f" G/ E! ~" E# i
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  1 m) b) R! G- T/ A" t3 {* r
• 
  
  0 ]" ~  A: ]/ F9 h     }  
  5 M5 L7 s" P4 k, d! ^( \
    |* L, V& b! z  F1 J' S
• 
  9 X2 F' E0 }) P! q) `1 r5 E
  + b1 a  W- I0 ^7 D) p0 Y6 ]      prt(alg); /*输出进程PCB信息*/  
  3 Q2 w1 e" K4 E+ E& V8 v
  
• 
  # Q2 O- R1 v7 t% G" E
  9 c0 b: u; Y- H/ O1 \% M/ C6 P   }  
  + l6 P8 ]/ @0 r' j- ~5 g7 R* k
  + P  ^9 r2 Q7 a0 q* p
• 
  
  }  
  ( m- K6 v: R" s( @* M3 p
  9 ]! t- Y" M, n' g
• 
  8 X) v; K  B* u5 E% i1 N% s+ ~, b
  /*主函数*/  
  8 `" h+ f6 x$ N5 r- G
  7 H( e; \* W5 l) @4 x
• 
  % D5 m! h- g$ D' R" V8 J) Z# u
  $ V% i) v2 ]' u' M7 x+ V( cmain()  
  ) e# G! n0 V$ X, j
  , y0 u: a# a& k  @5 t$ C7 ~
• 
  
  {  
  
  0 a1 Y, I1 n0 q- Q0 e
• 
  
  ( e9 _1 i' J. h" ^4 V  |   char algo;  /*算法标记*/  
  
  
• 
  
  * {- m( y1 a$ O; u/ H- A" d  R   printf("输入P确定算法：优先数算法\n");  
  ' M" X8 z0 O0 y1 g$ I" \
  
• 
  
  5 P! Z/ Z( w0 O+ L   scanf("%c",&algo); /*输入字符确定算法*/  
  
  
• 
  
     printf("输入进程数：\n");  
  
  * y6 v! ]: ?! I: b( M# X! i: R, ?
• 
  1 |& R# s! g: `+ j2 N% p6 N6 Y# n
  ( ]+ Z# N; g: @, ~   scanf("%d",&N); /*输入进程数*/  
  
  9 e7 `  z- n* |' T; ~; ]+ Y
• 
  
  ) `" @5 h' |  ^+ }; ^, J' l   if(algo=='P'||algo=='p')  
  ! E7 x; C) B5 \8 G
  
• 
  ; E  }% w$ n! j) a8 I; Z$ F
  / B  U9 {$ T* C6 {* p   {  
  ) }# B8 t  l5 i  X2 a
  
• 
  5 _3 F% i6 c; `
  . \& q, s% W. d$ s9 J1 F% @      create(algo); /*优先数法*/  
  
  ; c8 ?- _# |; R# o+ f, i
• 
  + \( o- ^% ^# E3 _
        priority(algo);  
  
  ( @' `  w: ^! O
• 
  8 i8 [# C, X; W  r- C
     }
  ! D1 U3 A6 Q6 i% o
  3 V5 r) j  B( d4 o" L
• 
  3 ~: r  G6 z" o4 Y3 [
  * H+ I+ N! T8 c$ Q1 }4 E+ d$ J}
  / j/ V  f4 K: e3 O( [
  
  - Q- C& a  K9 _

) T9 N- W  W9 N* N& K; g* i, d输出结果：
' ?3 Q" U  I+ I5 V

" d& }* A# d& S) _! |. y# E2 |$ r原文：https://blog.csdn.net/weixin_40962955/article/details/80072769