优先级调度算法

杨利霞

/ a1 a, K# \' p* p+ T优先级调度算法

算法介绍
5 {1 I5 g& s1 V) u) z' u优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
- [' h# S: Z* C; [1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
$ u% A1 B* s  T0 r" @' j

2）动态优先权

算法实现

抢占式动态优先权：

3 T7 X* w$ A! C# MPS：本人认为非抢占式静态优先权没有实际价值。

• 
  $ ?2 ?5 p8 ~) A9 R& h
  . U, F% @# L6 b3 D#include <stdio.h>
  
  8 ?3 P+ {% ?2 F' K
• 
  * }* z4 ]& [* u; {5 a
  #include <stdlib.h>  
  
  4 m1 M; l. l* T1 C! @" h7 R, X
• 
  2 w+ j- ?: M: q1 x5 [% Z
  ; |8 \- ?# w* Z( f1 k#include <string.h>  
  
  8 ~+ H6 Y& u: k/ J/ m" `
• 
  
  typedef struct node  
  & g% @, ^, z( `
  1 _5 N, Y% u. z  D7 S
• 
  . i# h) ]! i8 c2 V+ K
  $ ^/ y, o5 \+ v  W{  
  , s" A  `) _3 L* [" E
  
• 
  
     char name[10];  /*进程标识符*/  
  
  
• 
  
     int prio;   /*进程优先数*/  
  
  , Q: u* V8 `/ T- X# s; C
• 
  
  4 F: g0 I* e& {$ b' T! K0 W   int round;  /*进程时间轮转时间片*/  
  
  
• 
  7 ~9 Z; a5 ~. I6 \
     int cputime; /*进程占用CPU时间*/  
  
  / f$ j) d& i7 r$ P! w9 _+ U
• 
  0 O7 J' A! U& G% a! J
     int needtime; /*进程到完成还要的时间*/  
  
  " b- }) [3 |/ p* }) K
• 
  ( ?6 N0 T$ I2 w! E) H& G  @  l- P$ {
  ( z9 N' }, [/ ]) q   int count;  /*计数器*/  
  
  6 e" x0 p$ d# Q+ K
• 
  
  6 @% c/ ?! t0 O/ t/ q   char state; /*进程的状态*/  
  % `+ ]% _& Q' x5 L1 F' [2 j
  
• 
  / }- x! P9 k7 E$ Y- ~2 a
     struct node *next; /*链指针*/  
  
  
• 
  
  5 v5 X9 C$ T6 O}PCB;  
  * t; F0 L6 q, f0 [7 M& A& }
  
• 
  
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  ; G  t0 Q3 y/ u/ T, J( u
• 
  ; _4 O2 h. g% r7 e
  6 X& t. h! Z! y% Gint N; /*进程数*/  
  
  3 X0 u9 b. v6 v0 T, t
• 
  
  9 F2 ~( e* m: v+ J4 y! I/*将就绪队列中的第一个进程投入运行*/  
  8 R/ q$ [6 r( l
  & v& l  J3 {0 }# e) N- e
• 
  , z, V, i' U$ T) M+ q
  / m5 ~, p' h& N; k) P6 i! Vfirstin()  
  0 T) l$ ?  U. v& A+ n1 V& G, B
  
• 
  
  ) o0 z: Z8 H0 i& |{  
  
  
• 
  : x2 S6 G& x$ ]) L6 p7 V. \
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  3 W) S# s/ k- v/ Y$ \' z
  
• 
  7 u/ n! n5 }8 u' x
  & r' ~' z0 N5 b: Q, j0 H2 _2 E   run->state='R';   /*进程状态变为运行态*/  
  
  
• 
  $ F2 P  i; s7 A& C  s: E
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  
• 
  
  }  
  ; n) q7 T  [0 R& h+ y/ Q( c8 Z
  
• 
  - ^1 F5 g) u9 D
  /*标题输出函数*/  
  
  
• 
  
  void prt1(char a)  
  ) j$ j9 w4 s* V1 C
  
