优先级调度算法

杨利霞

2 F6 N! [/ W" W; o& u  S' ]- |优先级调度算法

算法介绍
优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
( O$ f+ H; O8 L3 F- S, H# l系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
/ C) S! y2 d% {1 ]2 u2 h: m' a1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权
/ }, D' ]8 l1 O! U& u: p; F$ W

算法实现

抢占式动态优先权：

PS：本人认为非抢占式静态优先权没有实际价值。

• 
  
  & p- t3 x' d$ r0 P: g, ~. \#include <stdio.h>
  / z( j2 E) R* C2 v6 L
  
• 
  1 {+ m9 t/ L( [6 j0 f. J5 ]
  #include <stdlib.h>  
  , i5 U* F$ W3 e1 w
  & R6 e* q2 J7 z
• 
  
  #include <string.h>  
  
  
• 
  
  typedef struct node  
  
  # K! ]3 w. _0 |& \3 f( w
• 
  
  " E9 p( b1 [8 {1 U{  
  
  / M5 W1 N* X8 R$ `6 Q+ H* q4 J
• 
  
  4 \, n8 ?8 B* G   char name[10];  /*进程标识符*/  
  
  
• 
  
     int prio;   /*进程优先数*/  
  9 e' \  S2 l! `! q. o2 R: F
  
• 
  
  ' K9 j; D0 B" C$ V8 f% K: W   int round;  /*进程时间轮转时间片*/  
  
  1 j6 T4 v5 _3 q8 D2 J
• 
  & ?) ?( Y3 w: t7 ~6 p
     int cputime; /*进程占用CPU时间*/  
  
  - E4 U' y8 s) J) {& P! {1 Z
• 
  ) H4 ~, g  Z" F" T8 r% m
    _: l9 ^7 E3 G   int needtime; /*进程到完成还要的时间*/  
  
  
• 
  . `0 u3 k; p8 v! B# Z# U( h) t, I8 i
  4 T5 ]/ i! s7 Y7 w   int count;  /*计数器*/  
  
  
• 
  4 W' h3 L+ K, C# K5 Z0 m) p% B
     char state; /*进程的状态*/  
  % g5 T1 }" \6 k  k( D: R
  
• 
  
     struct node *next; /*链指针*/  
  ' [# `1 Z) H" Y' E0 }3 |! J0 W
  
• 
  ; a4 O' B- V6 `# @$ R  G- t$ o( q
  % w. j/ X! \7 D, N6 m' y6 ]; m" C: z}PCB;  
  
  
• 
  ) F, z% d8 S7 c( f! }
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  " n% [4 l. f  y/ r6 ?
• 
  
  int N; /*进程数*/  
  
  
• 
  % D1 Y! p& G1 v+ d
  /*将就绪队列中的第一个进程投入运行*/  
  
  % F; x) P, h4 J6 U2 M0 u; x( G4 E
• 
  * h6 S2 [8 m3 N. B; z0 L
  * N4 z5 l* W( K5 Q' Z9 ]5 v  \firstin()  
  & Y  r' N4 M: T
  # c1 b7 E# j- O0 l* a5 t
• 
  . V# I' l# j8 }
  4 P& U8 e) f. ?{  
  4 J, ?+ t/ b9 q- p
  
• 
  
  3 B$ D1 P$ X( p+ _( r   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  % Z& @3 Q/ @' e. ~( K2 I: o* P6 Z+ p
  
• 
  ; P0 ^) s$ D  x% v
  ) ?' ]- i8 r1 v$ B- e   run->state='R';   /*进程状态变为运行态*/  
  
  9 w0 k, w7 ~7 O) H+ _- c
• 
  * P1 t% U7 G4 j
  % k# r& W+ w" ^, e. v! [* [7 f   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  6 P- V  K) q" ?" T! d( p6 f
  
• 
  
  9 M* U. l, y# q; {+ u  M' I  P}  
  
  % P9 z! N* g0 W- M8 H  W
• 
  1 F0 I2 @7 R3 V0 L  X. q
  /*标题输出函数*/  
  
  
• 
  
  void prt1(char a)  
  7 u# I6 J" y/ r2 F9 @8 ~
  
• 
  
  " z% O  N0 s; |2 _{  
  9 _) k! O5 R+ o" {  M$ R1 w
  
• 
  % b6 {$ E. E3 J% i9 ]3 M: b8 n
     if(toupper(a)=='P') /*优先数法*/  
  
  
• 
  8 X0 o. S, T% p, v- o
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  
  " z  p! ~2 j; z; Z   else  
  
  * R/ Y) `% d! Y3 k4 ^# d
• 
  
  $ Q! y0 Q! G: j! }% c      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  ; T# D9 @, _) k5 R  ]4 ?9 L0 R
  
• 
  
  }  
  4 S. i! Y3 H1 u' P. U0 z' N# P
  $ v) @9 t& F4 \" E8 h
• 
  ) y; A* u+ ^/ ?0 ]3 L
  3 \% {3 g3 S: m8 D* p6 v  G0 n8 m8 H/*进程PCB输出*/  
  : a% K& I3 k- p' l; G; ]1 Q8 A
  
• 
  
  / d0 _/ Z4 n* H% tvoid prt2(char a,PCB *q)  
  
  
• 
  
  {  
  
  ' T/ z1 ^6 G/ `; i8 ^7 U6 R
