优先级调度算法

杨利霞

5 j0 e8 B% \2 X/ ~优先级调度算法

算法介绍
优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
- h! N  `8 i( _: C系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
, v( T5 N0 |9 {3 v! ~2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
# j& {! V9 Y8 q1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
: b/ o/ y3 A5 c5 C, w7 I, b

2）动态优先权

算法实现

抢占式动态优先权：

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

• 
  
  #include <stdio.h>
  & y. }1 W# I: `
  & C/ C$ C0 p$ N, M7 K
• 
  
  #include <stdlib.h>  
  0 j0 m2 ]& k2 m- z
  
• 
  
  #include <string.h>  
  
  : u; V3 s7 Q2 o' D5 `0 ^
• 
  
  typedef struct node  
  ' ?& Z8 T; [* y+ ~: F4 V
  8 y2 E. \& Q% m# \3 ]0 n
• 
  
  {  
  
  . P0 l. O5 \5 V; |, A
• 
  
     char name[10];  /*进程标识符*/  
  
  ! o5 Q6 g% X! d7 Z1 _
• 
  + A, ]8 `( G! {7 G( e  H# C# b
  - h7 U; W+ A- ?3 j/ u' H   int prio;   /*进程优先数*/  
  : d+ e- v& P, G! F, \) W$ h
  
• 
  ' a( r, }( ~8 `" i; T( ~  j
     int round;  /*进程时间轮转时间片*/  
  * [* P, D0 U$ f. y* r5 C
  ' K+ z6 p: e+ S, R' \( H
• 
  
  * ^' w' p7 ]. p# h4 {% W/ e/ Q% V" J   int cputime; /*进程占用CPU时间*/  
  
  ( ~3 x- M; K% r
• 
  
     int needtime; /*进程到完成还要的时间*/  
  2 b+ m1 a, G. s  J
  
• 
  
     int count;  /*计数器*/  
  & A9 @/ K) L' W7 C6 K9 X% g
  . }" M" a5 {- K* |& ]2 N; c
• 
  
  - ^2 f0 v/ o6 k$ j+ \   char state; /*进程的状态*/  
  
  
• 
  $ X& C) [9 d: ]# m& t7 V
  7 k* l% t' F8 E( x. Z1 ~$ S6 x( i   struct node *next; /*链指针*/  
  
  
• 
  
  }PCB;  
  5 O7 a' f* \8 D. r! n8 |  U: [6 c
  2 Q; a( `: W* h7 j2 _5 f
• 
  
  8 A# g/ E) T) Z! w' iPCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  
• 
  8 u% o1 Q7 }; v- r
  int N; /*进程数*/  
  
  
• 
  
  , q8 e* x5 f9 |5 g2 {( G+ @8 ?  n; S/*将就绪队列中的第一个进程投入运行*/  
  
  9 o: |2 v' e9 s1 v$ Q
• 
  
  6 p& @1 ~  F# V1 ~. Jfirstin()  
  , G7 }/ D' G8 `  G+ X3 n/ E$ C' L
  6 @, Z. p; v: ?8 b, v) Z" J