• 
  
  {  
  
  % T! B" j# F$ }# m% R- U
• 
  - k+ M, L/ ?  F
  + S- F2 {% F8 F; E  h0 \   if(toupper(a)=='P') /*优先数法*/  
  0 S/ o' P* `3 w9 k* B+ j3 V
  # k' u. j3 R7 \! Y/ Y
• 
  
  ( E$ J7 M: a9 ?& T# A- V! N      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  . M; [. X  ?# u" s6 B7 C
  
• 
  
  3 P) v8 [# m" l" I4 g   else  
  # t! t+ j* Q  }9 I* R1 L4 X
  ; ~5 D8 o( C2 O4 M0 F; |. o
• 
  : S2 ?; n5 Q; G4 r
  $ x% D3 h( }+ c; C) k4 V- ]      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  / p0 f: H" A4 w1 J  C
  ; m" _4 _$ s2 ?. i# j  h4 U) T9 L* D
• 
  
  ! ]' {2 _; P, n}  
  
  
• 
  
  /*进程PCB输出*/  
  : ^: d- y3 h# }0 D% e
  
• 
  
  6 P# h5 _( B6 \& Pvoid prt2(char a,PCB *q)  
  
    N( ]# H' ]( p/ }. }8 K
• 
  
  {  
  
  & [- [  T$ Q, N  ~! o
• 
  
     if(toupper(a)=='P')  /*优先数法的输出*/  
  * p( r" z4 y% q; ~7 i. j9 y& U
  * H; `$ R# \8 ?4 [; u! {8 D
• 
  
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  * L' I- e: E( \& K6 ?
  6 E0 K3 e  \; e" j! |- g
• 
  
         q->cputime,q->needtime,q->prio,q->state);  
  
  ' M  J/ ]* ]0 n& N
• 
  
    B0 P- J( \1 O, q) k" f+ ]8 v   else/*轮转法的输出*/  
  7 q+ p! T8 n: ]: Y: J3 J
  ; _- q; _$ l$ u
• 
  
  " G3 Z6 m+ S# D, F      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  ; r' J0 c9 ^# a- k
  
• 
  
  , G( T1 V  a! M- g       q->cputime,q->needtime,q->count,q->round,q->state);  
  ) ~2 T0 B$ P7 I0 g
  $ M  g3 `( x" v
• 
  
  . [/ a& k6 g! [7 L5 s& V! B- y}  
  1 T, T. ]3 N0 D8 k
  & b* A) Y; ~( ]) u% Z
• 
  
  " u. [+ [7 z' z" `% x/*输出函数*/  
  
  
• 
  , ?7 a6 @* k0 E" ]9 \/ |  M
  void prt(char algo)  
  
  
• 
  
  " T  [; d6 [+ e{  
  
  . S) d" J5 O' d2 G: q
• 
  4 c6 I9 ?* h% |8 Z
     PCB *p;  
  3 ]' _8 F0 O' O# W
  4 q/ K5 n: q' Q6 S4 S" U
• 
  7 l8 H* W) l6 h5 K+ U
  0 m, O6 v8 B! y4 \- w4 z   prt1(algo);  /*输出标题*/  
  
  $ j2 v( O  M1 r6 M! L
• 
  
  + F3 d( f" m+ q! g   if(run!=NULL) /*如果运行指针不空*/  
  $ ^% N8 d0 @6 T
  
• 
  4 j: O& T! o# }$ c
  8 R0 ]- F( l- t. H6 f4 F      prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  + M% ?( F8 K/ h% O: J
• 
  ' F& M$ |. k: l$ X* l3 V. H7 u
  0 O' \- |$ i' }4 H) L7 V- u& H1 z   p=ready;  /*输出就绪队列PCB*/  
  0 A: S: ^  k0 k2 f' v5 u9 z6 n" I6 o. f
  
• 
  7 t$ P* `( s3 U3 B* A7 o
     while(p!=NULL)  
  ( N1 C& S9 ?5 E; F4 b2 Q+ t9 _
  
• 
  5 o& H. N+ `2 T4 k
  8 S5 x/ Q' a" z; o9 Z% c3 b9 R4 P8 q   {  
  
  
• 
  7 s% B" ]9 ]) e9 e! M" c% O
        prt2(algo,p);  
  
  
• 
    C- b+ G% ?, r6 q0 P8 O/ z
  % g8 t9 b& p  m- r- q* _5 Z# r      p=p->next;  
  
  
• 
  
  + m5 I; Q' x. D% Q   }  
  
  
• 
  
     p=finish;  /*输出完成队列的PCB*/  
  
  
• 
  , A& L* b2 _$ c6 ~
     while(p!=NULL)  
  
  - r! c7 C0 K, J
• 
  
    i/ |. ?9 w, e8 O, F5 q   {  
  - Y+ P# h4 @4 Y, @1 C+ m9 O) U
  
• 
  & U. k- p. @3 c( s; W
  8 d+ E$ w# _) ^2 G, |. H      prt2(algo,p);  
  
  / a8 o2 Z4 E( E7 a8 ]! F# x6 s/ l
• 
  $ y4 L- }# u% @: m
  3 {. t  o) o7 s7 N0 e4 x3 f2 Z      p=p->next;  
  
  - c! h4 s/ X" l. P: k- i
• 
  
     }  
  
  ) y3 E' }/ T1 [( `: e% l% Y
• 
  
     getchar();  /*压任意键继续*/  
  
  
• 
  * b; G* v6 ]* _  o+ w
  }  
  0 }: d/ r( V$ H# k* Z1 E
  
• 
  
  /*优先数的插入算法*/  
  
  0 [+ \0 H* H/ Z, k0 a. L3 z
• 
  ) G/ j. a& |; d- e9 @: F6 H* z
  5 J- O9 c, w" ~, ainsert1(PCB *q)  
  
  
• 
  ; A- o( e% u: s! r2 o' e& K
  $ q$ K8 ]: u4 |8 l  ]{  
  
  # E" V% H/ t" H1 A, k7 ]( R/ k( _! j
• 
  & E& w8 s, h* O+ M7 q8 O
  5 h7 s- b8 V. k   PCB *p1,*s,*r;  
    O4 z7 y  z/ X/ B. {& P
  
• 
  
  - ?' ~, h& L, H   int b;  
  * v* n; U9 x  _: a; l9 \
  # v& w' v9 j3 l7 W6 E
• 
  
     s=q;  /*待插入的PCB指针*/  
  & O: a* f2 N% V" `& O, N2 z
  1 H5 d8 }  V0 {3 v* M4 n
• 
  
  ' ]6 w$ L6 y/ p   p1=ready; /*就绪队列头指针*/  
  
  
• 
  
  , @; r4 j: F& [& e: p8 g. [- ~% H/ O   r=p1; /*r做p1的前驱指针*/  
  : l8 z' u1 O  [8 x- Y
  6 K2 ^/ m1 V# Y' [
• 
  
  8 U1 U# ~. u' r3 F: ^0 v; u   b=1;  
  
  , n/ M# r6 O7 R, {
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  
• 
  + B9 i" S7 K& M- n) W$ s
  4 Z  O" Y* P- r8 F' X      if(p1->prio>=s->prio)  
  
  
• 
  
  3 \& r1 r, o# b5 q1 L* Y      {  
  0 Z2 W4 Q6 U$ e
  1 E7 p) q4 x# X6 C
• 
  
  1 U1 j4 S: [! e; t     r=p1;  
  1 u9 j" h5 [" {; |  F
  ' v- c- b' b3 ?' v& v  l; Z
• 
  . f! j$ b  j, r( `: q2 _0 W
  : \6 k* L$ N+ D/ J1 U2 L     p1=p1->next;  
  - v; E- @9 m9 G1 D  z
  
• 
  
        }  
  
  1 b  ~: H$ T% k( _0 j% w
• 
  
  9 Y; G$ H/ a  O8 R4 v$ V, m      else  
  ( l9 ?3 r" V5 g& I# r
  1 K$ s; Z( o, u! p2 b
• 
  ! q2 F0 `3 T6 ~: M  E
       b=0;  
  & ~: L$ [6 Y# J- e
  ( q7 F3 t0 r  E$ U' x3 }
• 
  & A1 z. `' n# X- F4 ^- q9 l
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  . H- P* Q0 R9 o' \7 V5 a
• 
  8 r( f* A3 A$ D' O. A9 Z) R  k
     {  
  
  
• 
  
        r->next=s;  
  
  
• 
  
  - P7 p6 a1 ~7 [4 T  k      s->next=p1;  
  9 x5 E5 n( B# F/ w
  1 A6 u) g1 n( B% [9 j1 J
• 
  
  ! X7 ?! n- f4 H, q4 ^$ z9 n   }  
  & ?  s1 q0 A" v. \( ]' k4 \
  9 r. Y5 l, v6 M  h  V
• 
  
     else  
  ; ^5 l9 }: R& ?/ \" E) S+ F
    K& y) r6 [6 ]
• 
  
     {  
  
  
• 
  
  : \1 F1 R8 R3 g5 A! E8 m$ a* ?      s->next=p1;  /*否则插入在就绪队列的头*/  
  / [1 ~+ C$ y! a, o, R
  
• 
  9 f2 m1 l% B: A  [  @% e! @
        ready=s;  
  . }; C4 O  w  c, h( P: Y
  3 [2 `, U' I0 Q
• 
  
     }  
  
  / R4 l+ k. \1 u7 R7 N
• 
  
  # F' w+ |/ X+ b( t, p}  
  6 E: T1 x9 _* U. t  o+ |9 A
  
• 
  2 {. O$ t" ]! Q1 W
  % h8 ?0 X, P/ B/ g) J: M/*优先数创建初始PCB信息*/  
  % o  Q0 P: m! V% z8 ?8 U
  2 R0 B7 W( h- S) ?! h) `2 c
• 
  3 p: p8 x% R$ @: c( E- a4 Z
  * B" l3 M0 |5 s; e+ G4 Avoid create(char alg)  
  
  
• 
  
  7 }% ?& ]0 Q+ n3 m( }2 t{  
  
  
• 
  
  $ G6 N" Q. R( U0 I   PCB *p;  
  
  
• 
  
  9 T; y2 f+ L2 O# X3 S8 Z   int i,time;  
  
  & V1 I4 Z( J" W. E( K- b0 H3 a
• 
  # n/ y8 n9 f! P: L0 e
     char na[10];  
  " T1 C1 M" q( W; @, n7 u9 f: |
  
• 
  ) m  u7 ~3 A7 n
     ready=NULL; /*就绪队列头指针*/  
  
  
• 
  ; o* Z* [$ }+ S: D, C4 B0 s, D" B) A
  3 Z, s1 X: C9 J# d* O/ k. @   finish=NULL;  /*完成队列头指针*/  
  
  
• 
  
     run=NULL; /*运行队列指针*/  
  + F( n% M, |7 y  l- M! ^
  ; w: g# @8 K/ @0 O1 x2 p
• 
  , y* |& _& p  y) m; |
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  7 h$ ?: j" a/ f, @5 O
  
• 
  
  % ?1 I" ]5 I  C* C" Q7 Y   for(i=1;i<=N;i++)  
  7 S7 O8 V' c" L) _! }  H) k
  
• 
  7 M0 d+ h( |- J
     {  
  7 Q" s5 c9 C7 s/ Z& x: t: c) K
  + W3 r2 p# N8 q, K" J& g# T
• 
  
  ) L0 N9 I* x5 U      p=(PCB *)malloc(sizeof(PCB));  
  
  0 A' E7 D- h+ b5 B8 l" Y
• 
  
  1 \9 |" V# n2 i& ^      scanf("%s",na);  
  
  
• 
  # T3 v3 d+ o4 m( |  e; i. N" O4 Q
  , ^$ d$ v& U( Y! {+ @$ ?! A      scanf("%d",&time);  
  & u' j3 `% ~1 ~$ |( z
  
• 
  $ I! x# J, [3 d: ?
        strcpy(p->name,na);  
  
  
• 
  $ s. t7 b( c0 S. l; b1 M* i; w+ W4 S
        p->cputime=0;  
  6 T: f' a1 q& _
  
• 
  + O- L4 P: A- T+ F- T) M( w) r7 M
  7 {+ T. l7 b1 h# d      p->needtime=time;  
  # b4 r5 I8 k' r) g& ]$ i+ s, Q
  
• 
  
  1 n2 {9 F% n. [% l      p->state='w';  
  $ k9 E" y9 P0 u  n: o
  ! N( O. I; r* q
• 
  
  8 h& c/ m4 K) M! |      p->prio=50-time;  
  % |$ K# h' e) B$ i3 p1 M* G8 {1 x
  
• 
  % H% q2 e& k- K. T
  ( ^' v+ ~. h/ |      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  + z# b: f, c4 U' d# R" N
  . F+ q) C* Z- N# ~* y3 s
• 
  0 t! o2 c( O6 U. }! J
  " c  k. C, A6 U9 {3 j2 k3 P     insert1(p);  
  8 j  p/ s& U: k/ B
  
• 
  # }8 N0 S# N4 z# U5 i8 j" x
        else  
  
  
• 
  
  # q) c( Z1 ]  ~/ t! l6 Z  c2 l      {  
  6 W+ Q% ]( D$ {
  
• 
  . B  ^4 ]' Y/ B- K  h
  - c( \- y' H1 T. @0 a     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  
• 
  3 b1 v2 h8 t6 p' Y6 g
       ready=p;  
  ! j. A. i: D. ]) y- `5 P
  
• 
  
  . X* ~6 v2 d8 H7 h4 ~- a8 I      }  
  4 g& S. }$ Y" o" U. |# H/ x% e$ {
  
• 
  8 |' c# L. I' ^
  / H; t* u3 _% u, @- B# o* ]" ?   }  
  
  ( I) k8 y7 n- o' `' `; {1 f1 [1 E  h
• 
  
     printf("          优先数算法输出信息:\n");  
  5 |8 ~2 I: r( D2 d& K/ Q' Q
  3 U# M" o* S  L9 s! ~0 [, w' e3 q$ s2 M
• 
  
     printf("************************************************\n");  
  
  ) p7 k* r" u1 p/ n# m
• 
  / V- P* s/ ]7 F6 k
  " m/ B, L5 e4 ~% i   prt(alg);  /*输出进程PCB信息*/  
  
  5 G5 s4 C9 x* S
• 
  2 ]1 s) h4 ^" ^5 J, p
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  - O* q& G; h) k
• 
  + S3 |8 g/ D3 q& u! C2 C3 M
  6 O, i! f0 l; H" l   ready=ready->next;  
  ( o5 }0 o9 j9 a* ~
  2 H) ]/ \4 T# `( g) [, C- \/ b
• 
  ; }8 K# P' O; U) w* M
     run->state='R';  
  / U# q0 [; P9 ^. f# h2 T! |
  
• 
  % M7 E/ @" ?# p/ K2 B/ s7 o
  }  
  
  6 {5 R6 p- N7 Y) Q4 L+ v3 y
• 
  
  /*优先数调度算法*/  
  . }  \+ ]7 x$ M6 @
  
• 
  8 W8 s9 `% P" N: {6 {9 E1 l
  8 I) E) A! W& T7 I/ d+ _priority(char alg)  
  . k3 [' e; \  y' E$ V; G$ _6 q
  9 |- z% o3 `0 q* Q; V( R
• 
  $ `+ I+ {, g. z* z8 n8 b4 l, t
  8 N' {. a, t" {7 z# s" C  E{  
  0 R& M9 N+ C$ C1 {. q9 q6 ^  q
  
• 
  
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  
• 
  : M, k) `, V9 j/ `+ @0 s
  2 |/ P) I" i2 ^0 g3 u: U- m, K   {  
  
  
• 
  
  ) D6 k- a. w1 M* K7 L      run->cputime=run->cputime+1;  
  
  
• 
  
        run->needtime=run->needtime-1;  
  
  ) B% D1 H& h$ R
• 
  
  ( ^( u. J4 g* p6 y6 t7 Y+ G      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  # l8 D' ~7 ^" ~4 k- n) u) `- t9 l
  ' L2 c1 {4 I2 ~2 V. r! ^. G
• 
  
        PCB *p;
  / q4 s2 Q  `' Z2 f6 B
  
• 
  
        p=ready;
  
  ( p' V2 r! m% D2 w# f- e. p: \/ m
• 
  
  8 D5 O- r. E* |! F, w      while(p!=NULL)  
  * `5 g8 F& S* F) Y# r+ W
  $ @4 Q0 \2 T) _) R5 {' E
• 
  
  8 R: r. I9 X, A7 n. h. Q      {  
  
  " k. q1 X- _/ W
• 
  
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  
• 
  : I5 `0 Y$ c0 {9 G' P3 w' m
  / Z5 N6 m9 [  q4 E          p=p->next;  
  4 b: w1 W+ ]' `/ a5 f% y/ ^) I- F
  6 K2 q. E, ~6 m6 h  Z* ~/ C7 Q
• 
  / l" E) J5 x. T
  + Z$ b4 c( J7 X* Y8 [      }  
  1 d* [9 M2 I7 k
  7 V# e- w7 k- r
• 
  ' P7 S  T! z+ y* {. h
  2 B9 {% m) Y: M7 G$ P      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  ; h, w* p/ v3 L" j, D8 v# A; K
  
• 
  : z7 {# J% t# I" e8 ^
  ! F, z- J1 ~! z2 J' Q- {& R      {  
  0 g. I' o+ R: N1 p* }$ F
  * l. @2 f. H% S4 ^! K0 h6 N
• 
  
           run->next=finish;  
  
  
• 
  7 ?  U" a( t, b" }/ X
           finish=run;  
  
  
• 
  
  5 C* g2 M0 w2 e$ h) ]         run->state='F';  /*置状态为完成态*/  
  ; P4 ~) Z5 ^8 D, V9 s
  