• 
  3 H, d: J4 m. Y! V& ?
  ! Q# h7 n3 V4 S. A   if(toupper(a)=='P')  /*优先数法的输出*/  
  
  / X" i6 e8 A' X; h: N
• 
  
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  0 W/ O/ t1 j3 v8 f# ^
  & p( h% m; n# }: s- J1 ~: h
• 
  - u5 }. o. v6 F
  . B- {. U  h  ^5 W  q2 U       q->cputime,q->needtime,q->prio,q->state);  
  2 ^6 g8 M/ w9 X0 `
  4 d; G/ m: O: k( k' \; P
• 
  
  # z* _( X2 }! }6 l$ U   else/*轮转法的输出*/  
  
  : ~0 Q' ?1 L, l1 O2 i, `+ }
• 
  : I/ {2 {8 @& p; @" ]
  2 m  n; ]9 r0 i: ?7 }! }" ]      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  
         q->cputime,q->needtime,q->count,q->round,q->state);  
  
  
• 
  6 F! z2 v+ s- |- Z
  }  
  8 T+ l2 Y7 ?% I$ ]4 Z4 K& e+ g9 `/ l
  
• 
  / T/ ^$ |# U0 S
  /*输出函数*/  
  
  & l. `1 p3 i) {. O5 k
• 
  5 X+ L8 }! ^% t3 m7 S6 H
  void prt(char algo)  
  
  
• 
  ! r* M  o8 n- r0 ~4 q& ]1 |
  {  
  1 Y, r. d0 r: \% A
  
• 
  + V: r; d5 b  C  o/ B' v: @/ m
  9 o# p# l+ ]. R% W6 t% d   PCB *p;  
  5 o. U3 F- s7 `3 t6 a' {
  
• 
  
     prt1(algo);  /*输出标题*/  
  9 [6 c7 i/ e1 m) Y9 U1 O/ q- A
  
• 
  
  : E4 Y" o7 q8 [, @9 L   if(run!=NULL) /*如果运行指针不空*/  
  2 z& ?" Q7 A9 B: ~1 ]
  0 H7 q4 ^0 e3 p# ]3 ]
• 
  
  # K8 ]4 z  b- D7 R      prt2(algo,run); /*输出当前正在运行的PCB*/  
  1 I3 I4 i' A7 t' o8 ]
  5 f9 x7 l! s* u
• 
  3 P; y7 j+ E/ N) M0 s, F( u+ Y
    R+ Y' E0 O! I! R$ p   p=ready;  /*输出就绪队列PCB*/  
  ( J  V% f, \8 h3 d/ X% W
  5 v" v( m8 a! p
• 
  ; x! Q# q) ]) L* w$ D8 r: s# o
  . m& P4 w) \% C- x   while(p!=NULL)  
  ' J" M: ^$ R: A9 z
  
• 
  
     {  
  
  
• 
  
  - w3 {5 Y- E& k! r9 }7 R7 ?      prt2(algo,p);  
  
  
• 
  ( i9 {0 H: w0 L3 B
  5 s. [* r( R: W" T      p=p->next;  
  7 Z+ S0 N- S9 J1 R
  5 z. v0 G% d' {4 b" k7 p& o0 X* H
• 
  
     }  
  
  
• 
  
     p=finish;  /*输出完成队列的PCB*/  
  
  9 K5 R6 M6 {' }! \. y
• 
  & d5 Y8 W7 l' n) L( `8 E9 V* Q/ M
  + @; Z& v4 x! \" m- ^: }   while(p!=NULL)  
  ! B3 p3 A* ], f! P$ V
  