• 
  
  ! W6 T/ O& R7 J: A( t2 h6 m4 C{  
  
  
• 
  , r/ p7 b# c3 x! j
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
    v0 t& q* w) J9 A
  * t: ?3 J9 C% @+ h. `, f
• 
  
  " t1 U4 f; A  R. k   run->state='R';   /*进程状态变为运行态*/  
  / y. c5 {1 t; x- O% y1 q( q
  $ H* L9 n7 |# O8 H6 w! O" t* F
• 
  
  ' [, U! I$ _  |, w* n5 O   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  & L- Y- k- v+ ~3 E0 A% h9 U' o
• 
  % h+ v3 \3 B2 Y) d0 ?  d2 y
  }  
  
  " O4 m3 }6 L, n; c" L3 r0 L
• 
  ! r+ c0 y4 ^# h; |; G, L
  /*标题输出函数*/  
  . x7 b8 ]6 ^7 Y; O3 P2 r
  + w- S$ X1 D3 ]1 L9 t' c8 r0 x
• 
  
  . a; _' k7 V8 L1 k7 Xvoid prt1(char a)  
  
  6 s. Y! T2 T5 m5 s3 i
• 
  
  {  
  
  % v0 b" y& \5 R$ T9 O; H7 F5 z* K
• 
  : d2 f1 r* L% h5 q
     if(toupper(a)=='P') /*优先数法*/  
  ! J; q- A" K5 n( }3 Y
  ; q, s- I# |! D; t2 u, S* J
• 
  $ B% B+ f" b, m+ q1 g7 c+ k0 \
  5 m2 l4 p! U4 Q" Q      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  . z: ~- b9 }: C9 P3 P/ C' ^
     else  
  ! ]! L0 l% M4 l3 r& C/ p$ D7 ^
  
• 
  
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  
• 
  / {  k. j7 v* ^' f) R0 a1 }& ?5 V
  }  
    z% X9 m, y1 A! l: W0 d7 j( ^4 L
  ; z, x& k9 l- W6 Y
• 
  
  /*进程PCB输出*/  
  
  5 Q6 @6 M1 s4 ~( U* y
• 
  8 D4 K, D6 j6 l% ]% p/ t) v% o; b
  void prt2(char a,PCB *q)  
  * }+ w5 o0 G' I+ S8 {5 B7 j
  
• 
  ; k7 n; ]6 V1 V
  , V* [) u+ |9 _# ?% M2 f( W* o6 w{  
  
  
• 
  
     if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  ( Y" t8 l6 a) ~5 f9 W6 Q
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  , ^0 j7 l1 D5 K. e: O
  
• 
  ' ^4 i% _1 l* H6 D" V" l
  8 A1 P  W3 b! A4 W1 c6 M7 ?; H       q->cputime,q->needtime,q->prio,q->state);  
  
  
• 
  + c% _/ H3 M, U: f
  . ?: w8 \" s% |: P* L   else/*轮转法的输出*/  
  
  
• 
  
  ! d! J2 A8 x% \4 ^      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
    t6 U* t) ^6 w' V2 j
  ( c/ K+ e  q, y# [, V* W1 X4 F+ k5 e
• 
  
  0 `$ h" ?% j; r8 `. J/ ^       q->cputime,q->needtime,q->count,q->round,q->state);  
  
  
• 
  
  }  
  
  
• 
  4 P' x# Z$ n3 g' p# a- f: E) b
  # A7 R' F# C/ _( X' [- ]1 S/*输出函数*/  
  
  & }2 ^2 I' l+ _: n) x1 ~
• 
  
  void prt(char algo)  
  
  
