优先级调度算法

杨利霞

7 S4 g/ b' T! u优先级调度算法
1 T+ B1 L) V' M+ T. I( u

算法介绍
+ |9 M7 ?2 o6 t2 H2 d# p优先调度算法的类型（用于作业调度）
5 K6 C( n+ }" H0 O1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
' |- x7 F- T0 A- j. A只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
: s. `9 X+ C( e+ E! v! p1）静态优先权
) c2 v. I0 F" a( F静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权
. M. i% E$ m0 k: p5 \8 y

算法实现

抢占式动态优先权：

: h( N" O4 n6 L) @( c8 W% tPS：本人认为非抢占式静态优先权没有实际价值。

• 
  2 j( t7 q3 O( P! g
  ; S) L" w4 D0 g2 h, u) b#include <stdio.h>
  2 \) w' X7 J( U# i! Z
  
• 
  ) \- W' P: g0 s8 m; w8 v" U
  #include <stdlib.h>  
  7 t) }2 F, {7 l1 t3 H4 L
  
• 
  
  #include <string.h>  
  0 Y, ?( q# a% l/ W
  " Y" N/ `$ l  `& N' p& X1 c
• 
  2 j. U! i8 g; m  t4 m5 P
  : p. Z& A1 S3 O. X0 ntypedef struct node  
  
  9 T6 F2 }% P  q' ^' H7 x( y
• 
  / n, f) Z9 @1 n1 v7 A$ C8 T
  ( q2 Q' i! y( m5 q; O% x& c{  
  1 B& J+ R+ ]; k$ _# E' f7 U
  " M' \; H. m8 y# I3 z! r
• 
  
    B; a. j/ `& K2 d/ r) g   char name[10];  /*进程标识符*/  
  
  
• 
  7 S9 x- r8 W6 }
  4 {( u7 G3 |0 E$ V& |   int prio;   /*进程优先数*/  
  
  7 a- t% t. C2 d0 ]
• 
  ; W7 a& ]  y2 y0 r/ {4 d
  ; b' C# G& D& Y   int round;  /*进程时间轮转时间片*/  
  
  
• 
  
     int cputime; /*进程占用CPU时间*/  
  
  9 c% b" ?- }! H  A0 T# X, P5 W% [% }
• 
    I, U" v, w& @$ a& e
     int needtime; /*进程到完成还要的时间*/  
  + ~3 b, d0 {# o, p6 Z1 w
  " ^7 ~& y: j* V9 {
• 
  3 ]4 @, _5 Y* W: n
     int count;  /*计数器*/  
  8 _( U  J+ _& v# u; K3 z5 p0 G0 T
  ! H# s- s4 I) c/ \/ v  N
• 
  
  + |  e8 R( C1 T5 ]! j   char state; /*进程的状态*/  
  " f" K; U. {  I) b% g( R2 B* |
  
• 
  3 Q1 d* d' i: l6 x+ P( w4 r  E
     struct node *next; /*链指针*/  
  
  + |) Z) O+ `' M8 j% U- J- U: ]
• 
  % g  B7 D5 i, R, ?  G
  ) N6 e$ p* V: C* J: x2 }4 G}PCB;  
  
  0 j2 W5 w2 Z+ {9 b  f# ^& N9 u# c
• 
  
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  5 g3 E6 |; W; h6 V" O( \! F
  0 D# Z- ]& R: K' O8 T
• 
  ( m( N9 C; z0 f% m" d* p( L
  1 k! ]0 S/ B( _, ]$ R" O0 Cint N; /*进程数*/  
  ! d- M* s  D5 x' e  G+ Q, z( A
  
• 
  / E6 u) A' x+ s* O$ U
  /*将就绪队列中的第一个进程投入运行*/  
  
  5 d" h& t" @1 F5 A6 Q# L( ?! N. y& s
• 
    ~  P8 K  i  a6 @4 n4 i5 m' @
  8 o% b+ ]& l( V" c# P% a& ?7 Sfirstin()  
  3 L! V' A: Q1 o* U( B
  
• 
  
  {  
  
  3 {  a" d  A2 b- G8 Q' _
• 
  
  ) I; w& [. F" I& b) G5 i   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  
• 
  : _( r% F* q: K4 F( U
     run->state='R';   /*进程状态变为运行态*/  
  
  
• 
  
  / ]# g7 T8 c5 R6 E   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  , a: Q# a* g5 S$ c
  
• 
  
  6 F0 j+ S! S2 S0 P' G% ~6 e' j0 S, B}  
  " i. G, ?# b" V& C1 k" L$ x/ M6 D/ {6 P
  
• 
  ( {# V* a$ Y9 ~; X6 S) J$ J+ Q
  + [6 D+ W. M% C) f/*标题输出函数*/  
  ( `9 ]& n8 r6 {6 i4 S, S# |
  5 v. ~1 k- ^& e4 b* }# E
