优先级调度算法

杨利霞

7 d+ c3 E6 j0 D优先级调度算法

算法介绍
优先调度算法的类型（用于作业调度）
% l0 i) d; w  \( l1）非抢占式优先权调度算法
: I0 s% }& }! j系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
* i3 p9 R- s6 e; E* J1 g2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
* H  r, _; j; t8 ]3 a8 s

2）动态优先权

算法实现

抢占式动态优先权：

0 P. x, L- M* z, [5 i' EPS：本人认为非抢占式静态优先权没有实际价值。

• 
  6 G1 h2 j( m8 L( o# D
  #include <stdio.h>
  0 t. m8 ]% B- }
  
• 
  ' a) ^3 l* J# J
  " q5 S# {" q( a$ f; t% d#include <stdlib.h>  
  ! W5 s! E# ^& ?6 H  n$ N0 _+ n
  
• 
  
  4 w2 b* G& z: S) e  K; j#include <string.h>  
  
  
• 
  
  5 p+ Q1 x6 O+ \* N7 btypedef struct node  
  5 |& r( h9 v4 w5 ^# a2 }2 B
  $ L% ]: j. q% F$ [$ a
• 
  " p; C  B4 _" k
  5 f3 ?  J( P7 R8 ~* g{  
  
  , E+ B0 L# y8 l) F, p% J* G
• 
  ) |% C# p2 `/ i% ^
  # i$ U  \/ v+ b- V9 N   char name[10];  /*进程标识符*/  
  % P; z9 }& @7 d& ~4 ~" m
  
• 
  
     int prio;   /*进程优先数*/  
  
    R" J' o  k! R) |- E, I
• 
  " E( ~6 W* d, `1 K, }
  ( o: W7 U5 K; Q% U   int round;  /*进程时间轮转时间片*/  
  
  
• 
  
  & n$ G+ A8 o7 k( V: U& U$ O   int cputime; /*进程占用CPU时间*/  
  5 h" w! S% p8 L
  * x) A$ V: u  \$ ?
• 
  
  7 E  ]; _; H7 w" R: a5 N   int needtime; /*进程到完成还要的时间*/  
  5 Y) P( [0 c4 `& M: F/ Q
  . G( b' V0 z* i3 W0 x$ S1 g
• 
  
  ) i9 D% W; ~: T4 P+ i% r8 V0 T  o   int count;  /*计数器*/  
  ! T; c& I3 s7 i7 x  T
  2 }+ T9 y# s, Y% v) n
• 
  * |0 R/ X; T3 g3 h1 `% L/ x
     char state; /*进程的状态*/  
  ( _3 x( o3 H1 ?1 q
  0 d$ _' T6 b+ O* }' _
• 
  
     struct node *next; /*链指针*/  
  
  
• 
  5 z6 W2 r* n# c1 C5 D2 Y" u- {: Z5 n
  6 w# T) T9 ~/ V* u" K9 F}PCB;  
  1 F( K* I! z( T2 I
  # O5 y* }6 g" M( q
• 
  
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  5 b( f: U/ s3 g' I$ X
  & A! R' w5 m; W6 R0 C- f& x
• 
  $ B. T; |- i% H  p
  int N; /*进程数*/  
  ! a# w6 S+ o0 U. S
  
• 
  
  1 `9 B1 p5 W8 U$ [/*将就绪队列中的第一个进程投入运行*/  
  
  
• 
  
  firstin()  
  
  9 ^! C# M* h/ \( P- b  k
• 
  
  3 n1 I; N1 y2 n{  
  * L5 [" E. Q; ^. G* V
  
• 
  
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  
• 
  . F/ d1 I4 G3 s: v* ~; S
  , f& }- n* `# I) s6 D   run->state='R';   /*进程状态变为运行态*/  
  
  
• 
  ' ^8 n, _) F* r* K4 Y6 i1 p; c1 T
  7 }+ q  t$ C$ ]   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  & d! M; E( v! b; O* v% B5 p
  5 J; i* [- T# e. h0 M+ `
• 
  ( `, I1 r' _/ Z6 m* F2 U: }
    a' L7 _# `2 }0 t& I, e}  
  5 X) `( z0 B1 h! S1 U
  : o$ q& F) Y6 G! x3 v" z
• 
  3 ?; R) K6 h& w
  # P. E& N$ n% Q, _/ L$ q' D/*标题输出函数*/  
  8 ]% v4 C5 s5 O
  
• 
  ) F' q' a; E3 }0 w
  void prt1(char a)  
  
  3 O9 Y% L, g5 k- Z% l
• 
  * x+ O$ S4 c5 `9 S3 u/ g- ?( O
  {  
  
  ; I0 n; K" a3 [) o  q2 N" `% l2 c
• 
  / k6 m5 l8 t0 c3 B5 I
     if(toupper(a)=='P') /*优先数法*/  
  
  + a7 n* h" }# A( l; z9 h
• 
  & ~: H0 N% F# c3 `4 I
  : e1 j2 G8 |0 k6 [4 |      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  
  & F( C# r& [0 b   else  
  ) J+ W  L- v2 e  x
  % n! s0 B7 h2 |% ^" ?+ x9 K3 o
• 
  
  # G, E: B9 ^, V+ m$ z- _0 b      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  1 Q) b4 ]8 ]% h5 x* ~( V
• 
  & `# D; B  A# ^" g3 ~
  }  
  : p) r8 r/ Y7 P9 i1 `
  
• 
  
  # H5 O- F' m- B' t( T( w" b/*进程PCB输出*/  
  
  ! O4 E9 s1 X( @- l" ?
• 
  2 T- D# l; E* {* {
  void prt2(char a,PCB *q)  
  . l7 z: t1 T6 W+ z2 k/ m
  
• 
  & ^$ e0 }8 h5 ?9 v" S0 Y; O- S
  8 n4 D% O3 n0 i7 K# l. x# a% Y{  
  " ^4 S% H# b2 A7 z
  2 g% S; h) P: o% _
• 
  
  0 e# Y; y& {" r   if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  
  : R" @" l3 s+ Z3 u, o. A      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  0 M! g/ ]  D; o, Q) S. D. i
• 
  3 f( I" p: f4 z/ s( f
         q->cputime,q->needtime,q->prio,q->state);  
  # A& N: m" U9 Z6 K1 n; M
  
• 
  ! Z4 S- q" O2 Y& N; S
  ( n- Z. G/ l8 D0 `! G   else/*轮转法的输出*/  
  
  
• 
  
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  
  / r& I3 {: B& x$ e8 X" D3 E! s3 Y       q->cputime,q->needtime,q->count,q->round,q->state);  
  
  ( j0 o) G) f  U0 n+ T
• 
  7 a. m) o  w; O1 _) O  l/ r1 T
  }  
  
  . J- [+ J* ?! i8 \' Y- r
• 
  5 y" Y! r' @* f. W- A0 t: l1 A, a5 m
  /*输出函数*/  
  
  3 |0 ?# T3 Z1 g; R" ?
• 
  
  * R8 @  v" N0 J) k! `( [; Rvoid prt(char algo)  
  8 X  J: y) {9 O7 P' o
  
• 
  
  {  
  
  
• 
  
  : j1 a1 J+ U" h; I5 g   PCB *p;  
  * P1 }3 b7 T& Q7 A/ @
  ! }# u& g3 R! ]2 e( d5 ?
• 
  
     prt1(algo);  /*输出标题*/  
  
  
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  
  
• 
  ; c+ A0 x0 N0 y3 u/ i
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  - B* R2 a" V  d6 |! G% P
  
• 
  + T/ E; |0 K$ _" W6 I0 a
  # Y7 D* _5 c$ p4 O  V4 O   p=ready;  /*输出就绪队列PCB*/  
  + _( Z$ L/ B8 x
  
• 
  3 e% h4 H* @4 M! g3 E
  2 P# l. T. `; J   while(p!=NULL)  
  
  
• 
  
     {  
  7 q+ I2 P9 o3 a& C1 b: e. i5 N
  
• 
  
  1 X+ ]& {$ i$ Z0 {      prt2(algo,p);  
  
  : Q9 P) X& P# B" a3 W
• 
  
        p=p->next;  
  - e! ]/ X" ?' _5 r4 h! T
  
• 
  ) d$ E: B6 |4 Z% ]- t" v
     }  
  
  
• 
  
     p=finish;  /*输出完成队列的PCB*/  
  
  ' R& H8 N5 h0 `# A& b, `
• 
  
     while(p!=NULL)  
  ) R& c; J) J. g% ?7 Y4 U, J: P
  * b* `, n$ g0 [
• 
  , P# i3 @% b6 C  @
  * n6 L! F% c! J$ [( l0 }" ~5 g1 h   {  
  7 u  ?- t8 A- ~+ _$ W
  
• 
  , @( \" U; i) i2 F
        prt2(algo,p);  
  0 Z; k7 j- P. E8 d3 l
  8 _( L- K! h; Y1 H- O; o
• 
  3 y5 L% w( d/ T
        p=p->next;  
  
  
• 
  1 A( ^8 _( L: V8 n+ H" x% N3 o/ I# g
     }  
  $ C8 t* P; K8 c, s+ M. t, K
  
• 
  
     getchar();  /*压任意键继续*/  
  
  9 [% @: {! ~# b! P  I6 q
• 
  ! _$ y* R. K/ H& `; I) @# S0 ~
  }  
  8 l8 i0 T1 ]% _
  3 s% X" W6 N3 Q" R3 N
• 
  ) m2 X0 ]% f4 R6 G7 O( w
  /*优先数的插入算法*/  
  
  # G; H5 Z7 C/ p4 {' U
• 
  
    u: O& t, J, ?9 z# S! {% Xinsert1(PCB *q)  
  1 {. z" W( D- d: l5 J$ x
  
• 
  
  - [4 D0 \* W1 k; m, T" f; I0 z  n$ v{  
  5 t# J4 c, [3 Y" `  Q
  
• 
  0 }' B, D: P% y- H! V
  ( |2 q2 e4 l4 y3 ~2 J   PCB *p1,*s,*r;  
  
  9 b, q! N6 W. J3 O( D
• 
  3 d! c$ \4 B/ k9 o
     int b;  
  
  
• 
  
     s=q;  /*待插入的PCB指针*/  
  
  
• 
  : c6 @2 Z5 G# b) y, D  D
     p1=ready; /*就绪队列头指针*/  
  + _' _6 f$ |# e& ~8 v$ ]+ ^
  0 O& X: B4 @7 H$ G( ~! l
• 
  
  * Y% y5 g. G7 a- [- l( i% W/ p   r=p1; /*r做p1的前驱指针*/  
  3 i4 h' U. _7 K
    G6 A1 ?" R6 c  i
• 
  
  ! L9 T! ]% [- G6 V3 e' i$ P   b=1;  
  
  
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  5 E, [. r8 B* y& o8 D9 l
  
• 
  
        if(p1->prio>=s->prio)  
  - k. h& k! w+ ]
  
• 
  $ y" T) a, m' K: ^  X- y- J2 e
  ; B% ?6 j' b+ Q+ z1 x7 I2 s1 e      {  
  ) s* j" }' y$ C6 _8 j
  
• 
    E: h6 j' V, @8 C
       r=p1;  
  6 s# E( x0 j& K
  1 Y. X5 T8 \7 E, h+ T! X( V
• 
  
  " T! O* u% G# K2 j! X! O# B) Z+ x     p1=p1->next;  
  7 y) L7 l4 O3 ?; y/ J
  ' g: i' q3 ^* o+ w! X7 C- E
• 
  
  8 z( e0 Y+ e2 X5 j  [      }  
  
  
• 
  
  3 P0 R+ Y2 r) }% p$ |* U( i# x      else  
  ! Q7 |8 R6 I2 u$ t# p
  . y# z+ n0 S8 p6 f* a1 Y+ ^
• 
  
    L2 X, N% N& U7 r     b=0;  
  
  
• 
  9 n. X0 S; v2 c  B# {% S
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  5 ^2 ~( h1 f" o* S. d4 |
  * s( C, X$ x4 D4 u
• 
  
  * ]- I. a/ ]. E   {  
  1 r/ B( j8 ?/ P% Q
  / J5 w$ q7 s$ v- ~' g1 J# r! R
• 
  
  " K  j' s3 h( l1 h; B4 f      r->next=s;  
  
  1 j9 N% V, {3 P4 l1 b3 ]
• 
  
        s->next=p1;  
  $ Y' H$ e) P( h' ^
  
• 
  
  2 r, O1 Z  d9 u   }  
  $ }9 P& h+ n' V( r
  
• 
  
  6 A/ t/ y) M) T6 L5 z   else  
  
  5 |. H  J9 P. R9 S0 l9 a6 d
• 
  
     {  
  - J5 f" n  p1 s7 e" R8 R
  
• 
  
  2 d8 \4 A3 V+ O3 X/ B      s->next=p1;  /*否则插入在就绪队列的头*/  
  
  0 y. P$ i# _% \3 O- w/ h6 ?
• 
  : G- d4 n  b4 A! y( _6 W
        ready=s;  
  1 w/ S3 l4 _+ w( \% D5 u
  
• 
  & A, k4 P9 u4 }, Z9 W' p
     }  
  
  & B% @) g7 H: d+ G. p
• 
  & t# I" f! f. [3 ^
  3 ^% Q; K1 K3 n. Q5 r}  
    {8 G/ r( @1 |3 s9 l- }: m
  * t- w* v" f1 s/ b2 H: x5 l
• 
  / J' i, J- p6 p4 s
  /*优先数创建初始PCB信息*/  
  
  
• 
  
  0 q# s1 \1 @/ H" {2 O- _- ?1 u& K+ tvoid create(char alg)  
  ! u- T4 P! E, U% s' A, g
  % Q4 d, Z, j  `+ f5 X& g
• 
  
    H; O' ?* h$ T4 e) J1 _# i{  
  
  . N! n2 {) ~, |6 r9 t- \, H6 q
• 
  0 {1 t3 ?9 M0 x+ [7 V
  / B4 z) ?# _" Z0 f  U( l   PCB *p;  
  
  
• 
  
  ) _7 ?5 n$ `- t   int i,time;  
  " _2 k# A. f, o+ k# }
  
• 
    ~/ F3 j7 a" N+ g- H  g
  ; v8 w7 i, M7 ?9 ^   char na[10];  
  " T% w$ ~+ L& h( v. K3 y
  
• 
  
     ready=NULL; /*就绪队列头指针*/  
  
  + p6 m5 G' M) `% C: P1 j6 v
• 
  ! U' _% b' {; \: |, A
     finish=NULL;  /*完成队列头指针*/  
  ) L  X& c) T5 p- f/ c; L! L
  
• 
  8 X4 I; w7 D: e5 C8 g' L  N+ v# r7 |1 [/ H
     run=NULL; /*运行队列指针*/  
  
  6 U; W0 g/ ]" ~6 |$ [
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  
• 
  6 `/ ~( g# S, C. d: |/ v( u. M. {
     for(i=1;i<=N;i++)  
  # `/ Q3 |3 r1 T0 O; H, f
  9 r: ?4 ^  g6 j8 A" j4 I
• 
  - m" W$ {7 [" r  V
  ' U! U) B9 n. F" _0 a5 a7 I' ~4 N   {  
  
  
• 
  
        p=(PCB *)malloc(sizeof(PCB));  
  * R  _7 ~8 f, h9 p" Z; f- M
  2 a: G9 m% w' C% e7 g1 n
• 
  
        scanf("%s",na);  
  ) [0 m+ R3 B3 }+ \5 ]& S3 m5 X- \
  
• 
  $ k3 M% q' ^8 h7 q/ E6 `8 K- [
  4 `6 |6 I: X8 Y2 k; N/ h  \      scanf("%d",&time);  
  
  
• 
  
  0 f. a9 c5 x" o  V) \! P      strcpy(p->name,na);  
  / l4 J7 O' ]  }* x. m- t6 P) U- D% s
  8 H% Q/ Q* M5 A+ m4 I9 y
• 
    ~  q  u3 Q6 c9 k1 d
        p->cputime=0;  
  # b1 P9 Q* H. H0 G' A; F
  
• 
  
        p->needtime=time;  
  
  
• 
  5 U$ ?% `) @- q. @
  . d3 ]& H' k0 U  b      p->state='w';  
  1 [: f1 B, W: K0 p2 i* z$ z: q
  3 f, @2 W  k$ v+ n8 D9 R- D
• 
  
        p->prio=50-time;  
  
  # a: o2 A* P% t" V
• 
  $ m$ b9 G3 e  T4 x, x+ e
  : \/ L6 p3 j$ W2 y1 w4 W7 O      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  
• 
  2 H1 V  H1 u( ^. B
  : J0 A2 w# r" ]2 x0 n0 |1 l     insert1(p);  
  ! y' n- h& ^/ |1 b' D: d+ {
  
• 
  
        else  
  
  : W+ Q/ v3 S' n8 M, p! ^; B% S
• 
  
  ' C- i6 y8 k& P. K. j% c1 r& b      {  
  : m; R2 w  b9 \7 V  a) y, Q
  
• 
  , j+ r' j4 S! c, P6 X( |7 x
  ' @0 j; ]& W9 W* S: W+ x  \! E     p->next=ready; /*创建就绪队列的第一个PCB*/  
  ) x- b* ?8 e" Y( M" Q' Q: R
  9 n3 W3 p( q1 @7 m6 A% R
• 
  " L0 A  j. j' t7 I
  : @6 i- s7 r" I7 ?. W     ready=p;  
  ! c8 z/ d8 P0 g/ L
  
• 
  
  9 M' h6 K/ e' T! b      }  
  
  ) M3 U+ N6 _/ x1 ~# o8 O' k