• 
  ) ^+ Q8 U& {& {
  . l$ _* w3 H  D) T   {  
  
  
• 
  
    k+ J# S) j, i0 N1 a  u! D      prt2(algo,p);  
  
  
• 
  % h2 P/ c9 D) L( n3 ~
        p=p->next;  
  
  ; e5 K& j4 \, g
• 
  3 r1 c1 r9 N& D9 U$ @9 E. U: D
  5 e4 _9 X$ w5 i- ~" D   }  
  
  # M3 ^# a* {4 a7 z% |5 E
• 
  ' M! _! C5 [+ k% D) V8 z1 x' Z' j
     getchar();  /*压任意键继续*/  
  + }9 A& ^' s5 w; F$ i
  
• 
  
  . t7 O. w" ]1 `) v6 b1 u}  
  ( {/ F0 }* E& v+ ]
  
• 
  
  /*优先数的插入算法*/  
  
  
• 
  8 k) U4 f0 ?) f( ]6 v$ I3 Q7 C+ l
  8 L+ p7 X5 k4 A; W/ h' T2 ?insert1(PCB *q)  
  
  0 @$ M$ _: Q* i. Z; M  X
• 
  
  {  
  . f  J6 C7 p! d  j9 @# l/ M0 P
  : ^/ m2 J: b4 n; ]; O$ K6 c
• 
  
     PCB *p1,*s,*r;  
  
  * Q* p* d, S: v( M8 ]# ^
• 
  
     int b;  
  
  & ?4 `! z3 D. n% a& l: ~1 G) \5 n
• 
  ) f: L: _  _9 E9 ?9 {4 b& t* O4 K
     s=q;  /*待插入的PCB指针*/  
  # N8 g0 A' z$ c/ z% e/ a! k
  
• 
  ; w& B7 g( A  i. u. I$ `! t
  / e; u5 J7 w' D; L& ?   p1=ready; /*就绪队列头指针*/  
  
  7 h0 z. ?  r4 \$ k7 \0 h
• 
  & d" ~/ c, b, h5 F6 k
     r=p1; /*r做p1的前驱指针*/  
  ( q, j4 M. k- M4 B( A1 W) ~" e" m
  
• 
  ' j) y' d$ a7 G
    P$ W9 O% K5 j% Y   b=1;  
  6 z5 J5 U& E  ]5 C& y
  
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  * d, E' z. z/ o9 l
  
• 
  2 {) M9 E/ `- c" ?. z
  % E$ y9 F/ A" u- q2 _3 Q7 V: A      if(p1->prio>=s->prio)  
  ' Z3 i$ j; m7 n6 {: n
  * v; i* J) h4 J2 K$ F
• 
  - n# S2 ]) b7 ?9 G0 I6 t( [
  $ ^! q3 L; \5 H$ ^. h2 T      {  
  
  
• 
  $ r: @) T) f0 O! m+ k1 b' \
       r=p1;  
  
  1 L0 T4 f1 o1 a* U4 j, W2 `
• 
  4 [. _: b- G: j( P/ ~: I
       p1=p1->next;  
  
  % w! @0 M1 m, t3 \* ?* s
• 
    Z! t3 \6 ]* Q1 V: ^3 _! j8 J$ E5 a
        }  
  
  5 k4 D) E; |& {( K0 M' C0 ]
• 
  & D6 a+ O- x  R# r$ `0 F6 Q
        else  
  4 k$ d/ u, a3 \3 F
  . U4 z+ }. O9 n  ~3 l& a
• 
  
       b=0;  
  
  " |: @6 c" o: ^0 b
• 
  # Q, q. v& l9 ~
  : i9 b; t0 u/ ~8 y   if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  ! D, y/ L4 k8 k/ i# ]3 J8 [  ]9 K
  * |) d+ Q$ [* A4 M3 E
• 
  
  8 [; D. s( i4 d& [( i) m7 A   {  
  # M7 |; A( L$ L+ N; L
  " `8 `7 p9 U- e& Q' W
• 
  
  : M5 b: U  \6 R) M# x      r->next=s;  
  
  1 N' c: b2 P# \' v$ \! s8 O2 p
• 
  % G; P7 L# i" j# t) a2 A
  " D$ ?2 K# [5 }0 R; @      s->next=p1;  
  
  : G# f) `4 B; W  ~
• 
  7 `" j3 ^! J! |- z- x
  + u; m6 |3 Q- I$ I* d9 p# f   }  
  / N' Q$ X1 d4 T; S0 B  D
  
• 
  * F! Q$ i, m  d
    v  y+ R, ^/ c3 ]+ P& |0 L: p   else  
  3 h6 f* i: @5 y) z% u! B% Q
  
• 
  / d6 k8 m6 e8 ]& l1 u
     {  
    p* u( C1 G$ t  M3 T, H, }
  . F1 }: `2 z) Y% H1 ?# \
• 
  7 Z+ K% I* B' {
        s->next=p1;  /*否则插入在就绪队列的头*/  
  / W" J9 O7 M! b$ P" ^7 b
  % E& p: d  g; c) s
• 
  0 k5 U6 c6 p5 P
        ready=s;  
  3 U: {' N# Y( B+ e. q
    }5 ~+ |9 s; r9 I6 h
• 
  
     }  
  2 _) @8 i  q3 i3 R) W. {
  
• 
  
  8 F, B5 S' Y9 p/ |, Z, G}  
  
  ) ]- B0 e0 a2 N: @+ K