• 
  5 \4 T, ]/ M- b0 ~- v3 I
           run=NULL;  /*运行队列头指针为空*/  
  
  
• 
  " f! l3 e' H% c, G" E
  * l3 D; o1 X8 L3 w2 M& g$ d/ B         if(ready!=NULL) /*如就绪队列不空*/
  
  
• 
  
           {  
  
  
• 
  
  . \5 i1 T" C9 r$ r& N/ h4 s' e            firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  
• 
  
           }
  
  : }3 k' H; g4 g- U8 H; c
• 
  + r- a8 G3 M) g& ?5 ~& \5 C
        }  
  
  0 l3 e9 R8 C' H
• 
  
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  % S. T9 e  _5 W/ G& {4 @; C
• 
  0 K# K5 c) |+ ]9 o% n6 f9 v- \( q
  4 z- a1 U8 r/ c/ P& r4 ]     if((ready!=NULL)&&(run->prio<ready->prio))  
  
  
• 
  + {/ n6 m% f5 \; r9 x
  8 G% b3 a1 N, v1 T3 F/ d" V     {  
  0 J! g  C* u# K$ |% ^# X3 {9 p& R
  8 ]3 c4 D# X6 K
• 
  2 T- s+ I$ a- ]4 _  \
          run->state='W';  
  . V2 f$ \+ C! F; y2 r8 [% Q4 t
  : P* w- Z4 O4 w& O
• 
  
  5 i  ?' E- q0 H/ c1 _/ g9 I        insert1(run);  
  ( @; c! p$ p% Q  A2 G
  
• 
  
  7 P, s8 B7 x6 q* U! }        firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  1 Z" k  l! p9 f! d5 L
• 
  
  . `; @# W# z" R1 `$ V2 ?3 z     }  
  * Y  ^8 P: i3 x5 @
  0 q5 Z5 E7 I3 o* l