• 
  
  {  
  / ^+ r. d9 \1 S& t  K& n
  
• 
  
  & g# C* j( \6 X- E. r5 k2 Y   PCB *p;  
  5 s2 d" a; \! e/ h: ~) j5 `- Q: o4 D
  
• 
  
  9 U1 x9 S8 I& U( I, i* [( S9 Y% a   prt1(algo);  /*输出标题*/  
  
  7 z' g/ T* r8 u0 `  Q1 g" p3 z. \2 z
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  
  4 S' F2 `& Q+ h" h# a# J" q
• 
  8 Y: E) \0 k- [7 v
  6 _2 N& k! |; {% j9 r      prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  9 x8 O8 ?( Q' Q
• 
  
     p=ready;  /*输出就绪队列PCB*/  
  ( O4 \+ T! j0 y, q& M
  * p5 p% |  I7 G/ ^& O+ f
• 
  
  ) a& D* ?$ J7 G) F5 K1 ?3 P. G   while(p!=NULL)  
  
  % j) |8 p; j' X/ b; R
• 
  
  ( ^0 ?- B. `* v% N' R   {  
  % a9 w5 i" T& x0 m. q
  
• 
  2 I+ N# z/ o: I6 @3 i5 |3 ~
        prt2(algo,p);  
  
  
• 
  
        p=p->next;  
  ( h7 ^) E' T  J
    F0 t9 G) l/ Q" S. e
• 
  5 N5 I/ X, B+ t+ Q2 d
     }  
  
  
• 
  . U/ \, [3 _/ ]
  / L7 H7 x. a4 |6 Y, F, A0 Z0 ?   p=finish;  /*输出完成队列的PCB*/  
  
  & i: v$ b" K0 n# W7 z
• 
  
  + s( `  ?* H! u8 c   while(p!=NULL)  
  
  
• 
  0 }) y0 X3 @2 @, Z0 I, Q
     {  
  
  % ^1 Z1 ^9 A; `1 Q8 A
• 
  
        prt2(algo,p);  
  + W$ P. S9 B, j8 d0 k& F1 k
  
• 
  
        p=p->next;  
  
  # `9 r* P9 C; P: T3 f! }, N
• 
  
     }  
  
  
• 
  % m! v9 P  k- E* s+ Z1 ?5 K
     getchar();  /*压任意键继续*/  
  ( X* \/ e2 D9 j6 g" X9 L( S
  
• 
  
  ! X  f( x' g. i}  
  : v+ f4 Y; }. J; V9 q, B  A2 q
  " [* o/ y5 y5 ~
• 
  
  6 |1 M# P0 J  C2 ?  H0 E' i/*优先数的插入算法*/  
  - v& o% ~6 [0 u
  4 K4 b# |: w6 E, E; D6 @( j$ L' x5 F
• 
  ' a! [, g3 W, y, Z2 |+ H0 v" V
  6 h* a4 G% R' d, h  E9 u6 p7 ?insert1(PCB *q)  
  ) x$ c/ T& `0 O
  
• 
  / T9 X( G3 x$ p' s- h
  {  
  & ]* R5 m, L& a1 }8 Z
  5 X0 F, M) t! z2 @' k
• 
  
     PCB *p1,*s,*r;  
  
  ' e: w  X& O* m4 g- m$ y
• 
  / }. x) L. x9 T/ s7 g! O" d
  % c! j" N) \  o" O8 k   int b;  
  
  
• 
  $ U' U$ E3 h$ b
    ^7 f# T# Q2 i8 w   s=q;  /*待插入的PCB指针*/  
  ! l0 ]8 e6 q7 [; T
  * S3 z1 s5 @; ^
• 
  1 n" x* ]; r: f3 p# @- x5 k
  ( o- N" `- I. {( m; a   p1=ready; /*就绪队列头指针*/  
  2 q! S4 s6 x" y8 m/ c& h( z# D+ n! Q
  
• 
  
     r=p1; /*r做p1的前驱指针*/  
  6 l# _" {7 @( M6 n
  
• 
  8 o9 w3 c' Y3 A. r9 U: v9 m' S
  1 S. J1 M( `' [) d' M" e3 q   b=1;  
  
  ' j: ~5 L# }9 o; ?: @# q* U
• 
  
  ; q' P0 X$ }9 L6 S; ^- ^7 J( S7 V   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  " o6 l" d4 g/ Q7 @' `) @* Z
  + x0 S$ e; e3 G# [) I& ?2 `1 t
• 
  8 C' ^; R$ _) C( d
  % {; f7 r# d' k3 \; Q' O      if(p1->prio>=s->prio)  
  
  
• 
  
  * Z8 @) _5 P: n: I* p      {  
  2 @$ D% I$ L% Z7 t  o
  ) F( l7 f! Q; W8 A$ w+ q  e$ W
• 
  
  5 b; R5 t7 X1 }     r=p1;  
  - U7 o! O* A) K) S3 X
  
• 
  5 y7 ~+ A, j1 p, G& B* e; `
  8 P0 b. z' V% I" F& M' O' t* A" ~% l     p1=p1->next;  
  + o, Y, T1 V: w' k8 `
  
• 
  
        }  
  # r( u+ Z0 w7 H
  4 e/ \& a  m9 b, B! U  m1 M
• 
  
        else  
  & W% y- h. z4 y; K1 t" t& |7 |
  0 r2 k& n5 w* O' ]# k3 x
• 
  
    E+ T) G1 s1 k& O$ h, j     b=0;  
  6 F8 C1 V* C6 r4 F' J4 \5 F
  . A8 j$ _! x+ y
• 
  
  ) T; p. a$ C8 G0 I- P1 h   if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  & w$ [* R3 E0 {% H% w3 _
  # B4 \0 @: e0 n   {  
  ' ~% ?- @3 i, }! U0 ^
  ) A1 P" w  P( s0 w- u' C: p% F' K
• 
  ; p* @2 b- @) l* ^  h0 @  V. r7 T
        r->next=s;  
  / d0 r1 q; {7 F& t7 ~) o" |
  
• 
  
  * E+ N- X; R% J      s->next=p1;  
  * x3 W9 e" r. w; D1 v1 d
  
• 
  9 }4 w" X* O6 m( r( u# K
     }  
  
  7 V1 |' k8 T8 v  f7 e; w0 }
