优先级调度算法

杨利霞

优先级调度算法

算法介绍
优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
3 n0 R3 K, L) y& R* t) }- n系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
6 x' l- C' Z  \4 o只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
5 b4 `  s0 z9 N) ?6 p/ ^* u1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权
* o! w( y: B' S. [

算法实现

抢占式动态优先权：

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

• 
  
  #include <stdio.h>
  
  
• 
  : R3 E' U8 b4 z, r! n' p
  #include <stdlib.h>  
  
  
• 
  
  5 |4 W- [8 n0 J- \) N  u' X#include <string.h>  
  
  / r# q7 q6 P) F' B% z9 g
• 
  
  4 F2 K/ ]8 [% T$ x7 B: \typedef struct node  
  5 C* p* X$ _) o6 w. K
  ( [" h7 Q: n1 L
• 
  
  {  
  % I% a5 C$ o, o" T( V; V
  
• 
  1 x7 L9 f1 }7 K& Z( }
    i' F" N- ~) p   char name[10];  /*进程标识符*/  
  
  
• 
  * r% ]2 ~0 A+ m$ f/ G/ P* x" w
  7 h0 `+ e/ _6 u$ E( w8 Y- K" p   int prio;   /*进程优先数*/  
  
  
• 
  " q; t6 n3 J; _
  ! S0 f4 E* \. q9 \   int round;  /*进程时间轮转时间片*/  
  ; a/ _( p3 _1 D9 F' q
  
• 
  
     int cputime; /*进程占用CPU时间*/  
  6 N2 O# k8 Y+ S
  
• 
    C" R2 F! f9 I  d
     int needtime; /*进程到完成还要的时间*/  
  : B$ Z1 h, q  b- g* {& C
  
• 
  ) C5 a- p" J1 o; _+ R- n
  6 ]8 j2 i- H1 P  w2 [   int count;  /*计数器*/  
  
  
• 
  ! s6 g. M5 Y0 |" ^. {; g$ ^
  ! q$ S) \/ n2 u* R# P   char state; /*进程的状态*/  
  
  9 p- l" L. U7 a/ p
• 
  
     struct node *next; /*链指针*/  
  ; T/ _1 s' m$ e% T
  # _( Z  z7 t2 F
• 
  
  }PCB;  
  ; Y/ a/ C, H/ K, t# V
  
• 
  
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  
• 
  
  int N; /*进程数*/  
  
  
• 
  ; ]$ M5 R  {2 `$ B. {: _0 L
  9 a: b) d4 q* T" M/*将就绪队列中的第一个进程投入运行*/  
  % @! U2 t. `; I' g
  + X  A% P/ }" ~4 F, d, u
• 
  - {2 d' l7 X6 g. E2 c! Q# `! s
  5 n, e" X  E: j+ K$ q; [0 i( Bfirstin()  
  ! k+ ]" q6 s2 x" d& w
  
• 
  & z$ V2 o/ G' S# \$ O' Q
  {  
  # E8 I& U* c' P, w% I5 ?# V) x, M# E, V
  / J* V) p4 A4 y9 C0 e2 f; H
• 
  3 J$ I( k6 E+ O! W2 q3 y
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  
• 
  
  ) `9 i& G. ?& S) M8 a* n4 C   run->state='R';   /*进程状态变为运行态*/  
  
  - Z  u( w8 K# @0 ~
• 
  
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  ) ^" B+ t1 d9 n, @3 ]
• 
  8 q  q0 i( E# L! q
  }  
  & @3 j" e& ~. O
  * G  }( G( z: |! R! `
• 
  
  8 y/ g8 m% U5 v" b/*标题输出函数*/  
  
  
• 
  
  ' y( h) e9 {. g9 _" Ivoid prt1(char a)  
  : N" a' _  M- U  ^. K2 [1 {5 q
  - }# Z8 S( h* b* o1 A: F1 u& D9 N