• 
  
  void prt1(char a)  
  0 P' o0 C% ~# F- D0 ~. M9 [. u
  , I8 M2 o, p  E) P# F; X0 A
• 
  
  {  
  
  
• 
  # _9 h' v/ l; K! ^2 g4 b$ _- z5 p
     if(toupper(a)=='P') /*优先数法*/  
  - K  v- S+ v( M8 v3 W0 [( T2 r& c2 n$ @
  
• 
  
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  - N. A* k3 U9 ~* \; y
  ( p# ]& C: Y( Z! |( v) Y( m: z! N% m( Z   else  
  
  
• 
  
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  0 p; U3 }+ l% ~' M
  % m7 ^1 U8 M8 s, w* r; E( g
• 
  
  0 Q/ R4 j% k- d! k; z$ L8 |}  
  
  $ e* F, _+ y. @$ g3 Y  T: W
• 
  
  /*进程PCB输出*/  
  . c% S9 U5 t( Y3 h
  
• 
  
  void prt2(char a,PCB *q)  
  
  + i+ u, ^: `  g+ g+ w1 g
• 
  
  {  
  
  
• 
  
     if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  ( r. E* H/ Z* z
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  * c- h8 P# g- d! y) r6 y- I
  
• 
  : R+ h3 v2 H  }3 p, d4 Y$ I) ]
  2 O! Y* ?; k* `! {* U% q5 m! |       q->cputime,q->needtime,q->prio,q->state);  
  : }6 l) z5 f* `  ^, z# E
  
• 
  
  0 ]0 Z, t4 R2 F, E4 c   else/*轮转法的输出*/  
  
  $ W! a8 @; P0 M! \3 |! O& D3 W
• 
    q2 ]: r: u+ t. V" {) A6 O
  & b: ~3 Q$ \# ^) X& ]* i, e      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  7 w- H' h7 W! {3 Z5 [
  
• 
  
  8 j5 ~% l2 ]4 D+ a3 x# d; D& j: i       q->cputime,q->needtime,q->count,q->round,q->state);  
  - E' z( b9 u5 C% z. o3 N( W' F* Z
  ! L& R$ g3 O- q8 }
• 
  & Q7 [4 G' }8 ?
  9 j0 l, d2 R3 E; c* R}  
  1 O8 R) D# d  i  _
  ! E# R9 y- Y6 }6 v
• 
    k6 ?$ E* k$ t. J7 L, {
  /*输出函数*/  
  
  
• 
  
  % b. U. y) L& O1 O7 Z1 v9 Y3 kvoid prt(char algo)  
  
  
• 
  
  7 a4 e$ X* ]$ F6 |, y{  
  9 V! Q0 R6 @. _2 p: \  N
  ( p- O4 n9 M: p! s9 S9 M6 A
• 
  7 e* Q0 A  }6 k. Z- F: U* [1 n, j
  % y; |. \8 N- u. m# o, t: r' F   PCB *p;  
  * t2 o* w/ n& c) B& I2 j* P
  : I/ y8 S0 C, A, K7 E
• 
  9 n' n1 b1 t/ j1 e5 D" r! E
     prt1(algo);  /*输出标题*/  
  
  
• 
    I0 l4 e  R6 D8 E- e8 w% c! ?
     if(run!=NULL) /*如果运行指针不空*/  
  
  
• 
  
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  
• 
  
     p=ready;  /*输出就绪队列PCB*/  
  ( X7 a% c( I# H7 X3 [
  
• 
  
  " L7 n: s  n: r   while(p!=NULL)  
  
  
• 
  ( [# z* Q: X! j
  8 s. N( B( x* g" S% w   {  
  , B+ m* N! S$ S7 U
  
• 
  
        prt2(algo,p);  
  ) E; j& m4 A3 [+ b& ?% ]- j8 V
  . F: t. }9 e# }, b
• 
  / ~( F$ Y. d/ C# J
        p=p->next;  
  
  4 y: |% C4 S7 S: X! s
• 
  
  4 w9 [( G+ b6 K   }  
  0 m, A9 ?$ h3 `$ l/ t" g
  ! Q  q( {9 d5 I8 [4 U
• 
  8 G9 ]- d5 ~( K3 x- B) S5 d
     p=finish;  /*输出完成队列的PCB*/  
  : Z4 A' t) [% Q7 g
  
• 
  4 L) C; G7 H6 W( c  O6 |; `
  : ^2 \) L) J# ]4 Q/ q, D   while(p!=NULL)  
  0 A. T! A/ i! ~
  , v3 l' l6 a! `: v9 ^3 I5 ~. h
• 
  % @  s1 c( V9 h5 s, t) S5 {
     {  
  3 u  O3 ~  Y# M- m! R
  9 w3 }5 v, M6 g+ s* Q+ X' \! z
• 
  
        prt2(algo,p);  
  ' Z4 B" \7 K* @, B+ }2 F4 K
  
• 
  
  / U( P) W2 f) ^% @% b  M      p=p->next;  
  ( F3 Y9 Q0 b3 W2 z; K6 |6 p
    G# o! ^  c( w; ]
• 
  & i& |# e7 F% n( Y
  2 d$ f0 H: v6 i, [: e  [0 u% d   }  
  ) f" O3 r4 E! F
  % x+ s- m) q" {5 o% R
• 
  
  4 f; n6 I& o1 b# o0 a  l/ @. T   getchar();  /*压任意键继续*/  
  # j+ K/ Q9 U) W, F  B; t% a0 g
  0 `$ F: c! R5 _# T
• 
  7 A0 q8 J4 q4 _  ~
  }  
  % f9 }8 e2 D: k3 o+ ~9 {
  
• 
  
  /*优先数的插入算法*/  
  
  ; u/ [6 e' Q* w+ ]; f
• 
  
  8 \! F+ P- A$ ~) h) L4 ^9 x8 \insert1(PCB *q)  
  
  
• 
  % Q& U8 u7 p" C. B; r, b$ u
  {  
  ; r& J$ p. C4 s' o
  
• 
  2 u& ~. z' E1 c0 V3 y
     PCB *p1,*s,*r;  
  
  
• 
  
  % D6 T" |" @2 @* v, N  }" p2 {3 s   int b;  
  
  
• 
  6 [7 _( z5 c4 Y+ E" u
     s=q;  /*待插入的PCB指针*/  
  
  2 M' S) r  u* Z5 d4 x
• 
  
  1 |. m6 Y5 y' a8 G; h3 N+ F   p1=ready; /*就绪队列头指针*/  
  / I4 G! l, a+ Z+ ?& o! q3 m! a, Q
  
• 
  
  2 S& }  k4 S# K. u. _# i   r=p1; /*r做p1的前驱指针*/  
  
  
• 
  ! V; }8 g. ?% l0 e) @) b  z7 \) N& d/ Y
  0 p! p5 i9 X2 Z! T2 _- |   b=1;  
  
  
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  6 D, h  }/ v' B; j9 |- h" C6 P
  ' Q8 }6 _: X8 ], v# y
• 
  7 r! z8 n9 S9 ^+ w6 P
        if(p1->prio>=s->prio)  
  7 e2 |/ q* E7 _. I7 C9 n9 W( w  A" I
  
• 
  # W# W9 Y/ L  G% q8 f8 F- V
  1 e! H% J: \9 T- }$ ~" m1 p& _      {  
  
  # o& v; T0 h: B
• 
  . @! ^; O6 v2 o) r( `% z
       r=p1;  
  
  
• 
  1 D" |2 Q' [- r: s
  ! U6 y1 [9 f9 R8 G/ W1 y" F     p1=p1->next;  
  
  
• 
  
        }  
  8 n/ e# e6 ^) E- Z0 Y
  0 n+ }) q9 g# j- i
• 
  3 n7 {  g6 {- n6 w+ B
  " t& T7 u; Q! O7 @& U; `% z: s      else  
  
  
• 
  9 a( _( _" U$ H5 n
  0 J5 L0 f( q) r7 w, i     b=0;  
  
  
• 
  5 j" R; L/ }' u1 b9 P8 i! K& @+ a
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  " G" s6 n( j) \% }
  / j. U; H2 X, T  e$ }6 h" S   {  
  8 |' |6 h1 J/ u% s
  
• 
  
        r->next=s;  
  
  + T( Y* v% ?6 F% w& r4 L2 b
• 
  
  8 W- S- I& F+ E# x3 z      s->next=p1;  
  & u2 @3 j6 R  l) X3 g& m6 x) Z7 e
  
• 
  
  ! t. h/ }& @* P+ |8 a   }  
  
  9 p' \6 J7 A+ `3 w( {; M
• 
  # l. F% V0 P5 \7 N  W/ ?
  ; y8 h2 u. }# {; Y. I4 C5 R   else  
  
  
• 
  
  $ E. V8 ~0 \+ M3 |) g  W8 e   {  
  + m, L- S- U2 W' _4 w
  
• 
  
  5 V: M: ^8 k$ l      s->next=p1;  /*否则插入在就绪队列的头*/  
  / |: @( j- G, ?# S
  
• 
  
        ready=s;  
  
  
• 
  
     }  
  
  
• 
  
  , b9 ~; p) W! `}  
  5 e5 A- M# {% H+ R
  
• 
  $ \" _  ]4 [) j( r
  /*优先数创建初始PCB信息*/  
  
  
• 
  ) @- B. D* w2 g
  void create(char alg)  
  
  7 j7 |: P! g- z* E1 Y- O
• 
  $ E( [+ Y- k6 r& ^0 X2 i
  7 C& ?, C- K8 L3 t# \8 G! a! n{  
  2 {( o7 j- n$ }/ t- d
  
• 
  
  ( D2 v9 w! Z  G   PCB *p;  
  
  
• 
  
  3 F$ L) l* Y- C' H% A9 z   int i,time;  
  
  
• 
  
     char na[10];  
  . ?- }. \( b6 b' L  _
  * \3 E9 w! M- {6 N% Z$ R2 `