• 
  # N1 X1 _9 ^2 Y
  " p% y6 |( a3 B0 k( v" {   else  
  
  
• 
  
     {  
  
  5 N# Z, A' C2 ]. K, \. r) C
• 
  
  , G1 c# O) T% P: Z2 s      s->next=p1;  /*否则插入在就绪队列的头*/  
  
  : J. q5 D' O0 w2 _6 e" N/ c) m; p
• 
  
        ready=s;  
  
  
• 
  
  3 I# R; i+ \  ^" ~9 q   }  
  
  ; W0 p$ x- F/ N1 ^
• 
  $ w/ v6 ^4 l; T6 @' s$ S2 x: c0 N
  8 t4 H3 @' `+ ?4 T6 f& A. J}  
  
  7 K6 \4 ^* |" p4 Y( o8 B) B
• 
  
  /*优先数创建初始PCB信息*/  
  
    a6 P/ P" N; O# @- p( \" o: W. `
• 
  
  + |( O1 x) A8 r: p6 Svoid create(char alg)  
  
  - D. K! E" _% l# X! T- l
• 
  + i. E2 @% u' N, m2 X4 D
  {  
  ; ~* _) N1 n3 Y% ]
  
• 
  
     PCB *p;  
  : }" V' f& i: |* d
  
• 
  
     int i,time;  
  6 C& k9 V5 O, H6 L2 J
  $ W1 b5 b2 Q, j; r
• 
  
     char na[10];  
  
  
• 
  ; K% E5 H* W; V8 J
  $ T" b9 J* Z1 [9 F% a   ready=NULL; /*就绪队列头指针*/  
  
  
• 
  , [" u' x& ~/ y5 j3 e0 K
  ) p. S/ n+ y# z   finish=NULL;  /*完成队列头指针*/  
  ( R' N- }$ D6 p) H3 u  z7 J% S3 x
  ( C2 o5 D1 [7 C' q) l
• 
  
     run=NULL; /*运行队列指针*/  
  / K- \5 J+ c/ G5 E
  
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  " ]' a! e) j5 N5 a2 Y; e2 j/ X
  4 X! L/ \& b8 X4 S
• 
  
  + Y+ l( Y; B1 C6 }6 @   for(i=1;i<=N;i++)  
  0 s" R7 r- K$ E$ N3 Q# }9 Y
  + w  H+ R9 e; L' B; ~( L
• 
  ' S1 `( {0 B3 t, a5 W# N5 a
  ( a6 V# r9 ~* B1 O   {  
  $ n! B$ h7 R/ o* U3 F9 Y0 ]# m* n! p
  8 C2 W0 A$ j! i+ f
• 
  
        p=(PCB *)malloc(sizeof(PCB));  
  
  
• 
  
        scanf("%s",na);  
  7 L4 e1 B/ X4 _# c. t6 l1 _
  ; h' I1 Q  u* Z" S
• 
  : ?) Q$ f& r: Y: ?; P0 b
        scanf("%d",&time);  
  / v+ g# I+ [2 R' F
  6 q% I) R7 G1 ~" H0 r) Y
• 
  6 K( C4 C' \( t/ a% P! T0 C( y
  7 b6 W; L( h% k6 ?7 M3 k      strcpy(p->name,na);  
  
    _% ?0 H6 y* a0 h* G
• 
  
        p->cputime=0;  
  
  
• 
  " ^# ^& R5 N0 F! U# c
        p->needtime=time;  
  
  
• 
  : C9 ]* W3 e! ]
  . i* u2 ?! r3 |1 S- f' v      p->state='w';  
  
  ' E) M9 S4 P2 ^, {. s' z: Q
• 
  
  4 |" N0 O% K- q7 A) d4 @7 A6 h      p->prio=50-time;  
  ; E1 A$ Z4 Z/ [# q2 V3 j
  
• 
  ( }# A! a4 n+ l! X
  3 R$ O: k! P; x* o* c, g. Q      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  
• 
  
  5 h! u& n, j8 v6 h     insert1(p);  
  
  
• 
  
        else  
  6 N2 u3 u9 i+ z7 o) l6 O7 c
  ( x7 i4 W& E+ n5 ~! S
• 
  
        {  
  ) x. t3 K% ]0 U$ h2 v, d
  8 o3 }4 u/ k( b7 \
• 
  6 x1 m' Z5 J1 }. z
  , I! L9 ?6 Y8 [! t4 @2 }     p->next=ready; /*创建就绪队列的第一个PCB*/  
  , m* g+ A+ z! n8 c
  
• 
  : _! {- h' {& T3 r* Z7 q) i
  # ~, r7 Z6 O; R5 Q+ f; J1 M4 E5 ^. h     ready=p;  
  ' ?6 ~% e* K5 W- W2 N
  
• 
  ; o; p% O% t0 p* H+ ]6 \
  , U8 D! V  F" w! n+ o7 T, n# z      }  
  
  
• 
    X& U6 ?- r, ^% D  V4 Q) \3 G: A; b- ?# w/ K
  / M; K& R' ~& u4 m* w; v   }  
  
  
