优先级调度算法

杨利霞

; {0 F' t% T5 h- i2 l2 v: T! l优先级调度算法
4 n, e* s0 M3 M( y7 W

算法介绍
优先调度算法的类型（用于作业调度）
/ W5 Z& F$ Q1 u' q( v  \1 g6 O1）非抢占式优先权调度算法
* n$ P$ p5 Q. E; P5 v7 |  F系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
. I! ?- \/ v5 [2）抢占式优先权调度算法
& W0 f: g: L( N. ^只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
8 L  m5 T4 T$ W& [) K2 s1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
/ t( E3 _* b; v  f3 D

2）动态优先权
7 p$ ~8 n* D+ {

算法实现

抢占式动态优先权：

1 z- g. m: ]8 SPS：本人认为非抢占式静态优先权没有实际价值。

• 
  
  5 d9 a! T9 j5 M#include <stdio.h>
  
  ! s, x- ~, ?. B6 ^
• 
  
  #include <stdlib.h>  
  
  
• 
  
  #include <string.h>  
  
  : k5 F/ f; H* g; z) d
• 
  
  typedef struct node  
  
  
• 
  
  & J$ x4 v4 @, a( t/ S' w$ P9 J: P{  
  % w  E3 M6 }4 e8 a
  : _$ v  a; l. T1 a
• 
  ( n' ]/ K$ P+ f* K
     char name[10];  /*进程标识符*/  
  
  , p" L0 r6 ]8 p6 A+ ?2 e% F$ d
• 
  
     int prio;   /*进程优先数*/  
  8 V0 r1 i, ~2 r4 J) K7 ^4 l
  : _7 M& _6 |4 K. e
• 
  6 S+ `0 x0 d% @' O8 N6 m) H
  8 G4 q+ V( b: A. F1 s9 {. J   int round;  /*进程时间轮转时间片*/  
  
  
• 
  $ Y* X9 |; ^, i' v
     int cputime; /*进程占用CPU时间*/  
  " w5 o" U  G5 h5 Q
  
• 
    k* m% h3 t5 G; g  G2 ~
  , \6 N0 f0 X: }, I/ `' u7 H$ V   int needtime; /*进程到完成还要的时间*/  
  
  
• 
  7 n- M5 P/ b' J5 _! P& w8 I  y! F
  " {" Q! J+ Z1 E9 y$ L+ v! g" C& r   int count;  /*计数器*/  
  
  / i8 F* ~4 O0 s
• 
  / [0 s. Q5 N( Z0 ~( C. a. ^
     char state; /*进程的状态*/  
  , S9 Z- l7 G* E& S; G+ h
  
• 
  5 j9 q8 }7 q% ^
  0 v. c' f5 i+ e' H5 K/ m' v6 h) F   struct node *next; /*链指针*/  
  
  
• 
  3 n  }! Z7 Z9 J  _6 A3 t
  " F# u  F" d, i. v2 s. I7 T- l}PCB;  
  ( E0 v9 Q6 h/ o/ y
  % U6 |0 z3 F9 S9 m' ~
• 
  
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  2 G! G) A) a; H: A
• 
  
  1 `- n1 P$ F" _3 \$ @int N; /*进程数*/  
  & o2 F+ ?; C: V" N! B4 k
  6 }2 ^( o; C" B/ ~3 `# c! i
• 
  
  & T7 P5 @, l/ |- n1 R! L: q/*将就绪队列中的第一个进程投入运行*/  
  
  ; F% r% w, s" p! m" q1 n
• 
  3 i- q3 x9 s6 c* M8 j* ]) w9 v  N
  ' W4 V( `" s; efirstin()  
  
  / E( b& h  D4 t3 X1 N
• 
  $ _& [: Z  I7 L' S" O' |! ~
  {  
  * M4 u: D1 t6 K( ~& {% O9 U
  4 ^' e: ^8 U% p2 x2 w- C
• 
  4 N0 s/ y/ i; y4 \. w8 w
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  
• 
  
     run->state='R';   /*进程状态变为运行态*/  
  0 }3 D+ a+ W- O& I
  
• 
  
    N! m  i- J* s! ]; Y. C7 @   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  $ c  i  X6 n9 k  o9 {) `
  ' T7 J% U! O, A$ e! ?
• 
  + V8 ]3 N1 Q2 O% y: H
  }  
  
  
• 
  
  /*标题输出函数*/  
  + k3 m2 u% p& w. ]/ ]
  2 O& F. S% ~; _4 c; w
• 
  
  9 s2 {% F# z4 Y% a! D- Zvoid prt1(char a)  
  
  ) _' {' x. Z# Z; ^) l
• 
  ! s( d9 w) p$ O4 S
  4 A" ~- _4 E* p. z1 P8 S5 s) T{  
  
  3 F0 b6 `- {1 F
• 
  & H' v6 }/ [' Z  R+ I* U
     if(toupper(a)=='P') /*优先数法*/  
  
  
• 
  
  5 I, c# n3 v8 R( F; S, f+ e5 r: I      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  ' i) ]/ w# J* W4 _' t
  
• 
  
     else  
  # f) I, q; l# \. ?: G% n
  
• 
  # k2 T7 Q7 X& E1 q* m4 f
  + @+ p. l* @/ f$ s      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  % T. f' A1 K- Z! s! [2 f
  
• 
  ( E& j5 G3 m  A/ ~0 {2 n
  }  
  - t9 P" j6 c: F6 a# B) L
  
• 
  
  . `( d3 Y7 K/ u/*进程PCB输出*/  
  6 M( J& t1 ^$ B7 u( f& O
  7 P* q  r2 Q! \' o
• 
  * c1 `2 |) a: S" N( D
  # h# s/ U7 P. t. Y& W: fvoid prt2(char a,PCB *q)  
  
  ! }, _1 c. Y6 n8 m) J
• 
  9 L4 Q3 G, f  ~6 x$ d
  # R9 ~% g# k0 s" \' r- w# K! W{  
  ' l9 P. r. e: t
  6 L! H% R0 V2 H3 L
• 
  
     if(toupper(a)=='P')  /*优先数法的输出*/  
  ; n5 I- d3 X% L9 h* `4 G" |
  
• 
  
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  " M% U! d6 c+ A  [% Z/ A. D8 Z6 c
  
• 
  8 N0 v0 ]- f- F) N' ?6 ~
         q->cputime,q->needtime,q->prio,q->state);  
  
  
• 
  6 b) g; @- _- R  w4 u8 I
     else/*轮转法的输出*/  
  # ^& o( ~( R$ ?6 r6 x( c
  
• 
  
  & k- u2 A) w5 n1 U      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  1 i$ H1 i0 k, g' G+ n5 k4 V4 Y8 t
  & M- @* M. Z1 N" T
• 
  4 O# x8 I. G6 G" }# |
         q->cputime,q->needtime,q->count,q->round,q->state);  
  4 S" k: y0 k* I6 p) ~+ K
  
• 
  
  }  
  
  9 e. V2 [5 U/ h9 w
• 
  " L6 z: r  ~, J# V: V
  /*输出函数*/  
  
  
• 
  
  & B, @' G& |! Z' t$ ?2 Cvoid prt(char algo)  
  
  
• 
  - g' g+ Y. _7 _+ t# R2 Z" t
  % F8 e' U6 t6 o# S) L7 y{  
  0 V9 p2 o6 F* f4 n) \
  7 q, S( N- E% ]5 w! j* l7 n5 E/ Z
• 
  5 I1 z/ S1 A- l1 f$ a$ V
  ) r5 n6 I) P6 b: }0 }$ w) s   PCB *p;  
  
  1 _+ H9 E5 S; e: S7 Q$ F7 \- a
• 
  % G0 |+ [+ {7 J, u) o: w$ {0 o
  & h4 v: ^9 Z" O& j( ^* s! o   prt1(algo);  /*输出标题*/  
  
  - W: \8 C" M$ {/ r: y& ~, v4 q! {5 n
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  
  
• 
  ( x* ~4 y9 w+ E2 b$ J1 Y
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  * @: c1 f/ h/ c( N6 E/ b
  : ?! h* B# ?$ J: \& L
• 
  
  6 Q$ n! n4 r) [& `   p=ready;  /*输出就绪队列PCB*/  
  
  
• 
  " `. f/ d( P  B3 j# H# P
  , \; ]7 |2 n" ]7 F1 c   while(p!=NULL)  
  
  " l  b6 F( H$ W
• 
  / ?6 g% }- [& h6 t4 q* x; j& Z' V
     {  
  
  
• 
  
        prt2(algo,p);  
  " N" I- x, U7 |$ j0 \" U  [/ s' A
  ! A+ B* J: X& @: z( x6 f3 k
• 
  
        p=p->next;  
  7 ~% c- q* ~( S2 a# y( _5 ]1 _+ u
  
• 
  6 ]) r+ X0 {, _( v) T" l7 r! B3 G, L
     }  
  
  
• 
  
  " \# O$ Y. n/ i. E  ^   p=finish;  /*输出完成队列的PCB*/  
  
  # A* p/ Q* }$ v& c1 Y* r3 [$ P
• 
  4 y$ B$ n6 {; S! w' P
  . k- |9 r; C4 f$ x. V) s& G' F  O   while(p!=NULL)  
  
  
• 
  6 y$ V1 q' G1 e# H5 r6 F  r
  2 `4 |* f/ o1 d0 _" o& Z# ~+ P( ?   {  
  * l. O0 Q. o* j5 k+ R" C8 ?
  
• 
  5 A0 Z' K4 y( j
  , {% v- q6 Y4 s' t; h" _$ v      prt2(algo,p);  
  
  5 i4 [" G7 N, _4 ]0 o; f4 n
• 
  ; v+ n& g, V* |/ {
    r, P* ?9 Y  e$ v  f      p=p->next;  
  9 s  R  B: Q, s) F2 o" ?
  2 }3 @4 k2 p5 l: x2 f  y# y
• 
  9 k1 Q& A! ^0 ^4 L5 l3 B' k) V6 @
     }  
  
  0 N1 `+ K+ L. L
• 
  - |3 q' W! l( }+ T" k2 N! F. ?, f
     getchar();  /*压任意键继续*/  
  
  3 a& y1 Q$ |/ j, e* I7 A; V7 D  E, R7 R
• 
  * T2 N3 W8 P. z; E: h) P4 O, w1 m6 B3 q
  ) ^. F3 Q1 c# ]. B( E; [8 }}  
  
  
• 
  4 J9 n& E# ^, S4 \
  6 [# D+ G. P( N" h/*优先数的插入算法*/  
  
  
• 
  
  insert1(PCB *q)  
  
  
• 
  
  3 ?9 N3 w: a9 l% U( ^' A{  
  ; b4 v5 s9 G- x  L0 q
  6 _4 W! h4 K% D2 p
• 
  
    d4 U6 c+ X8 T+ C- W1 O   PCB *p1,*s,*r;  
  
  9 v$ N, ?6 k+ V5 [' y9 B; z4 d- `
• 
  
     int b;  
  5 l; Q6 _; i7 i( ?6 C
  " x6 W$ k' {" P& G7 D8 f8 j
• 
  ) W0 M9 K( {' _
  7 p$ W3 S4 V0 L, G   s=q;  /*待插入的PCB指针*/  
  
  ; M: ]; l8 T; t$ O
• 
  : S* A' A3 r, b/ i/ _" b
     p1=ready; /*就绪队列头指针*/  
  
  " z4 V( K! [# W' \- |" F) d
• 
  
     r=p1; /*r做p1的前驱指针*/  
  
  
• 
  1 R; G7 A+ d  l7 v! ^! l
     b=1;  
  
  
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  . z7 X2 V/ B( B- ~+ |
• 
  
        if(p1->prio>=s->prio)  
  / z2 o  e# ?  _2 G5 `* k
  
• 
  
        {  
  
  
• 
  
  2 w  A4 B5 h" p/ n  d. x0 M/ Q     r=p1;  
  
  ) `8 C8 Y3 b( k6 ?
• 
  
  0 K, N8 C) Y+ ^2 g5 f+ @9 t     p1=p1->next;  
  
  2 Q" O+ ^! T, U; g' `& t
• 
  4 \* C: g5 T7 h
  * o2 ?& @  L! D$ P1 V9 ]2 C/ f      }  
  
  
• 
  ( l& {0 [) y' l/ ]+ z- S
  " h$ {% p$ m2 k, u2 }      else  
  
  
• 
  
       b=0;  
  
  - D  {8 v: a, W
• 
  * K( {# r& |; [0 {: X& N
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  / ]8 e: P+ X; s- h/ s' Q' G
• 
  6 D+ d: G# x# Z4 `. q) k8 g8 ^2 a
  & W  f+ ]0 f, Y   {  
  
  
• 
  
  - _+ I) o2 W. R& f      r->next=s;  
  
  
• 
  
  / h' w% }: A2 `2 s/ d! t- T# K8 m      s->next=p1;  
  
  
• 
  
     }  
  
  
• 
  + s& k( i+ a2 V* P- a2 z  N
    p$ b) `0 n2 z' P# ]2 x7 {4 o   else  
    t+ B9 G: e, f7 B' V
  
• 
  
  1 l; V: E" C- j3 S( \   {  
  
  
• 
  ) U% H+ G5 k! |7 A
        s->next=p1;  /*否则插入在就绪队列的头*/  
  
  
• 
  
  + g# c1 h% F4 |; C      ready=s;  
  
  " R! a, d) B- D( w2 }+ g+ o( V1 r. t
• 
  & Q, h3 i0 }% x% W* X% \
     }  
  1 q* |8 q0 @! X; d* Y
  8 O# z) _% j# x1 u/ J7 G
• 
  2 I* t1 }  s, |5 A4 T% |4 s  z
  7 h& v- \3 X- l  s; s5 U- _8 C" ?}  
  
  * n! n) i' I) n2 l
• 
  
  /*优先数创建初始PCB信息*/  
  6 \% P! ^' g0 O+ O+ J2 V, T
  
• 
  
  8 y' _- i' O7 y6 vvoid create(char alg)  
  
  ) h, V1 V+ U: B/ J" I% `
• 
  - x5 t: y+ J% Y- A1 l- S
  ' ^; A/ C' Y1 \{  
  
  
• 
  * \3 s5 \& y4 ~
  ; X, Z6 T* y" O   PCB *p;  
  & V7 B9 G4 V8 Z% |+ }
  : K* P2 V0 r1 ?7 P2 w
• 
    g/ g6 C  E: \
     int i,time;  
  / Q5 ?8 T5 r' n+ W; N
  9 z8 s$ m% }* k3 ~
• 
  
     char na[10];  
  2 W+ T" W0 d9 u) l: F
  $ \5 f/ V4 y" Z# Q4 Q8 t
• 
  
  & y- B1 g; n* z* j% t) m6 H- ?1 e   ready=NULL; /*就绪队列头指针*/  
  6 m+ E) C# f7 B! v( ^- t; K4 @  O
  2 B" L5 L/ F+ m& K$ G
• 
  # k) S2 [* }; `- @3 j
     finish=NULL;  /*完成队列头指针*/  
  
  
• 
  
  ! r  [% a% _! c# n3 a9 Z   run=NULL; /*运行队列指针*/  
  
  * N! ?8 v% C2 |+ B6 u7 W3 O
• 
  
  ) a$ B& C8 q$ p/ [* ^   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  9 ]( }' O/ u& F( J) U, }
• 
  & o. ^3 g5 K9 k0 u
  & m0 m. P0 r% `: a   for(i=1;i<=N;i++)  
  
  
• 
  
     {  
  8 ]% r) S& r9 E) x% s) M9 |
  
• 
  + }5 k# h4 X# b' ~
        p=(PCB *)malloc(sizeof(PCB));  
  
  
• 
  7 i% ]+ Q; ?% ~  u7 v6 B8 j- J
        scanf("%s",na);  
  ( w# l/ p/ ~, }' M! R/ y* N/ i
  / b; Y4 G% c+ Z" v9 }9 d! E: \: ^
• 
  
  & S7 D4 B2 Y, B- J8 B  u0 _      scanf("%d",&time);  
  
  ( F9 D. ?" I" u; J' C4 E
• 
  ! S- y( g- B5 v! r8 y4 e+ N
        strcpy(p->name,na);  
  7 [. i! [0 L: ^7 F& u
  
• 
  6 W) B5 K0 X+ @( C- I
  ) @' a6 h" L5 m- e, Z' v2 ?      p->cputime=0;  
  3 C" [- d8 O' d. |' T* k) c: F6 d% M# [* ^
  
• 
  
  * F- n0 y0 f+ g% R$ a1 @7 g# Q9 E8 @      p->needtime=time;  
  5 e. ?+ @8 Y( B7 s0 @+ w, L7 w
  
• 
  + X* v3 I0 d; ?( A6 U
        p->state='w';  
  
  " A' P8 d' E. o5 Z; l6 v
• 
  
  2 \5 i* ~8 S! x2 C$ M: W3 Q      p->prio=50-time;  
  ' \+ Z0 C0 n( T  {5 y
  
• 
  % B# P- ?4 @. G2 Z3 D
  & {/ z' ~2 p2 v9 [+ l1 `5 I  I      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  
• 
  
  , @/ e8 w. {7 J     insert1(p);  
  ! k4 _* F" o" i8 _& V1 p
  
• 
  
  1 s8 l) ]$ k3 h6 z' Q      else  
  
  
• 
  9 d2 b4 l  f# H6 _. d  g; T
        {  
  ' V+ N, f, I, b6 G6 M# Q7 m% M
  
• 
  
       p->next=ready; /*创建就绪队列的第一个PCB*/  
  ! L4 n% s- Y, C& D' L
  + ?4 w! l9 E' J) S9 t
• 
  
       ready=p;  
  9 B. ?& R: u$ S
  , }9 N- G) `! Z7 \, w" L6 G, e
• 
  
        }  
  
  ) S5 ^' c# E5 n
• 
  , [. G# v) J/ z% p" c
  3 }7 U6 P: U4 O3 R   }  
  
  
• 
  
     printf("          优先数算法输出信息:\n");  
  " p/ p9 j7 i6 k& H1 ^
  4 H/ F5 C1 Q+ L. V
• 
  
  ! c2 F8 k% y1 j8 C0 q   printf("************************************************\n");  
  
    ~) y9 f1 I. [3 c, Q5 V
• 
  
  3 l$ v9 j/ j' N. z* E   prt(alg);  /*输出进程PCB信息*/  
  ; J8 X* G' P! Y" |( j
  2 x4 t! H+ Z: x
• 
  5 }2 R: `! a$ e9 v+ Q0 k
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  
  0 h' }6 F* ?; l# e6 s   ready=ready->next;  
  - j$ ^9 I" o* D9 Z4 m0 p9 J& P- r) K
  ' s; x* S! J9 w  G1 E: v