• 
  
     ready=NULL; /*就绪队列头指针*/  
  # i. X& }* ~/ c& e! I
  
• 
  , E8 c" \8 Q- Y) G. Z- ?
     finish=NULL;  /*完成队列头指针*/  
  
  + ]5 J# ^1 `6 d/ _6 ?  L
• 
  
     run=NULL; /*运行队列指针*/  
  
  
• 
  + O7 }: ~' l7 g
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  & B1 G% E% ~1 C2 G* ^9 P
  
• 
  . ^' k& r: {8 r. F& i/ Z7 x- _3 [4 E
  # }6 b' S8 i6 \# o& ~2 o. n" B   for(i=1;i<=N;i++)  
  
  
• 
  
  - @/ h4 f6 D4 P: \) Y( ~   {  
  
  
• 
  # _! e2 Z+ b* V9 Z4 P" Q8 x
  - ]5 b  N4 i; \: J5 E+ z" A      p=(PCB *)malloc(sizeof(PCB));  
  & \% T( {+ V+ x$ w0 i
  % f( N1 V, o  h" _# l9 e
• 
  " u1 `$ |1 T- h
  1 R: V- V2 ^7 i' d" p      scanf("%s",na);  
  
  7 q1 H; M  m2 P8 f7 J* ?3 `6 e* `, k
• 
  
  ; p* s- @* L/ i      scanf("%d",&time);  
  ; w, |, m) d: U
  7 x8 a+ T  [1 g4 h6 p( M2 l. {
• 
  % o2 M4 ]2 `7 ^# [
        strcpy(p->name,na);  
  5 Q' k- a3 m) Z% g  n  P$ D
  - D8 Q: b5 |7 {1 s# m5 }
• 
  
        p->cputime=0;  
    k1 j% i- D+ l3 r/ r6 u$ n& `
  8 t: q3 p2 ~: t/ @" q$ |
• 
  
  , o' I  M1 ^( f* ]5 [5 p* F      p->needtime=time;  
  # T  G1 R1 H3 S5 O( J7 Q
  
• 
  
  9 }% z) v4 L& `% `- b      p->state='w';  
  6 B8 H) S7 V3 ^# @% s1 K
  + q8 H8 l$ M$ C
• 
  / p2 T% G7 v0 }" X
  # B% V. t; }  U" q, Q      p->prio=50-time;  
  
  
• 
  9 }& Z$ Z/ q  \! `
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  
• 
  
       insert1(p);  
  
  
• 
  2 B1 ?# _6 I, y  S  w0 R
        else  
  : |3 ~1 J1 m. ~/ L( M) [' t
  
• 
  : M, ]" C3 |: F) _9 k
  , g7 j4 h# z5 O2 Q      {  
  
  & m6 a  Z: c, F+ u/ d" m
• 
  
  . l: V2 E; Z+ U1 ?" S/ W/ S     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  
• 
  
  ; y  d. C6 G+ m4 y3 b9 U. O     ready=p;  
  3 w/ }# A+ P2 K, ]0 |. d1 ~% b3 o
  
• 
  
        }  
  
  
• 
  
     }  
  9 m7 R8 s8 c6 t* Z
  0 A  E" l# f9 }) b) O  h: @  J
• 
  ' b" k0 J' |; T
  - \5 C! ~' A; D& N& f5 H   printf("          优先数算法输出信息:\n");  
  
  
• 
  
     printf("************************************************\n");  
  2 u( d4 M7 T9 i" ^0 {3 b1 [
  
• 
  
  6 S" x+ U* M5 L   prt(alg);  /*输出进程PCB信息*/  
  
  2 ?8 Y# B3 o. j
• 
  
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  9 [5 l2 R) O* \. G
  
• 
  
     ready=ready->next;  
  # V5 E' Z# h$ O- q, s' {
  2 e) W' ~! T: \- o* ^  m
• 
  8 S$ o. w% ]* _+ B* f* S
  : Z( d  {& c3 c* C1 y* A  }   run->state='R';  
    p1 P# s- f% ^3 y! {
  " \+ V. i0 x9 m" W
• 
  
  ) e, J, V6 v7 R/ q}  
  * v  @: L% y+ F2 M  ^
  # u. S) A( Q  s' z4 |5 }
• 
  
  /*优先数调度算法*/  
  ( g/ z$ ]; a; c% g' \: o# g6 A
  : \; w4 x" I5 k) |( ]0 b" F! g8 l
• 
  1 @, P6 r5 D, T
  priority(char alg)  
  
  
• 
  ' T, R3 r, @  r1 s- @
    T% I% U( \% Q& g/ o: s% D: U7 `{  
  
  . f$ Y* L" G6 j% ~
• 
  
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  
• 
  
     {  
  
  
• 
  ' O9 l+ o  b* V. G% H7 G( s6 V
  + A5 f% q. D' }$ d      run->cputime=run->cputime+1;  
  
  
• 
  
        run->needtime=run->needtime-1;  
  3 u+ \: J9 P, }2 A; D. V3 O( I/ n
  
• 
  
    I8 [* X) h  z5 V      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  9 V5 D' ]7 H* N9 C
  ) R7 \* h0 C" k$ }' t' A6 G6 E! S
• 
  & p* x1 Y/ A+ G- |
  4 Y) ]$ k. L( A5 B' `+ A: ~4 e      PCB *p;
  
  , J, l6 B2 q  o, z- p4 A: m2 I
• 
  
  + ~4 q) N1 h0 X- s" c; r7 Y      p=ready;
  
  * }0 t0 W6 C) e