• 
    @5 s8 v& ~/ M! P4 G, W) l
  ( n8 ~' {3 m- b( R: O: S( g/*优先数创建初始PCB信息*/  
  4 x, X( B" \- I% M5 R0 F3 }
  
• 
  6 {8 v0 m! W+ q
  void create(char alg)  
  
  
• 
  
  {  
  
  2 Y1 ~! G/ k; F3 `
• 
  + p. m2 i! U' H! ]! C* R- c( G
     PCB *p;  
  . S' S' d, F0 y
  % S4 |9 p$ d8 i& g
• 
  . y1 t# ^' a' Z% Q5 Y' T
     int i,time;  
  
    R( v$ X- ]6 x: k* M: v! k
• 
  
     char na[10];  
  ! j  `8 \! y. L
  
• 
  
  ) {1 n, [5 l+ w) x& g) ?   ready=NULL; /*就绪队列头指针*/  
  
  3 U- Q8 M( g1 \- m- I
• 
  
     finish=NULL;  /*完成队列头指针*/  
  
  ) W% l7 E( T* }
• 
  
     run=NULL; /*运行队列指针*/  
  + E6 M" R( H5 W. ?9 n, K
  
• 
  8 w9 b* X$ q( @" d$ U
  - `2 T+ z) `, B1 J   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  * b: Q9 _6 }5 ^# H$ }4 V
  
• 
  $ ^' @  q& ?7 \
  ! H8 y; K/ C& P1 n, G' l   for(i=1;i<=N;i++)  
  , \  X. a1 Z& Y% J; [/ J$ }
  
• 
  
  $ H0 T! M# ^. M* v( {  c$ D- ?   {  
  
  
• 
  
  * C6 c  H* M( M  i6 l" q5 }/ Z      p=(PCB *)malloc(sizeof(PCB));  
  1 x7 {" X- B3 O# s& r) q& m3 g
  % M1 ~3 o) S3 U% `# p6 c: b0 N
• 
  / D$ F& M' l1 K) j9 G4 w
  / G* E! n, R8 J0 k( t/ k3 v      scanf("%s",na);  
  . K/ `/ R6 D% S0 C
  
• 
  
        scanf("%d",&time);  
  
  
• 
  - H1 K- M3 d% m/ E' g+ j! \
  + N! ]% c+ b' F( Y& u      strcpy(p->name,na);  
  ' r' I# y; i7 e' k0 Z+ X3 w7 \
  $ j& V# [( q) m) {2 C% N
• 
  
  ) |' e. U8 N0 z/ {      p->cputime=0;  
  
  
• 
  
  # a4 |1 Q# n4 C* m      p->needtime=time;  
  : x" C# e4 o' {
  - W2 m$ ^3 D3 Q! m) p# U0 r+ X2 Q
• 
  
        p->state='w';  
  $ M8 ]. y3 Y. W0 H# @( F
  & N- @0 d# m( [, i, \3 _+ V- a0 ~
• 
  : P0 @' J  w2 t" A/ ~1 e
  , D) k7 X( y( g! S2 t9 J$ @" |      p->prio=50-time;  
  4 ~  [& q, i7 h- k/ H! }. h
  
• 
  
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  9 e3 E$ O2 t* O5 S9 D7 z- t
  
• 
  : `6 E) j+ i* q& e( a* N
       insert1(p);  
  $ ]. M7 ^) x( O, {
  - c$ z+ K" P: e% t! l
• 
  & S' B( x7 z8 h$ T9 W5 x8 }. o: a  A
  ! h# q# @) A& e9 M' r      else  
  2 q" ?1 q5 L6 k% b  ^% p
  % w. Z* K1 ?/ L
• 
  
        {  
  
  ; }6 B" r+ b: r, F' M
• 
  
  ) q8 @8 M1 g6 t     p->next=ready; /*创建就绪队列的第一个PCB*/  
  $ b2 {5 J/ s; K# s3 }  T
    F$ Z0 a8 C$ d& S% R! r& \
• 
  4 l' U* ~( A* M1 A% k  Y" d
       ready=p;  
  : h! _. h( p+ \* Z
  
• 
  ! N% T7 c' o8 C. B; E3 W( I8 x) N, J
        }  
  
  
• 
  3 T' d5 ^, p: ]7 j. Z8 S
  $ K6 u& Q8 c, z  H" X   }  
  
  6 @: o& B) Z" @2 \: J  s! o# `
• 
  6 s# ^8 @$ r" \3 J! Y# W: ?
  ( t8 i* \0 J9 s9 V: G1 |) |   printf("          优先数算法输出信息:\n");  
  6 j0 i" \3 ~& q% v
  
• 
  
  # N$ A: n: j; ?( P5 {   printf("************************************************\n");  
  
  
• 
  
  + e; A3 z- Y4 Z. L0 r   prt(alg);  /*输出进程PCB信息*/  
  $ y  u- K" I6 j8 g' n
  
• 
  
  ( n  Z7 ~0 [) T; Y0 P% C% l8 E   run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  $ p! }8 J. R9 H" w5 i
• 
  ; j" g; b8 A" K
  4 l% p: A/ o' a, s* D6 J   ready=ready->next;  
  
  
• 
  
     run->state='R';  
  
  7 t$ ?/ t( E7 v: s( a- f- W/ u; h
• 
  5 Y, Q( w# @3 C% F
  : h) s  x* j7 |. j}  
  ) j2 l- W: i) Q: \5 t* z
  3 _6 A2 x  {/ Q8 z8 Z* E' k4 E
• 
  
  . @( ~5 s. a5 `* m! K6 X" x' f/*优先数调度算法*/  
  
  
• 
  
  2 B7 [: Q' N* _/ epriority(char alg)  
  
  ) J6 l2 e8 X; e5 x
• 
  
  0 e5 _# b8 R% u" ]* I{  
  ) y0 N. ^0 d, @% S7 q+ s) \" d; Q$ w
  2 |& n" w# ?) C( C  c- E
• 
  6 h7 b% _! b$ [. |  Z
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
    D2 Q% h% [3 h1 @) \; O
  0 M9 q) h' S! j/ E
• 
  
  4 X* ?: q8 E+ y' X; F. U   {  
  
  
• 
  
        run->cputime=run->cputime+1;  
  
  2 a0 D: O  q+ F: D8 n% u% }( B' l2 N
• 
  
  + F. u1 D! x  f. a% @      run->needtime=run->needtime-1;  
  . N. A$ B: L) I8 p- v( x; k# z4 u/ F  P
  , V% x( s* N! Z& k
• 
  
  : }# k6 V. u- U, p, u( h% c      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  1 C7 `6 \. u! F. _8 R, }$ A
• 
  
        PCB *p;
  
  % Z& Q$ y/ ]4 @
• 
  
  # Z. z1 O7 [. W- l+ t5 [7 h& A1 V" P      p=ready;
  
  
• 
  ! A6 m" Q( W# `2 r) ]/ c! W
        while(p!=NULL)  
  
  
• 
  ! @# l/ ~* H% ]1 n: w
  ; J4 g8 m$ s( W      {  
  
  0 U! P" `# V* x2 a
• 
  . T. S& F- @' W4 C4 `
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  - x, i7 g7 U% V
• 
  ' A" V# [  N' Z1 H
            p=p->next;  
  ' @5 p1 z2 f. q; y2 ]% U
  7 I# h7 F: }# z- ]# w2 i0 Z
• 
  
  3 }  ?$ }$ [" U5 G      }  
  & s) D. E5 e/ i( Z  s; q  C( }
  
• 
  , R7 p9 p: G  ?; m
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  ) Y2 n8 R) }/ i" g* [6 h
• 
  
        {  
  # ~: s# D* {& u+ [+ G: p
  
• 
  6 j/ `$ @0 ]0 u, a6 U& o
           run->next=finish;  
  
  
• 
  8 o1 R) c* G0 H  f' F; s5 J
  , H' Z: G" P0 j- b' g% F9 A         finish=run;  
  
  
• 
  2 Y' h2 A& |+ c0 s% c7 X, z
           run->state='F';  /*置状态为完成态*/  
  
  
• 
  : [1 r5 F4 ?9 b3 ]# y6 \; W
           run=NULL;  /*运行队列头指针为空*/  
  
  
• 
  * \; K. a& C, V
  & w% N& g4 C  e$ I* b         if(ready!=NULL) /*如就绪队列不空*/
  
  # u) |1 p/ i& }- t& a, R& C/ P
• 
  , u5 b7 K' z5 v1 u4 E
           {  
  0 S+ [2 A% T) E3 V6 b% ]
  
• 
  # C6 _$ s) o. L
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  & }" V1 v- Y' s* a& S" o( T
  
• 
  * \, G1 c" O3 L/ H
           }
  ! ]% F0 M* {; Z: |
  
• 
  
        }  
  8 P' M& p# T  Z. {. z, k/ g
  % i; h) c# N$ |' |  s
• 
  
  4 e: V  r- d) d" H' K, b. S      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
    e4 M/ K$ |  a5 \' H/ i
• 
  
  % U' O2 U6 j/ J2 M     if((ready!=NULL)&&(run->prio<ready->prio))  
  
  - D* o5 t* \* g2 s% u* E0 _
• 
  - m0 f2 k! l3 s0 D* _: ~
  ' k5 H  `) A* w& C/ M     {  
  
  - R0 |- `' ]6 h1 F$ S5 k5 u
• 
  
          run->state='W';  
  
  
• 
  # }( o; a) l6 D" l
  # Z  O3 G+ k+ t2 r7 S  |4 a/ D2 J% J        insert1(run);  
  
  4 ?% U9 D, t, s: y5 i0 d! w6 w
• 
  8 v8 Y: Y3 |, V- _9 P5 o( `# I
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  # w' y5 i5 ~( v" c
  
• 
  ) b9 G9 |; e$ d9 p' ?% j( W2 v
  # _8 g% p2 Z; K     }  
  
  