• 
  / @2 L5 {" J7 C+ A! U8 K$ f6 D
  ) `* W; p- h: `- \4 |      prt(alg); /*输出进程PCB信息*/  
  
  , }4 o" |5 q, |0 v& g, v
• 
  
  : o- ~2 t5 J% l: |   }  
  & F# S! w$ {4 ]
  
• 
  
  5 j3 g5 ?% r7 W4 d0 i' w7 T$ C}  
  
  
• 
  , Q9 A$ J6 r( Q) T' r1 L; M
  /*主函数*/  
  
  6 R0 D3 g+ K; L5 g7 t5 V4 V
• 
  
  - j( V+ d- ~- G0 ^1 K1 i. ?main()  
  & q4 q# F! L( b: t$ c
  $ N7 W* G  ?& [  d  x, v0 M
• 
  1 r; ~# e4 ?% m, _
  {  
  
  
• 
  
  8 v9 w( l( v' Z6 D: r   char algo;  /*算法标记*/  
  
  
• 
  4 }7 p1 T% n* |5 ]9 Q  q7 A
  4 r9 n3 P6 N  F1 c   printf("输入P确定算法：优先数算法\n");  
  " M" B# s$ j: }& d" `+ h
  
• 
  
  , q3 q- K9 t! ^) W+ U3 L# `   scanf("%c",&algo); /*输入字符确定算法*/  
  
  
• 
  
  1 K7 f* T" j, t3 {   printf("输入进程数：\n");  
  1 Q$ D- U3 c, _3 s( F
  1 `1 N/ {: ]# n2 t0 O
• 
  
     scanf("%d",&N); /*输入进程数*/  
  
  
• 
  
  $ t* l8 I9 n; Z   if(algo=='P'||algo=='p')  
  ; y8 A& _% T5 [  T! @; X- B
  
• 
  5 `+ E1 z/ j- t/ B( P. R8 x
     {  
  - `8 a% ]  V8 [
  2 R& @! u  X) E' u2 ?
• 
  ! D; I4 n3 r2 i# a+ Y
        create(algo); /*优先数法*/  
  , K' u: W- P7 N0 U
  " e; f% ^7 ?+ f1 F+ V5 H4 z
• 
  ! t7 Y' _# e/ L+ t% B9 ~1 K
        priority(algo);  
  
  
• 
  / P; R9 {1 [- E. Q. T8 D
     }
  4 E# Y! b$ `3 s: d8 V+ e0 [  L4 v
  0 a! B4 T5 T+ C) \
• 
  
  }
  
  
  ; J5 z. }! Y: @' S# f

输出结果：
" e% r# ?& l" N7 E5 `

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

3 Z2 P! k! E4 }  u! m7 C0 N