• 
  ; [# B$ `: y9 |9 Z$ u: p6 X+ y
  + D9 ~- q: y" o: @; h   }  
  
  . z, E* [! ]* ]/ C1 p! O
• 
  
  7 Q7 D" |6 j" i; F- B* n9 b6 F. Y   printf("          优先数算法输出信息:\n");  
  3 i# R4 U% R2 H6 v- S
  - W& W& C% j" n* K4 a! _
• 
  
     printf("************************************************\n");  
  # i, h4 Y/ Y$ V
  7 M. O; ?) g+ J: _1 {
• 
  ( u7 {1 H! @7 g. j5 R9 S! u
     prt(alg);  /*输出进程PCB信息*/  
  
  % v/ k# j5 f# C+ Q* x4 {- A% H
• 
  8 B# |. Y2 o8 y: T
  ; x" w# `9 ^5 F9 X( Q   run=ready; /*将就绪队列的第一个进程投入运行*/  
  : c5 z1 J, A, X( [. t& e7 N1 ]
  
• 
  * `' \5 ~2 S+ S
     ready=ready->next;  
  
  
• 
  
     run->state='R';  
  
  , B7 K% l* n; k$ ]
• 
  # L# v+ ~0 A9 |. L8 l0 P) d
  }  
  0 M! z* P; |8 \4 T
  
• 
  
  /*优先数调度算法*/  
  $ t/ T8 ~; z4 d8 X8 m! @
  % C' x" H  g1 }$ b5 i) f( T. @
• 
  1 W5 o. a# C( }2 y) F5 u9 K# a1 U1 a
  priority(char alg)  
  5 v, V: I- ]) P1 K
  
• 
  
  1 b; w" f1 C# P8 `{  
  
  
• 
  
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  ; r7 M' w7 {5 ~; ^+ @. F1 ~
  
• 
  $ ]4 G/ F2 n+ ]8 ^! L4 n& S# j
     {  
  
  2 j: c, l3 J  a. L$ a+ y; Q) G
• 
  
        run->cputime=run->cputime+1;  
  8 z( D! q& \$ y4 l' Y
  
• 
  
        run->needtime=run->needtime-1;  
  
  
• 
  . K# ^" K- c+ ^( b
  7 T, Z2 J+ I" `( @" N      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  # C0 T1 w$ @! y; Q
  
• 
  9 X* l) N) v5 w) g# x
        PCB *p;
  
  0 p3 C+ n; B' h# [: K
• 
  5 Y. Q# v- \2 Q: x8 E
        p=ready;
  2 V- O* e) N) H! d- j# c. b) F4 G4 p  r
  