• 
  
  6 P# A& a( Q" }2 Z5 F3 P, l4 n      prt(alg); /*输出进程PCB信息*/  
  
  + L" N) s' H5 H: S: R
• 
  
     }  
  
  
• 
  1 m6 v. T5 }& N8 ]2 a$ D( U# H9 k. P
  }  
  
  
• 
  
  & {+ E2 E3 N* e/*主函数*/  
  
  . n9 o2 [& O% a/ \; b
• 
  
  main()  
  
  ( P* l8 t% Z% ?! p* }% Y2 T
• 
  8 B2 j7 q+ l2 N" ]/ I1 n  T
  {  
  / O2 `% z* _) ]; R
  / N) B0 v0 y; `4 C
• 
  0 M8 }$ ^" T+ B2 F; Q- Q; X7 w
     char algo;  /*算法标记*/  
  
  
• 
  
  % p" ^+ K  A  T3 J  Q! S% v$ b   printf("输入P确定算法：优先数算法\n");  
  
  
• 
  
     scanf("%c",&algo); /*输入字符确定算法*/  
  9 t( h& q& u, w4 D: r" R
  
• 
  3 G- o! e7 i% n  S. Y, s7 C
     printf("输入进程数：\n");  
  ; F5 T/ ]/ f7 p' y! i! m* Q" c
  9 ]. [: G4 S9 l; ^/ L
• 
  8 g! r' d/ y4 h% O7 N  d
     scanf("%d",&N); /*输入进程数*/  
  
  ; M3 Q; O' F1 L
• 
  
  9 C' ?# O& s, g   if(algo=='P'||algo=='p')  
  
  
• 
  
     {  
  * d8 t0 W9 C! ], n8 H. w
  - p2 S# c1 w! ^. d" d3 {
• 
  
        create(algo); /*优先数法*/  
  5 H9 ]& E6 N  M' i  f
  . I% Y6 i4 n0 g
• 
  
  0 p/ R$ z, s9 z      priority(algo);  
  
  4 X7 G& G4 S0 s% k& |
• 
  
  ! r* c8 n2 v. l, {' a+ s" C* f   }
  / j- t, p/ r5 w$ z" M( i$ P
  
• 
  
  }
  & H9 \: r; }# X2 \. X
  
  

输出结果：

( h2 o' T& t. Z, ~0 X原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

% C6 ]6 U: C0 F9 o& {. m- A