• 
  0 c( k7 p  G6 `0 G" r; J0 d
  & a; X/ V: }" M& f, s+ }- U{  
  
  
• 
  / R( y5 w: O$ |* H* x  q
     if(toupper(a)=='P') /*优先数法*/  
  7 G  d3 }( Q/ F4 D3 t7 ^. T0 N
  
• 
  
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  * u( w8 T4 k$ I- j+ i, y1 l
  7 r9 ^) k  j+ F5 X; m9 N
• 
  & p, W, U% e" \& A- x
  * A3 L; B# U4 o0 F) x   else  
  
  . w# r! n8 L' f: F( x
• 
  & M6 J; z+ y$ R
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  
• 
  
  }  
  ; v% H4 g" @" k" q0 @' S6 T2 `
  
• 
  - j9 d. A7 `2 z1 O2 @% {1 L
  4 n; L) e- D$ a2 X! M# k6 q/ H/*进程PCB输出*/  
  
  ' W  n& K. b" f3 s
• 
  ) u) N& K& R) k! Z% z/ I
  void prt2(char a,PCB *q)  
  
  1 {/ r* g9 O2 t. r" B
• 
  ) `9 ~0 a' T' p/ T! i2 K4 o; m
  {  
  1 b/ c, Y9 C& _4 z( \3 O: w2 e
  - U2 U2 U; q! `7 h
• 
  ! W, I. h- p* f( S0 [
     if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  & F( D7 |' N1 S# @, D; K
  : x! {+ g1 \& k% e3 s6 R& J      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  
• 
  
  0 }1 `- j% w8 p8 H, `, u% [" g' Y       q->cputime,q->needtime,q->prio,q->state);  
  
  
• 
    u; S6 i5 ^" _5 [8 P; _( X
     else/*轮转法的输出*/  
  0 ?' e4 G; ~. ?0 [* ~9 R. l$ d
  " |2 b: f" a- B. G
• 
  + q1 Y, O' R/ i5 S! o
  # l6 G) m* ]2 o      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  ' ~# \1 x: u# h
• 
  
         q->cputime,q->needtime,q->count,q->round,q->state);  
  . N& \4 r: b& U7 }7 S
  ' P. E  \# q( A$ E/ Q% H
• 
  % Z; Z" p' _! V
  5 G2 X+ C, F0 g8 t0 s: `0 H}  
  & Y0 I2 n7 I/ n( x) h5 a
  ( C, N& ^* e+ b
• 
  " v6 Q! F5 Q) _: H4 ?
  , Z! P, m# B( `- Q3 w( M/*输出函数*/  
  
  
• 
  , j/ c8 W; k* k* B
  7 b8 _7 m" K. y- G5 |0 kvoid prt(char algo)  
  
  / `( J+ Y% _+ S, B/ A& P
• 
  
  % M# o+ d2 f3 n( I3 o{  
  * d! D& Y. v: r' g1 ?& d4 G0 U
  
• 
  
  2 @3 Y0 U* \  @7 M9 V   PCB *p;  
  
  
• 
  $ x& a) F6 L3 l
  $ T$ V5 m8 W' U1 T1 j   prt1(algo);  /*输出标题*/  
  
  : a& X% l% o, ~' R# a
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  0 y0 Y. u' I% Y7 _7 [
  
• 
  
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  ' m4 E4 L# h" n7 j- a$ J3 u
  
• 
  
     p=ready;  /*输出就绪队列PCB*/  
  
  
• 
  & K7 w9 |: ~; Z$ m: u3 a
  9 G$ o; A" W# Q& Q   while(p!=NULL)  
  
  9 b' x- {) i% L1 P* n! }/ Y
• 
  
  ) f' ^. |, @7 T0 ^   {  
  
  
• 
  
        prt2(algo,p);  
  # d% s) h( l* n9 P! e  D$ D
  $ L4 C. r5 ]2 W7 l; D6 L) s5 ~4 A
• 
  ' O$ |4 u0 T- ^' I3 U8 s. m
    ?6 n0 j' |5 x2 r/ H/ W7 o1 L: X      p=p->next;  
  
  + M( j0 m2 l" W( A6 [5 G, e& t5 d
• 
  5 H: N0 q( {+ S5 M+ i; ^
     }  
  
  . W( ?% D3 P( c; A  s1 {1 {% m
• 
  
  / Y% A) T5 y( }4 @$ ~   p=finish;  /*输出完成队列的PCB*/  
  , X  C( I% k/ n% c# |
  , L8 h+ F" h9 M
• 
  2 e2 D" U8 b0 v
  ! }4 d7 a, T& R  x, Z   while(p!=NULL)  
  
  9 l/ F% _, T  _. t
• 
  2 y- O( {& e: P4 i# ^  k
     {  
  % o& z! r% u. A  h
  7 B& ~, q" Z! t. m& h
• 
  
        prt2(algo,p);  
  & x1 `% E, A3 l2 I# i  e+ x
  
• 
  
  - K" h6 R% J0 y; E      p=p->next;  
  : l. G) \% U6 l+ R, `
  
• 
  # X7 t* r) k. O3 G
     }  
  
  
• 
  
     getchar();  /*压任意键继续*/  
  
  
• 
  
  }  
  * e4 N) `' p$ _# o9 k: p
  0 K% F8 B: R( z
• 
  8 A3 K8 l) A0 P  _
  /*优先数的插入算法*/  
  
  
• 
  
  & J  R( ]& L. _insert1(PCB *q)  
  
  
• 
  & q$ I' U( y6 c5 t$ u3 k1 ~
  {  
  
  - q- |$ Q4 v6 a, z  h4 b5 u
• 
  # i4 H* o/ ?6 i* ]
  " m2 o1 D) P% n% z  k' T" ~   PCB *p1,*s,*r;  
  
  
• 
  
     int b;  
  ! M$ i! p4 l% y: ]% C# v) V4 w# z
  6 ]! n. j1 t* ^8 @2 o0 l/ \
• 
  
  ( h( m- L$ C  v9 G   s=q;  /*待插入的PCB指针*/  
  
  & g4 U) A! V7 {+ j  C2 N; f
• 
  
     p1=ready; /*就绪队列头指针*/  
  
  
• 
  
     r=p1; /*r做p1的前驱指针*/  
  
  # s1 K/ d+ V4 H! |. {
• 
  
  2 U2 ~: r) O% l; R9 n0 {   b=1;  
  , H4 k9 h. j3 ~# @
  
• 
  
  4 n( J+ W4 J2 K3 Q" S; c% E   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  7 o0 D  c/ @9 v7 \# {
• 
  
  9 ]2 r* U3 v* W3 i      if(p1->prio>=s->prio)  
  , U; g$ i4 g% u% ?
  6 `+ }2 l* P4 D( \
• 
  
        {  
  
  & t% A2 ]6 o; J1 I4 \4 R
• 
  ' p5 |& A$ M7 D9 |1 _1 G
  0 Y! g! I" e7 y. h: [" {     r=p1;  
  6 W- ]' L. d! K3 i( i
  . ~% ~3 l) ]- i( p0 C
• 
  5 v* [4 H1 I& D- e+ H7 e  x
       p1=p1->next;  
  . |2 ~6 @0 m: \; D& Z
  & p" j+ W1 o4 |$ S( t. Y
• 
  
        }  
  
  % w& f; X6 u; W
• 
  
  . M% T# a3 t/ b- L3 ~; c      else  
  
  * L  v  k7 t6 P
• 
  
  ' @: n% g! o+ D9 C3 _( g     b=0;  
  
  ' ]; _' P  k" [: C7 q: r" M
• 
  
  1 a" f$ u8 p7 T3 e6 z+ z' }# `, i   if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  ( W9 U7 V. ]0 d4 g5 E
     {  
  
  # ?+ @) H8 {, |, ]- C( c+ ?  q, a
• 
  
        r->next=s;  
  
  . x) V# ]8 C2 @' C# x
• 
  / H' @9 ^4 \" `  S, f1 D! m
        s->next=p1;  
  
  2 ]1 ~4 B1 P! K  f. B) z
• 
  
  $ z- S& |# p; N* a& x* u6 a9 s   }  
  
  2 m, \& j5 [" H5 n! j/ B3 k
• 
  
  ( M7 C( E# D& O1 c- Y" O   else  
  
  4 q2 w6 \; t* w. S
• 
  $ }1 D8 a- C0 y% I$ N2 [1 a! L
     {  
  / w; s& e: s( h# e# `7 ?' p
  . E9 h$ H+ a- i
• 
  ; ?" h( w" H( r5 ^5 j) ]2 D
        s->next=p1;  /*否则插入在就绪队列的头*/  
  : X; b4 Q) p7 m3 w0 q2 l; z
  
• 
  9 \/ t5 X$ R; ?4 @7 q
        ready=s;  
  
  5 c% B. i) T; f8 H; B
• 
  + m* g" m! ~6 Y/ B' o. y
  " p$ P& {3 f! M" J. \) A; X, [6 |   }  
  . Z8 R; Q5 t9 Q4 A" d, [% ~& h
  
• 
  6 E+ [1 w* y) y# f. U: X. D+ ~' j
  }  
  
  7 b9 ^4 h0 q' ~0 ~6 A
• 
  
  2 r: Y1 b! l1 D* i; s/ B  h& y/*优先数创建初始PCB信息*/  
  9 G( T8 e$ s3 C% f8 [
  
• 
  # e7 {( P8 Y0 ~" _" k
  ) E' G7 Z% ^. D7 s8 evoid create(char alg)  
  
  
• 
  . x6 J( a9 F* K( p0 v+ t" E
  {  
  
  
• 
  
     PCB *p;  
  
  
• 
  
  ) j7 e; n2 P& [. w   int i,time;  
  
  
• 
  8 t  R: K- U1 y* V
  3 w' `% p& r7 s; r& p0 |   char na[10];  
  7 P, t4 P" T1 ?5 s
  ' e9 w; G( r% b, M9 u
• 
  ) O3 w8 D4 q. b- w# G) H" V/ K
  / Z# Y# n  Z$ _& X) A   ready=NULL; /*就绪队列头指针*/  
  
  " M, d, j9 C0 A
• 
  
     finish=NULL;  /*完成队列头指针*/  
  
  
• 
  8 i- }9 z2 J' _, I# [9 L
     run=NULL; /*运行队列指针*/  
  
  
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  
• 
  6 l0 J% d. s( J/ I0 H5 p- x$ O
  9 h  V# R: {- A+ w7 B* j3 r( }' j   for(i=1;i<=N;i++)  
  * u2 b. Y  c3 }; K4 I
  
• 
  
     {  
  4 P  z% _) g1 W9 R6 t
  1 \% T3 H2 a7 A. `% j6 L" ~: [
• 
  
        p=(PCB *)malloc(sizeof(PCB));  
  1 p8 N* D% [, ?; B8 g
  
• 
  
  # o" ]( I5 n  M5 G8 d8 Z* H$ I      scanf("%s",na);  
  4 o. V+ J; D+ F, T- K$ M- Q- l
  
• 
  % A3 M$ p5 X1 t/ @0 z2 |
        scanf("%d",&time);  
  * S* z- T$ y5 I! v! H0 q( N
  $ u( H' p# f* E: R% k
• 
  
  ( H  \, E0 t: i      strcpy(p->name,na);  
  0 f; J! w) N* [" j
  
• 
  & |- Y% e1 m/ l* d8 B* a- t
  , V; ^3 E2 [; j/ X      p->cputime=0;  
  + z4 H& ]* G  g7 o( T- p" z7 J  z' V
  4 a5 I/ ~5 ]. S4 S% a$ A" @5 B
• 
  2 S% r5 N, K% a1 \: R0 r8 h
        p->needtime=time;  
  4 k. Q2 N  I2 W  Q. B3 B
  0 O) C  h3 ~5 T
• 
  
        p->state='w';  
  + K- J3 B+ A% Y3 J+ ?1 |
  ' v! o( j) Q5 n6 t  O( w2 O
• 
  
        p->prio=50-time;  
  ! L/ L1 r) _" V0 R
  
• 
  
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  1 J! ]3 ^3 X0 r1 ^; x1 z& ?
  8 |- x8 z4 Z) E- ^
• 
  
       insert1(p);  
  
  
• 
  
        else  
  " O5 t* c6 t+ b6 f# u# g& B
  
• 
  9 I  u3 r2 B/ p; J, o6 o6 S& B
        {  
  : ?" J/ t& A' h( T
  
• 
  
  4 Q7 A1 i7 l) D3 R, \' _- z! M     p->next=ready; /*创建就绪队列的第一个PCB*/  
  1 @+ V1 y- o! r4 b8 ]0 R
  1 t! b  E) t. I# F
• 
  
  1 D6 a( v6 V$ r* `     ready=p;  
  ; @- h! \( n- @7 [; [
  
• 
  . k- l, {5 y* d3 v
    ~* V, z6 P% Q* Y      }  
  # U& g0 ~5 Z! l7 ^/ m  ]" L3 Q
  1 E' H! k  G6 I* O
• 
  . ?$ F6 }8 g' |' i7 k1 p
  " C, z# n/ ^! m, ]# `" Q) q2 E1 r" [   }  
  
  
• 
  
  9 Z3 S. f7 O; H   printf("          优先数算法输出信息:\n");  
  
  
• 
  
  $ p$ ]  P: W  R$ B4 z   printf("************************************************\n");  
  
  0 D4 Y! T  H2 n2 f
• 
  
     prt(alg);  /*输出进程PCB信息*/  
  
  
• 
  ! s3 G; j+ @) i; k  U
  * s0 M( s# i" }$ N" |. f, R1 T   run=ready; /*将就绪队列的第一个进程投入运行*/  
  ; T* e$ z( H3 G! U2 [
  ( m( c6 d: F& D6 \2 C! G: j/ d6 g* ^8 J
• 
  
     ready=ready->next;  
  
  
• 
  
  " R, U( |3 D- J' B   run->state='R';  
  7 Q' e5 Z. |: S. \# {- h* |
  
• 
    g3 Q/ H" G5 i7 v2 K& {/ w2 e
  }  
  
  
• 
  8 E1 [, h" N: P9 U0 ]% H
  /*优先数调度算法*/  
  0 H/ k" |2 v" o
  0 n& V) L* `9 M8 z5 o# j. b
• 
  7 ]' A* ~9 ~* z: q" e  `5 A
  # @" D7 v8 H/ V. ^9 |& l' f" j( Vpriority(char alg)  
  
  0 g9 O. A* m5 o! n% n
• 
  * S9 Y9 ~/ A5 |
  {  
  ' c1 R- X7 M9 Z  e# a
  
• 
  6 L) [& O7 u. o4 `3 z4 g
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  . B0 l% d. g' X3 j1 R
  
• 
  
    k& Y& j. Z' S6 d. [- h% p3 @   {  
  
  + v6 l* C" k; l  E$ w
• 
  3 R9 t* a; ^* ]* c, J
  9 i4 }; |8 ^# _8 m      run->cputime=run->cputime+1;  
  
  # Z6 W$ J7 N$ F5 X# M
• 
  
        run->needtime=run->needtime-1;  
  
  / n. w# T5 {0 v
• 
  8 E4 e7 M* v( l. o0 |# [
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  ! F" N- B5 _) [0 W) `) C+ \: U
  
• 
  
  + N6 F7 a# A7 h' V5 @      PCB *p;
  
  
• 
  : h5 Z! j; s$ C- K- B
  - J: u, }4 U# f# Z. N+ w6 J      p=ready;
  
  ( E- }6 _5 o/ w7 U
• 
  
  5 _9 d- W' e0 b! v      while(p!=NULL)  
  # Y1 U1 y! i- `, p3 P
  4 w( ]0 @' w/ F. O
• 
  / b  [" |3 Y5 g- `+ i) c( l
  " F- a, M" W) Y: P# B      {  
  . C: c% K+ B+ S
  + P/ j0 y2 {; u. M" c
• 
  ! f2 t1 _+ w1 j; S/ U1 N- N( D
  + X5 B2 n2 H( p! N$ O0 K7 ~' S3 n          p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  4 B3 d: P0 F# r# H0 R; `
  
• 
  8 w7 u! z0 E; U: b
  1 x- R- b9 W, K% n0 Q. {          p=p->next;  
  
  4 c# Z- Q& u* y0 l. y" I
• 
  9 B/ t# Q3 S( v4 j5 w  m  q. y
  - M" D+ Q9 |" `9 O( V; E      }  
  % P9 P- K: S+ T' {
  7 T1 F; D! o7 K& E% A. l
• 
  % u4 h. L1 P! P8 B
  3 A1 `. z5 g: e9 S* }  v' R' ~      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  0 u* }3 d% u2 P: U# t! L
  - l4 }5 T9 D, R; k
• 
    I' K1 ]4 S1 N3 `3 K9 N( ~- j9 R/ Q. Q: c
  5 W5 f3 A& H" l" d      {  
  
  
• 
  
           run->next=finish;  
  
  5 [9 M. m" ]1 q, z; W% t1 S/ M
• 
  
  3 R% @- E! K3 _0 C/ d) N- I  y( n8 B         finish=run;  
  0 d! H4 k6 ^4 L% [4 m* d
  
• 
  
           run->state='F';  /*置状态为完成态*/  
  - m& _' U: o- w+ P
  
• 
  
           run=NULL;  /*运行队列头指针为空*/  
  + W" V; I; C4 t) n; D( L- r
  
• 
  8 v' ~$ L; Z  \- i4 O0 `
  " n2 k8 n; |$ x9 [& Z; F/ b         if(ready!=NULL) /*如就绪队列不空*/
  4 D, [6 z3 S  t& L& S4 t
  & N- p8 f! _7 k! a9 U6 z
• 
  
  / c4 C8 g5 G3 @& W* ^* ]/ g         {  
  
  8 E5 s) j& v( K# A1 y) V
• 
  
  , Y6 {9 J, [( T3 c! _            firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  5 b9 \) p& K( d2 H, A3 w' w# @: n( A
• 
  / Y8 g. R! Z) U# u" N+ W5 A
           }
  * G9 K+ f5 k! l) z' T) D& e4 N
  
• 
  + z# M9 s% D- U& C/ y
        }  
  
  
• 
  " C8 Y+ M: d3 j+ m1 A3 }  J
  8 l# {, P% T4 G1 Y  c# @7 `      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  
       if((ready!=NULL)&&(run->prio<ready->prio))  
  4 }! t/ X' D2 a+ C: v' s5 i
  
• 
  
       {  
  
  
• 
  
          run->state='W';  
  
  ! I) T% E6 L& w1 E- |1 f7 `% F
• 
  ; h* t$ {) I" n  O
          insert1(run);  
  ( z) u5 `. S* {; R
  
• 
  
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  ; D3 K3 ?* |  c' v
• 
  ; ~4 s+ o' P# u! A$ H" e
  7 v* n1 m6 ~6 j7 D& @- U     }  
  
  / L: Y7 z- e2 J1 c5 S/ H
• 
  . }, z6 u6 h1 b& a
  $ W/ `$ H1 k8 c4 V8 Z) I& V      prt(alg); /*输出进程PCB信息*/  
  2 B* _: K( y! F, w' \+ Z1 x5 D
  % o" ~! N( x. E+ W
• 
  # ~9 S$ e- J" u3 f
  3 i: l1 b, z* P- k8 V8 ]' {   }  
  3 `. F& e9 V$ Y& ]8 ?, b
  
• 
  $ Y' m  g' h+ d) h: o% ]
  }  
  
  
• 
  
  # @  I3 p  A' ?+ G6 A" q4 n/*主函数*/  
  
  
• 
  
  main()  
  3 d2 H. Z4 \' T$ y; k
  5 [  y  c' r" f, m2 @5 p' A9 b+ S
• 
  % y( p+ V; a( o
  {  
  " _- }5 u' M7 c6 K3 M
  
• 
  
  4 G$ u( J, ]9 f" T   char algo;  /*算法标记*/  
  1 B" E3 O6 J5 h6 z. k) A
  
• 
  
  ) a3 S: g" F3 @$ |* p' }, |) L$ o3 z   printf("输入P确定算法：优先数算法\n");  
  
  
• 
  & s! o! D" f" K9 A9 d; r
     scanf("%c",&algo); /*输入字符确定算法*/  
  8 b8 y7 U7 |% z# l3 t$ f2 v
  ' E( m) F6 U1 ?) I; |
• 
  4 c! x- a& u: t8 g: k
  * ?+ c9 |) I2 |/ K- |  R. D3 _( _   printf("输入进程数：\n");  
  
  
• 
  - J# e, w% @$ y& D
  ' X4 @) U2 L3 l* e: `   scanf("%d",&N); /*输入进程数*/  
  " W8 [/ E9 m) R! v
  
• 
  ' w' w4 Z; J& y! |
  , k' X- S; p" K0 b( i8 t   if(algo=='P'||algo=='p')  
  . e) ]5 k* u9 Z3 T! `0 h
  4 n6 H+ W$ x: ^) N1 l
• 
  % C* t+ k" U) x
     {  
  0 _" G+ n4 ~5 s# S6 U& E
  
• 
  
        create(algo); /*优先数法*/  
  3 U; X5 u1 \( u8 f8 L: b
  2 p/ X; v8 r7 }" r8 x1 T+ ]
• 
  
  3 B/ D! W. n2 o8 m6 X5 E& C      priority(algo);  
  7 D' [/ g) m" b$ w7 {( @1 K
  6 ~/ U3 z- R  I
• 
  3 U9 _8 f9 o5 n* z1 A' ?7 F; K
     }
  7 Z' t& O5 g# X$ ]$ |3 L0 l& G
  
• 
  
  }
  * v. Z, I9 ]- U9 `: I5 w
  
  

0 s/ B& j& C' j9 s" h! y输出结果：
5 d* Q/ R* C4 W0 U2 l

/ o7 Y2 P- `  p& B4 e& M; q) f! Q原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

+ J: t& I. X1 ~. z
4 o' e, y" B( x* G6 l