• 
  
  ( _. J# Y$ H  E, s: L1 I   run->state='R';  
  & i$ ^  }# u% }7 h3 l
  & X: t  I1 K! Q, _! G. M8 L
• 
  ) X4 B3 ^1 z  L1 T% |
  }  
  
  ' O+ q- Z! W' ]
• 
  2 J: X5 w6 v( o- T
  /*优先数调度算法*/  
  * a6 `8 G9 ?$ F; K; \! q
  8 V5 L" P9 @5 l# u
• 
  + [' x" z  Q; m1 x+ J9 X$ J
  priority(char alg)  
  
  
• 
  ' Q& b4 m" B3 b$ \  `7 g. W+ N0 _
  {  
  
  % Z9 N2 j5 @5 s. [" Z- a: O
• 
  6 [. G" @1 |" \: L2 g* p( |
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  % C: ]+ Y5 M0 ~
• 
  * y  K3 x& e5 Q1 }% S" I
  4 w1 r  ]9 r2 L- Z   {  
  
  
• 
  
        run->cputime=run->cputime+1;  
  
  # q+ ^7 _, G6 z% E
• 
  , r( S  e* T$ G  o3 l
  % m- m9 S8 o+ \4 d# E) F! Q      run->needtime=run->needtime-1;  
  ! I5 G( z' X* \+ c& K9 ]
  
• 
  
  % g+ @7 P7 {" h& c      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  + e6 \- O" C4 l; }$ h
  ; B3 R! @: Y4 W; e- i7 G6 o4 S
• 
  
  5 V- {# [5 P6 K) b      PCB *p;
  
  
• 
  
  ; c* J1 O. ]4 c( r      p=ready;
  ! h) d: I4 ~( h, l4 s/ z
  
• 
  5 y  f5 {+ e; p' }2 n6 ^1 h
  + L4 v7 B* P( Z1 n/ w! |      while(p!=NULL)  
  
  9 U. [/ m: d5 q3 u: g& {& `
• 
  
  ! ?0 n2 O" E$ ]  N      {  
  & ?+ c, B: d/ O( ~- u3 E
  9 E6 h2 C4 i+ ?6 J* ~, P; T) p% y$ K
• 
  
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  & T9 Q. @! [* _& o* {
  9 A8 S3 f# I! T8 p, ~' @: O" @
• 
  
            p=p->next;  
  ; v' N6 [; F; |
  
• 
  
        }  
  
  
• 
  6 S' r5 `* f0 m5 g( \* R) r
  # h2 z" Z* _8 T2 k, r: q  a+ g: x/ ^      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  ( ]0 X3 X/ U5 H" l2 b- d
  
• 
  
  5 V' L7 s: T! I0 G, ]      {  
  
  
• 
  1 l* F; }) |- a6 B# {
           run->next=finish;  
  
  * z1 b6 l: |3 |" A
• 
  
  * ]* H1 L7 m$ s, f% a         finish=run;  
  
  ! x* C$ T# Q3 n9 u
• 
  
           run->state='F';  /*置状态为完成态*/  
  2 y5 X% ?# ~0 c- _1 h. Q9 g  F8 m9 A
  
• 
  
  / b6 J+ t& x8 Q) W0 f. I& d. R         run=NULL;  /*运行队列头指针为空*/  
  4 i% h4 e7 e& A! r2 j( t
  % I1 X4 X3 l+ n2 m! ^. v; S
• 
  
           if(ready!=NULL) /*如就绪队列不空*/
  
  . L# r# m! E/ `8 o& L: P) [. \2 X
• 
  . e. b: `0 u- N0 l
           {  
  0 j1 T( T4 ?) P0 n4 Y) H  L
  4 q+ L$ [& Z6 \* Z9 o4 x
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  ! Y1 r% E, @# A: R" I! Q  {5 x, H0 ^
• 
  ) N0 i0 @0 z& h, z' ?; u
           }
  
  
• 
  . S5 j; I0 u% k
        }  
  
  7 r' n  T) w$ d, b. i0 q2 U
• 
  
  & G, F# y, P. N- I- f8 ?      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  ' n! Y+ V  w# s7 y2 c5 n
  9 y4 W& @# ?4 j
• 
  / e2 a6 L2 f3 Q/ ?
  ; l2 X3 s' H  {) V2 J     if((ready!=NULL)&&(run->prio<ready->prio))  
  4 B) n1 K  {4 O) v. \) S- d9 h
  4 f' w( p' D4 o/ \$ k9 ]4 ?
• 
  
  ) @! A7 I( d6 L; g6 B8 b; J$ a  j$ \; H     {  
  5 E* z) B2 W2 i$ a2 w  y
  
• 
  
  5 [3 `# B5 }# G1 ?; C        run->state='W';  
  * R: F+ n' ~; g- d
  
• 
  
          insert1(run);  
  
  
• 
  
  + \4 t0 {: w- Y1 p0 l$ u% i        firstin(); /*将就绪队列的第一个进程投入运行*/  
  " G2 P, f( B5 ]2 z; R& P
  & R0 _6 m; d5 }1 k9 h4 q: g7 L& m
• 
  
       }  
  
  6 l  c( p; z3 ^$ _' a. a2 M
• 
  $ o1 D7 K: B( V$ E, R
        prt(alg); /*输出进程PCB信息*/  
  4 ^  Z( y$ z, D+ J5 h
  
• 
  % e0 `" w0 n& A1 S  x* o! u
     }  
  : v2 `+ }. t  `
  3 u; C9 j7 {5 k7 X9 c" ?; d
• 
  8 q" W3 S/ h" ?' N
  }  
  / e! P4 e6 p+ j4 l: g/ v
  
• 
  2 a; j4 D5 g9 b: S$ W
  $ V$ ^; J! c; D* {, c/*主函数*/  
  ) k+ H" e) }4 L# d- u; Y; L
  
• 
  & z5 B# i9 {& T7 |
  + J" j" C2 N; w5 ^7 u8 zmain()  
  - z  v0 i( h8 M' |, g* M7 R4 @
  9 t' I3 N. ?3 ]3 z! {! v
• 
  0 `* {4 j) h+ \& p" X% Q6 J
  - [3 l9 I+ ~) h& u0 v/ f{  
  
  
• 
  8 u- P4 p$ v2 x$ }1 z3 x
  2 C3 H% v' k& u. m, B   char algo;  /*算法标记*/  
  4 x. |* ?: n: _2 j$ U& @7 N
  
• 
  
     printf("输入P确定算法：优先数算法\n");  
  
  , Z8 \: [0 D2 a1 J# \
• 
  
  * H. o* ]8 a: u. d% H2 r   scanf("%c",&algo); /*输入字符确定算法*/  
  ' u! H  n8 U* \
  
• 
  
  ) L3 c; U  e! ?. w2 _; F3 I   printf("输入进程数：\n");  
  & b1 Q8 [" N* U7 ]# H; f! r& R
  # j5 W' ?& Y, B3 U9 j# K" Y) C0 }
• 
  % b9 W, o; h) _. f
     scanf("%d",&N); /*输入进程数*/  
  
  
• 
  
  / j  W  v. _- O: Z   if(algo=='P'||algo=='p')  
  
  
• 
  & L0 l( c0 H" n" A  F
  - Z. T+ R0 N7 y- B   {  
  
  
• 
  
        create(algo); /*优先数法*/  
  
  
• 
  
  ' v5 _& b3 D- k9 B- A! k      priority(algo);  
  4 S& d/ K0 G* H# T" v+ d, `6 V! |
  1 i  b9 R2 k$ H2 h. T" |
• 
  2 F8 o3 {( f; x5 ?- ^9 ?! a2 y
     }
  $ ^0 P$ V( s. @2 w. R
  , K5 W; u% k" P2 ?
• 
  
  * k7 W# O, z# L  o$ P! l: \' E' \6 z}
  
  ! I/ J$ L. m2 C/ E: y
  

9 U! o: @# ~: b& F  L" _3 ?输出结果：

/ m1 S3 P6 l& P8 B2 _  m原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

! ?3 ]0 h0 @9 T/ a