• 
  $ K) z- h* M* R
    o5 v  v  z2 d      while(p!=NULL)  
  & Z( O" ?( _9 I2 s- E
  - }4 x1 Q) X1 u& ]* v8 c. ~$ |/ G
• 
  2 p  ?; k5 x' s1 Y$ \
        {  
  4 ^+ I1 B) `0 K4 n. g* i0 L
  
• 
  
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  , q4 n# t, F0 \; r
  
• 
  
  $ z6 W. Y0 o- U" ^( q8 m) T; x          p=p->next;  
  " u& f, k% c1 l) z1 z
  . e& r! J0 V$ G& ?) x/ e
• 
  
  0 L( |8 Q0 C( `3 v* G, }; T8 f# O      }  
  0 `/ s9 p, b$ a6 k+ T1 s7 ]9 `
  ; d0 Z, K5 {  F7 Q
• 
  
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  # p- Y( y% X  i2 x! {
  
• 
  
        {  
  
  
• 
  7 T5 r6 j8 {1 \: j/ }( u( h
    P* @6 I' s3 e" n$ w) G0 T         run->next=finish;  
  : W0 L1 P& v  ?9 k( X  X
  , _( q$ }" g! }& P. L) H) [
• 
  
           finish=run;  
  
  
• 
    l8 j# I$ H6 L. o' h8 X8 C
           run->state='F';  /*置状态为完成态*/  
  . O" Z; h5 m0 p
  
• 
  & z9 J- Q" b$ M+ W
           run=NULL;  /*运行队列头指针为空*/  
  
  
• 
  7 Z4 V. m  L3 J+ j$ R0 `/ {. z) L* C
  . L. J4 Q1 E" _& o( C: o         if(ready!=NULL) /*如就绪队列不空*/
  
  : @; U& o7 h7 v8 n( U2 }1 V; r& a
• 
  % l9 j( V' z( k5 D9 J" N
           {  
    }. {# |4 s' l3 O3 _- l" m
  
• 
  4 \8 J9 _: d0 O/ Q. h" K+ x8 u+ l
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  8 K. e5 W: F8 w
• 
  
           }
  * ~; \# s; D' p4 P: B
  : W7 [7 |) `. e! p6 O
• 
  
        }  
  
  6 K' g; _) q7 S- a* ^! b3 }6 n
• 
  
  * t1 ^& E( t0 h/ i  p& e      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  ' W1 s. U2 b( @: C9 R$ E! ]
       if((ready!=NULL)&&(run->prio<ready->prio))  
  ) J6 G* P/ y- z, C6 t9 c
  + {8 ^8 T  d/ l3 k: w$ _1 y
• 
  4 N/ D+ T1 t* K! |
       {  
  
  " ^. z: J. I6 c. A3 J
• 
  ; Y; |5 X7 L# W; a0 S
  + Y7 x, C9 C5 C8 b        run->state='W';  
  8 D1 u7 e! ~$ G9 g; l
  
• 
  + V( U# r2 O0 u! I% d3 O/ L
          insert1(run);  
  
  - r% Q0 W  h, E; Z7 Y$ `2 @* A
• 
  4 c. H2 X- W* p% K6 u% L- R
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  
  & `( Z: O4 B% b$ [- Q     }  
  
  : g( }5 p( _5 E
• 
  6 W1 O! k4 B! ?4 P5 o2 x
        prt(alg); /*输出进程PCB信息*/  
  # t  [, h# H" @% `
  ! N/ ]9 d0 J4 `9 J3 n% i
• 
  4 B" O* U3 l9 N  L2 \
     }  
  
  ) m3 ^# {! r% {' m
• 
  0 R: W- K/ l) B: v8 G
  # X( g/ {1 ?- l; P! |2 M, K}  
  
  
• 
  5 B  F  b! v( A9 t
  /*主函数*/  
  
  
• 
  
  . w) N2 y7 f" ~! E3 _/ a  smain()  
  ' E1 v. q1 c/ @+ q8 d& [
  
• 
  
  {  
  * ~( D1 E+ x+ R$ W: d3 w  a- M+ z
  
• 
  3 D0 |5 z" \8 \6 [: {- A' J
     char algo;  /*算法标记*/  
  2 F( w6 h8 L1 e2 K0 t
  ) K4 Y& k  E( R1 C; W
• 
  
     printf("输入P确定算法：优先数算法\n");  
  ! N+ H+ q8 M* j, d' P) {
  ; |0 \0 O/ A2 m" z
• 
  # ]# Q/ U9 M: _/ i- N, {
     scanf("%c",&algo); /*输入字符确定算法*/  
  # @7 K& j4 D7 H( A* T, b
  
• 
    K) V. @5 \8 K0 b0 S4 m
     printf("输入进程数：\n");  
  ! J# M) x( V0 u5 S) |! P$ g
  ( V1 ?+ ^3 Z8 r/ U
• 
  8 z3 M/ I! a( o
     scanf("%d",&N); /*输入进程数*/  
  
  
• 
  " f/ X3 d: }/ Z. ~
     if(algo=='P'||algo=='p')  
  
  
• 
  
     {  
  
  3 j* h2 ^. z) m3 t! f! A! ?
• 
  
        create(algo); /*优先数法*/  
  
  
• 
  
  ' H* [: ~$ A" E! X! {0 `7 ]      priority(algo);  
  & q# d4 }& ]- u+ b1 o2 n6 T+ q& B
  ! g" U" o2 F. G9 X' |# m6 Z
• 
  ) t/ F2 X6 m4 t5 n/ p
  ' q$ `3 M5 j; E7 Y3 X* I' V: e   }
  
  
• 
  
  % ~' Q, _- V  P1 Q6 g, ^}
  4 y5 b8 X9 v4 W2 t5 i
  
  

/ t1 S, V$ y+ c, D输出结果：

0 E& d6 k" d, }5 g原文：https://blog.csdn.net/weixin_40962955/article/details/80072769