• 
  
  5 _/ F4 N7 o8 b      while(p!=NULL)  
  
  # m- {* P) R# r+ A
• 
  4 T, S; @0 C( P* w0 C# u; R+ M; u3 Q
  ! v, a$ M4 }( u  V/ [4 t      {  
  
  
• 
  # e  Z/ y) C4 a* w$ o; f# K" V" p
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  
• 
  # `+ N+ q1 t0 A
            p=p->next;  
  
  0 |1 h$ S" d2 {% D
• 
  
        }  
  
  
• 
  + T) L0 M) N& F' Z" F: l. c' R; @
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  , N6 a& i: Q) b  w3 q7 N& M/ [/ }
  
• 
  
  6 `$ D# R3 T1 L1 \) l4 @7 b      {  
  : H4 Q$ p! e1 P% i
  8 V0 N0 Q/ R0 Z4 ~8 |! J4 `
• 
  
  % ^: Z- }0 Y! w         run->next=finish;  
  
  
• 
  % i- w+ p) v9 S( q+ H  m
           finish=run;  
  
  1 e& ~- o" _. l' K
• 
  8 T; U* A0 l( _3 W
  $ N+ I# P6 x2 R# R4 w         run->state='F';  /*置状态为完成态*/  
  
  - v. R0 n% d/ R: B
• 
  5 Y& q% H+ c! R- V% K9 m
  * i* @5 J# s# K         run=NULL;  /*运行队列头指针为空*/  
  % b6 d, I. t+ P) e& c
  1 G4 [! F/ X6 e4 l( d
• 
  
  ) W0 T. j9 ]( {; ~2 k         if(ready!=NULL) /*如就绪队列不空*/
  
  
• 
  - O* I- r6 J8 r2 r& h  Q
  8 b9 s, W- n' d/ v) c8 _% L         {  
  
  
• 
  8 m  o) Y2 Z6 c) z1 d( `
  / ]8 m+ v& K# {' q            firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  - J3 C% P, V" I
• 
  
           }
  3 R, {) ?# F$ }  e, H
  ! o. x' u8 @( E" X
• 
  7 U( r6 a; W2 ^5 y. S; x
  - r' f/ f: a( M* i2 |: A      }  
  
  
• 
  ( }8 N8 n8 e  |3 Z
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  ; \# O3 q; o( r# S: l) ~; ~( @
  + I2 I! p1 }1 ]( `! r# a9 `
• 
  
  ( c/ K$ q( P. o$ C, b" \     if((ready!=NULL)&&(run->prio<ready->prio))  
  
  ' G, O  S+ z. p, ]+ k
• 
  
  + [5 f% w9 y0 I     {  
  
    U3 @  X% d2 N& |# |6 n
• 
  / S( W* d( `. a
  3 Z7 d  c& O3 [! l& r        run->state='W';  
  % ?0 H: |0 w2 A  o+ i4 V
  
• 
  
          insert1(run);  
  
  
• 
  
  ! o4 F: P; x+ j& B+ q3 V6 U' g        firstin(); /*将就绪队列的第一个进程投入运行*/  
  , q1 K$ E9 N/ _; d- f/ ]
  
• 
  
  7 X0 G* j" a# S% P1 o3 U& J+ A     }  
  2 ~: N$ Q$ B0 k# P; B
  
• 
  5 I' [* }8 i8 i( f5 ]3 i+ V
  8 L# \4 U: F7 C, h! a2 U      prt(alg); /*输出进程PCB信息*/  
  # e3 }  f" u; w% A8 G
  7 O3 m2 P; Q7 a; e
• 
  
     }  
    M& [5 _$ Z. n0 V8 ?
  
• 
  
  / K  [- D6 _, J/ j+ k3 O6 y}  
  ) s4 h7 E7 j! }; L
  ) ?# M* c9 f$ x7 |. ^% h& B
• 
  
  /*主函数*/  
  / `. _3 X4 k& O6 {; Q
  
• 
  
  7 _1 E# n: K+ O1 G# D' e4 _main()  
  & v2 r7 p0 ]2 ^/ b1 a! K# @: `
  
• 
  6 L4 x" H7 o# c, _
  {  
  
  $ Z* [, U" s" u0 B
• 
  0 v- F: B; _# L5 o) f, u1 l
  ( u2 B' m/ b5 E: o' F( A1 q# E9 ?   char algo;  /*算法标记*/  
  
  
• 
  " s/ L. Q0 S9 e. s9 i
  2 k1 V+ K) x, X, E" V   printf("输入P确定算法：优先数算法\n");  
  6 E4 L8 @/ H+ c/ Q! t
  6 E" g- ~2 z; @" ?
• 
  
     scanf("%c",&algo); /*输入字符确定算法*/  
  . o) b' N9 M/ {+ |3 D; b' {
  8 @( T. F2 v4 }4 B9 q9 g
• 
  ) i( {7 n$ ~5 u$ B$ y* k
     printf("输入进程数：\n");  
  / [% p# j2 n5 x' v( L3 \
  % w; h5 u, h8 Y' c
• 
  ! H4 W, j6 i3 S: W
  ! b, |0 m, L& f/ l. t) t   scanf("%d",&N); /*输入进程数*/  
  1 O2 [$ ?0 R, X- g3 T$ x% Y7 U$ k
  5 |1 N$ n( u, B3 }8 Y2 h8 Y& G
• 
  / L4 \% e* m! v' i4 c
     if(algo=='P'||algo=='p')  
  ( o3 q" p$ A5 @2 s  h  x$ E
  7 J. W" P1 @4 Y
• 
  
     {  
  % _' X5 e8 B0 s0 C, `' a
  ! {  G0 \+ ^9 X4 k: J# R
• 
  : G  X9 Q& U, P, V& y3 J, R
        create(algo); /*优先数法*/  
  
  8 D4 ^% @3 P) S+ j+ D6 @3 I2 O
• 
  
        priority(algo);  
  
  $ w3 P+ g0 v  h: @
• 
  9 v' b1 m7 W0 t* j4 o2 J) r) A
     }
  & {: j/ t2 H6 {1 P$ q( u
  " L  M4 ]" I- u! X/ _7 E' O, T
• 
  
  - d2 |6 q" W. |# Q! N7 V, g* P}
  
  
  

" G; @! }- k7 a' G输出结果：

/ D8 J+ h, M, b9 D原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

) ^( V2 M0 P% y3 w; w5 `
/ _# J7 Z! i1 k  h, r4 P