• 
  
     printf("          优先数算法输出信息:\n");  
  ' P6 {% P1 A' m
  
• 
  
  # n. E9 D; \8 k$ o' t# I2 Z: D   printf("************************************************\n");  
  
  7 f) t, v. g7 K+ A
• 
  
     prt(alg);  /*输出进程PCB信息*/  
  * A/ \, o0 y5 Q
  
• 
  
  ( h. V: p% K8 m! B' e* f   run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  
     ready=ready->next;  
  6 C5 o, t2 _: p* ?4 _; d/ p
  0 Y8 w+ w% F+ N1 i
• 
  & E: Q6 B0 t; |1 L, W0 N
  6 t1 ~$ p+ d5 O   run->state='R';  
  , b+ @, Y- Q& u/ q
  7 K+ R5 H# i6 j, ?3 L4 P) }
• 
  
  }  
  
  9 }8 `( ~; U7 v: n
• 
  ' G% ]. J" i. Z0 C0 T, j
  /*优先数调度算法*/  
  ' Y6 u% `1 S' [) V( G3 F' L3 Y" N
  
• 
  . G  ^: p! A1 Z
  4 V! a1 E  e5 r3 G5 zpriority(char alg)  
  8 [4 J% f/ a9 Z  p- G
  
• 
  
  {  
  ! h2 q# X. J/ y1 h  B
  ( E9 L8 d2 Q/ X! f+ u/ Q3 J  t- F. E6 U: ~
• 
  
  7 K+ @6 m: G2 n; ^( m   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  7 b. w9 T5 J5 g8 f9 X
  
• 
  
     {  
  
  
• 
  4 `5 E! M+ l$ V/ e3 C$ [4 J
  " i; ]5 I8 D7 K7 Q# o- H4 Q      run->cputime=run->cputime+1;  
  7 L- s* O3 ~8 @1 K1 n! v" v* `
  
• 
  
        run->needtime=run->needtime-1;  
  & F- n( I4 k% M, w/ d8 Q- M3 E/ i8 f
  
• 
  ) d0 `% ~+ y2 g/ m' H) ]$ `1 |
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  
• 
  
        PCB *p;
  : u+ F3 n" X$ d0 U* n
  * H7 J, t# f2 W3 g5 n
• 
  
        p=ready;
  ; N4 r; j4 N- m8 |- ^& R7 x
  
• 
  
  , x+ ]4 N) K: T7 D7 {# @      while(p!=NULL)  
  
  
• 
  * h; G8 L  u! g$ ~. l+ w
        {  
  
    n# n! F( L+ l; l; U9 y8 K
• 
  
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  : K+ s6 U  e5 ^0 t2 z' X% e$ c
• 
  
            p=p->next;  
  
  
• 
  
  * E8 {4 a4 S6 D7 X1 h, A      }  
  ' C6 [' z& N( H. L% s: O7 b+ J* M
  
• 
  ) i4 \, K& w3 H7 m0 ]# ^
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  & A# B9 |, I  N! [8 Z
  
• 
    v6 }& x4 u, x% i6 h+ R7 x
        {  
  8 M1 t0 L, T4 q/ I, m; V
  * e. ]* X' x% Q0 \( @; }
• 
  ( O+ H3 `/ ?4 }5 N: a
           run->next=finish;  
  
  ' B, v! H8 ?% O5 _$ g1 Y
• 
  
    M; C1 ?5 l4 @' O; t4 N# i         finish=run;  
  7 }8 g0 A1 C# f4 l2 c. i
  $ p4 u/ F1 x9 E
• 
  
  0 E) H( S" `, B$ M. X$ R! O' ^         run->state='F';  /*置状态为完成态*/  
  
  - N: c7 W+ a6 D; h
• 
  
           run=NULL;  /*运行队列头指针为空*/  
    s- p$ {* V3 ^5 a& _
  
• 
  7 n  R, w( B/ k
           if(ready!=NULL) /*如就绪队列不空*/
  1 @: j, W) H7 ^+ u
  : J1 C$ M) k# n5 Z+ J5 j+ x
• 
  : D7 m/ ^5 \6 c7 g( o
    ~: ]0 |& d' F, G" f         {  
  $ |2 I0 j- c1 b' d6 ?
  
• 
  * F$ i, S7 w# Q& E- U9 Q/ X
  2 H6 y( t! V+ i1 X) \& [! q9 i            firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  $ _: d& a# T8 w: U
• 
  
  ) K/ o# A9 }! j- r% W1 H         }
  
  
• 
  
        }  
  
  
• 
  
  $ m! A- h# c, L' w4 |      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  1 s( T+ T: S8 a; Y
  
• 
    H/ ^- `6 ]' v2 t2 u6 ?6 c8 _+ z
  , |1 n. X$ Z+ O( u+ _     if((ready!=NULL)&&(run->prio<ready->prio))  
  
  & M( d1 M: _1 K
• 
  ( @" D# l5 h9 u: ^# N
       {  
  5 d- n; t) l7 T( ?  l
  
• 
  
  : ~. @4 g8 R; p* O        run->state='W';  
  
  
• 
  * w2 ?8 K3 W% O; I, l: \3 f4 i, Q
  / r5 K. U2 ~2 M' b  n        insert1(run);  
  0 p6 s% f- F4 W/ ^. A  _
  
• 
  4 h2 n3 _  e. w( @; N/ X0 ]2 g
  ' ?* y" r0 k+ i! t0 ^        firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  3 s& U, r; {1 t' N
       }  
  
  
• 
  2 `7 |6 D  s* Y: r, G- G
  ) A/ N8 h3 n7 a6 j0 U) w& T: [      prt(alg); /*输出进程PCB信息*/  
  ! K) p$ R# [' R5 U% V
  
• 
  
     }  
  
  2 Z+ l+ t5 k( h+ x1 w1 f3 @5 k
• 
  
  }  
  
  
• 
  * {4 ]9 r. T( `9 M% T- E
  " ^0 z: [! q& z2 y/*主函数*/  
  
  5 W' U  P2 N& P8 h/ ]0 j/ [
• 
  , q; k) C% N0 y: p& Q+ y. |7 X" a
  0 x: y0 {" l5 e$ Z2 V. Gmain()  
  6 y. a' i) s3 T$ V/ G6 h
  
• 
  
  ; }. h% m) m9 Y& k( S2 @& x2 N{  
  
  
• 
  
  4 r' ^- m! \- ]5 W   char algo;  /*算法标记*/  
  ' @" f$ r1 j' Y1 z' k
  
• 
  
     printf("输入P确定算法：优先数算法\n");  
  
  5 _: i4 V8 p: ?* F3 ^+ H
• 
  
  5 e* q  K; ?6 e7 X" R   scanf("%c",&algo); /*输入字符确定算法*/  
  
  5 D. h7 ^! F" F. \- x6 F
• 
  . Y  a6 d  S; w' i; A" v
     printf("输入进程数：\n");  
  
  2 ?9 Q8 \: ]! S+ P' U
• 
  
     scanf("%d",&N); /*输入进程数*/  
  1 g' i3 h2 K2 c& w$ @% v
  ( z. \9 c. r, }+ i  R9 q
• 
  3 w; j1 M9 k. `( e
     if(algo=='P'||algo=='p')  
  ! h/ o  c% h  h* M! q
  
• 
  
  # g8 _: P" ^/ i. i9 N  V   {  
  
  : w- ~& C. U" D9 w' f0 S
• 
  7 c: }; u3 N7 w
  + Y4 p% t; d" n) W      create(algo); /*优先数法*/  
  1 g/ z' j/ u- q3 \' q( c5 M
  1 r' j" @0 Z: K
• 
  , w  Z' c5 n4 X" I
  - o% o# \# Y+ ?) ^      priority(algo);  
  ) {& N) [7 h% F9 y$ t
  + H" F9 a" E7 q$ X1 F# Z
• 
  
  5 B  \+ H( v0 H. S" C$ w' b' a" o   }
  
  & W  h0 B! ?. ?9 N  n7 y
• 
  
  ( |) m4 i: s) D5 O8 c9 Q}
  
  % q! D* X" E; R3 f
  4 N  {6 g! x+ x$ N

输出结果：

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

$ C5 x% _/ [7 d) R. [; l/ D  o
5 e0 t( D- b; f2 I