优先级调度算法

杨利霞

优先级调度算法
* v' L8 ?( j8 Y3 u8 ^6 G! I, S

算法介绍
& b, M* M1 f) M/ Q! w* Q优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
! p1 y- p* ~! t" s  N8 Y系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
2 n" {" O4 A* L! N" r/ S! t只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
$ U$ w! i" G; X0 A3 U1 y  b. H. c静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
3 v; S5 [5 ^- Y; E3 q

2）动态优先权
9 }9 @2 x- f2 u# a3 m

算法实现

抢占式动态优先权：

& b+ b- `8 C; V) {2 S# RPS：本人认为非抢占式静态优先权没有实际价值。

• 
  
  $ ]+ ~  a0 T- q* n* o: E#include <stdio.h>
  ' S5 O/ Q* N' i. v
  8 @: {8 c/ G& ]& W2 x8 N: v6 L3 O$ S
• 
  
  " w' ]. {/ E9 A1 L) v#include <stdlib.h>  
  
  
• 
  8 l% |; \" K/ K# Z5 d/ n; A
  #include <string.h>  
  
  
• 
  * L7 ~, u- o( c% k5 g
  * m, {  h1 v. S: J* Q) G6 Ktypedef struct node  
  
  9 U* Y! W/ k0 s9 Z7 \0 D
• 
  ! b9 y0 @6 K: l
  ) W: g0 I% x4 G/ x$ h: B, \( D  A( C/ K# U{  
  * y: m8 r) ]0 O8 C6 k1 ]0 v1 j
  : x, t6 d4 s# A+ F0 L. G
• 
  3 Y  S, c% I& }4 u  m
     char name[10];  /*进程标识符*/  
  0 i2 @% G% S& k4 e! k- W
  
• 
    d: `& J4 `1 I6 m
  ; w+ l' K  d0 I9 g' N   int prio;   /*进程优先数*/  
  
  
• 
  8 K* E% f2 Q% }+ f/ |
  % |2 x. K# a$ f   int round;  /*进程时间轮转时间片*/  
  
  8 w" y; m/ y* [8 E
• 
  
     int cputime; /*进程占用CPU时间*/  
  % p* P, c9 Z6 f
  
• 
  9 m/ }  O& K! h: S
     int needtime; /*进程到完成还要的时间*/  
  % Y4 o+ n2 L4 ]  V/ V! Z
  ( K. d' P! p$ T) e6 x
• 
  # r: e  E" Q1 k5 z" O8 h( w! ^# j, V
     int count;  /*计数器*/  
  . r) x* {. t  h2 K, ?7 s/ s* m# k
  4 k* F3 }% W" }* n# n/ c( h( Z
• 
  $ K% f/ i! D& V( E7 M
  * c. E/ y5 `" }! r% R9 X   char state; /*进程的状态*/  
  
  
• 
  ) f8 p* r* f5 u6 j$ }( c
  2 J: k/ ~) s# C& ]. s6 \+ g2 Q- r) E   struct node *next; /*链指针*/  
  
  
• 
  
  ! `: N) U+ x9 o7 T1 n. o}PCB;  
  
  
• 
  5 [; I" k: |6 i- Y7 H: i- F
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  
• 
  
  int N; /*进程数*/  
  $ F' H$ m  `; [) ~# I5 |
  1 [% T. t& l: ?) b4 G+ {
• 
  1 n! z4 R" N+ U* R, X! D# g
  ; K  ]; @* a( |7 D3 ~  M/*将就绪队列中的第一个进程投入运行*/  
  / B) A5 g& J1 I6 G# ?% ?$ z
  
• 
  
  firstin()  
  ; y' L/ d. I' c( T  `2 }- q
  ( f3 u: T# W$ m$ D; z3 l7 d8 v
• 
  
  {  
  9 A* U- h+ K' R: t+ q
  
• 
  
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  9 ^; [5 _8 l$ ?5 z( a$ i, f
• 
  
  3 D) p9 X: J( i5 ~/ b+ l# p4 ]   run->state='R';   /*进程状态变为运行态*/  
  
  7 M, Y3 F8 z1 a$ Y
• 
  
  - ]3 N4 m$ q3 `& d4 a1 ^   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  ' b, m) h: _; N! d0 B$ q4 T3 j
  , F! c* L7 c2 c: H
• 
  
  }  
  
  . I: I3 k8 u% \
• 
  * z+ V  |- G" s# ]9 C# b
  + F6 }" R; t# b+ ]! M! x/ D, `/*标题输出函数*/  
  : C. M; T4 V9 i# E+ q- K9 ^# S3 a
  ' {- ~1 z2 y# J
• 
  9 q. t& `; l& Z% }2 J4 \; S8 {8 [" o# M
  void prt1(char a)  
  
  
• 
  
  {  
  ' a/ q$ u4 l# F5 J# u& Y1 M
  3 q1 j2 j. R$ m1 F( b' T
• 
  
     if(toupper(a)=='P') /*优先数法*/  
  # Z. A: m: a7 _0 i/ C2 P3 @0 \
  5 P+ S4 F6 P4 {- \6 e; }
• 
  % ]& g8 I- m0 Y" A( |* m5 h, v" ?
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  ) z9 ^2 r0 M% [) [4 A7 a; I/ }
  % \: m$ u0 U2 X* T, {, a
• 
  
  $ J2 S4 p4 k3 d0 w6 D" Y$ l   else  
  8 M, a7 W4 g1 h7 w& a, [
  . v% ^; o2 F3 S
• 
  7 Q2 J/ \4 ?* Z$ M* P9 O
  , K' e: h. A& Q0 o      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  7 |+ b5 H" h# _0 [! \
• 
  9 l4 v8 |6 O3 g- d! N; v0 H
  }  
  
  
• 
  5 A" y4 ^- @. N% `
  /*进程PCB输出*/  
  ' h* u4 H9 u, H9 T: _" X- `
  
• 
  0 k8 T3 ^) M6 Q1 v# v) ~
  ) h* l9 x% n% s9 n9 P4 H! c7 mvoid prt2(char a,PCB *q)  
  
  
• 
  ( G# ]) i, t8 }; E9 w5 j1 I; D
  - X+ f  ?4 Y5 Y1 Z{  
  $ e2 ]" W) r7 I) D, c
  
• 
  
     if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
    \, d/ z  A/ G) A' Q( W
  
• 
  
         q->cputime,q->needtime,q->prio,q->state);  
  $ ^. r, W7 ?5 ~
  
• 
  : Y7 u, R! S4 B  f" l) T$ k1 e- `
     else/*轮转法的输出*/  
  
  
• 
  7 p) d9 z$ H5 @- L8 J  z/ J9 o1 k
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  ( ]$ ^; j. m" y" u0 g& p4 N2 [
• 
  1 r. \. {5 F- t) J9 T' |( j* d* b
  9 w+ t/ f2 \) w3 s' @       q->cputime,q->needtime,q->count,q->round,q->state);  
  , S- v( r2 c9 `( ^  q& z  u% x
    V! F0 ~% ]& _- ]% F( B5 G
• 
  2 Y7 B* w" g3 k. U
  }  
  
  
• 
  + i% @# c( _$ t$ J/ s) @4 U
  /*输出函数*/  
  - G" F, D3 S4 N3 ]
  
• 
  + r. x" H" i" Y+ J5 z( x
  void prt(char algo)  
  3 u# p, x2 i# v2 ]  @& a
  7 E; M# v4 m0 `# Z; g, r" F
• 
  
  {  
  + R; Z+ }- h7 r/ Z9 U
  5 K( c- e, N; g0 I- r  i  u2 G
• 
  
  7 k5 k) ~/ O3 i1 C   PCB *p;  
  
  ; C5 O& M. Q9 `5 d+ O
• 
  - `; Q9 C9 Q! B; [+ J# n+ J5 S
  . A. y$ S4 n4 f$ R6 V# ?$ f& B% o   prt1(algo);  /*输出标题*/  
  
  / j7 ?' g: M* j( t4 s
• 
  
  * ?7 h0 d, C7 q& ^1 I   if(run!=NULL) /*如果运行指针不空*/  
  : f8 G4 Z9 N$ L9 X3 U5 f& {1 U$ `& b
  
• 
  
  , [# W& N# T% ^+ U      prt2(algo,run); /*输出当前正在运行的PCB*/  
  4 C0 _" p( v4 o2 y& x# K5 V
  
• 
  
  & j: n* Z+ y% C- L* q% H; m   p=ready;  /*输出就绪队列PCB*/  
  
  , ^. p. o. @6 L" B, _2 L
• 
  
  ; u+ `% y( a# R2 c$ z4 x/ u$ o   while(p!=NULL)  
  + s1 k: b1 e+ f' C% o- @
    ?* R% u3 {+ G; n- G  n
• 
  
  7 x3 ^  _; q( J# d7 W   {  
  
  
• 
  
        prt2(algo,p);  
  / J& g; P9 V- y4 c$ C+ U
  
• 
  
        p=p->next;  
  ' O3 H) C0 q$ O+ K
  
• 
  
  . X" [/ A, @* n& R3 C   }  
  
  
• 
  
     p=finish;  /*输出完成队列的PCB*/  
  
  
• 
  
  - e! A$ Q9 K, B* I$ p* X   while(p!=NULL)  
  - A4 |7 |8 }& y9 E( Y
  
• 
  # B! `6 q- N, x" f6 r
  : H, ]% E4 A) Z3 H   {  
  
  
• 
  ) b! J, \" _% ~1 n' e  e! N; t" h, p: a
        prt2(algo,p);  
  : d; ]3 E1 `1 \# _
  0 S8 T7 l$ ^! D: d. {) Z
• 
  - c( \' }$ a5 A# \* r) J
  & D7 `1 H" V; T      p=p->next;  
  
  # B( b5 U! c9 w+ p, o
• 
  
  ) W- w3 m2 q* B+ a! Y1 D   }  
  / {' l7 F, d& x9 [& k
  & c9 f4 _+ [  n5 F5 L' C! u0 g
• 
  3 ?0 J- t  v& \( P
  2 g% r  J( a0 Q  u   getchar();  /*压任意键继续*/  
  * n9 U  L8 L/ F2 K- h9 u5 t' I
  
• 
  
  }  
  
  
• 
  
  /*优先数的插入算法*/  
  - K( W: r3 U8 y5 J" W
  ' ^8 ^. |# v# {) H. T3 S  r
• 
  9 w" x$ {; t; E) R2 p1 [! J& d
  insert1(PCB *q)  
  7 O  g- `0 z! W% p% l, W
  . |" ^( K' @# Q0 c. U. g% y
• 
  1 Q, C7 N$ Q: ]" l( f7 k* k' V
  {  
  ! B/ C4 f5 ?: l2 p) J( _
  
• 
  
     PCB *p1,*s,*r;  
  
  
• 
  
  5 S1 O2 D4 k0 N2 Q& e# c9 `   int b;  
  5 W& K$ N4 b+ i8 R
  ( ?) u, V/ J  H/ Z' M
• 
  / w- x( Q# d5 S' ]% ^
  6 u1 v) M+ H" R8 f8 f" R   s=q;  /*待插入的PCB指针*/  
  ' e) C3 [/ g$ @2 J9 l  |; l
  ! p9 V$ b- z" P3 P8 q6 f
• 
  ( c1 s+ J* p3 p8 P4 N2 c4 s& D# I; U( r
     p1=ready; /*就绪队列头指针*/  
  8 M- Q* h0 d% s! S8 X- Z, ^
  
• 
  ( f  R1 B$ s, A% l- X
     r=p1; /*r做p1的前驱指针*/  
  
  
• 
  
  4 `1 y9 D" ]- u" a! H" G0 ?   b=1;  
  
  
• 
  6 g4 |! L* s! C% O5 G: f- o
  # g( o- Y6 c! j+ U   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  " Q& ^, W! I" I5 }3 N7 S. G
  
• 
  
        if(p1->prio>=s->prio)  
  8 p6 C* b% R; l& F1 a
  6 B3 T1 ^9 @7 M: x1 [- q' S3 N
• 
    `! Q, u  {2 R$ ?
        {  
  
  
• 
  
       r=p1;  
  
  
• 
  
       p1=p1->next;  
  . o8 |; {6 ?& l4 h
  ( s+ O) z7 s5 ?) P
• 
  / I( _; `% m3 Q: U
        }  
  6 `9 g  U3 p1 R8 s. ]: t" @
  4 v6 }5 _% Q% M5 X' X% U
• 
  ' P+ P$ @  }3 U& x5 d# T; C7 @
  ' O& _) L* {2 j+ f  x      else  
  
    V$ p9 ]  K, d. y
• 
  
  ' f8 m3 `1 h: K/ g     b=0;  
  4 D( O! S  T; l; x
  
• 
  
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  + @" W3 \. t" D) E+ `2 E; ]
  # D- |# @- z) z$ I& L1 F  U; |
• 
  + N8 w; P' z4 Q* S; R3 O
  # P8 x$ L% P6 g8 g   {  
  
  
• 
  
        r->next=s;  
  5 }! `% h7 H% h' l* _- A
  , [1 p) d4 D8 o' ]8 i6 R! A2 q
• 
  
        s->next=p1;  
  
  9 R1 I$ y8 Y# \; K7 I- j
• 
  
     }  
  
  
• 
  6 r5 o5 e8 ?4 m2 }( a
     else  
  ( s! t( T" M/ S; _# y4 }
  
• 
  6 C7 z6 k, G$ [1 I5 ~) P
     {  
    Y: n" t' u7 f/ n" C
  
• 
  
  4 p6 I0 z, y' D! R0 J      s->next=p1;  /*否则插入在就绪队列的头*/  
  " [. b: A/ h( b* j' H, z) |
  
• 
  
        ready=s;  
  
  
• 
  
     }  
  
  
• 
  
  6 j( l5 q! b6 V1 K4 p}  
  
  % I) \2 _" J' h+ J
• 
  
  /*优先数创建初始PCB信息*/  
  % @4 y) ?$ F; c
  9 q. G5 a' n4 j4 G
• 
  
  8 r# t$ N* X" ]& n# ovoid create(char alg)  
  
  
• 
  / A2 O+ W3 O) w0 Q
  & m& U2 Y1 l( e: W, ^: H3 Z{  
  . m3 V1 |! O% u
  ) |  k& W( c' P
• 
  
  5 o) J) j0 Q+ D2 Y" C   PCB *p;  
  - s& a. |1 |. \+ G& K8 F
  " e- a0 H; B1 v4 N
• 
  ( J, L7 ?" B$ n! g+ a6 h
     int i,time;  
  6 D$ M, s) j1 j4 W
  
• 
  2 m( Q" a6 U+ E
     char na[10];  
  : Q# h5 I( _5 [& R: k( S
  
• 
  . M: i9 x0 O1 ~1 t
     ready=NULL; /*就绪队列头指针*/  
  
  
• 
  " q0 l: \: o! n
     finish=NULL;  /*完成队列头指针*/  
    w  S* H5 O4 U* U4 v
  
• 
  # B8 a6 S& v: l  @6 t/ n7 q
     run=NULL; /*运行队列指针*/  
  
  % `7 n* I' M2 N" v! j
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  
• 
  
     for(i=1;i<=N;i++)  
  
  
• 
  ) D, O- C4 P; j. J6 Z( h* r; S
  & f9 L! b! Z9 j   {  
  
  
• 
  . G4 v% X' q+ Z6 e6 T8 D; Y
        p=(PCB *)malloc(sizeof(PCB));  
  
  
• 
  
        scanf("%s",na);  
  5 g  A8 U/ {& R* O# b, [
  
• 
  - E' C0 l$ _; h2 D! d
        scanf("%d",&time);  
  
  , k, c' O8 a. v' P- t
• 
  
  & x& p! ~# l# b8 w2 m* K      strcpy(p->name,na);  
  # e% x* j8 \) ?, H5 l5 i3 W
  & X* a4 K% Q4 k0 J3 @. c/ ^
• 
  * Z$ E" e3 \* u( s1 ~1 Y1 V
  ; I( u) F+ n1 D  m2 C) ?* a, N      p->cputime=0;  
  
  0 R" i# s) p7 [# a, w
• 
  & z8 ^" f; I# ]  G( p9 {0 Q
        p->needtime=time;  
  
  ! ]. o: l/ ]1 k0 i8 ], w; `
• 
  . a$ }1 z' b6 P7 R8 o" u; R" \( v
        p->state='w';  
  & c  D9 G% I: U; j+ Y' r, M/ L  E0 l
  ; [, K- ]0 s. |/ A
• 
  
  . r  ~* L) }/ Z7 O+ o/ L      p->prio=50-time;  
  ) Q3 K/ m- w3 H. x% o
  
• 
  ( U% S! N8 H- J
  ' @2 W* {; n" U" Q. p      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  
• 
  - b; a" x+ a& ~/ _- |' P0 k
       insert1(p);  
  
  $ P9 h  R) F& E
• 
  
        else  
  
  , Q( t- y5 u# ~6 x' c% d
• 
  7 d/ X: D5 U& W
        {  
  / E2 z+ F: ^2 V" p: m) u
  
• 
  
  ! g) {1 ~  k2 D0 T2 X/ `     p->next=ready; /*创建就绪队列的第一个PCB*/  
    u+ r  I1 b, z
  , z' v8 A/ B+ S. _; v( o0 \; x
• 
  - _! S/ R/ a( H
  ! j0 R2 W5 O$ F# z     ready=p;  
  
  ) w% P" L+ A8 M# X
• 
  6 R/ X$ F/ k& J  J  G
  ) o" Y* g/ P) g% a      }  
  
  
• 
  
  1 L" y/ E7 Q  s# Z3 e# k2 |. B   }  
  
  
• 
  
     printf("          优先数算法输出信息:\n");  
  
  
• 
  " e; u9 P  d: v) N4 l2 R
     printf("************************************************\n");  
  
  ( r. k2 l# f+ a( v
• 
  
     prt(alg);  /*输出进程PCB信息*/  
  
  
• 
  8 x0 e3 Q9 v* u- c; L% K1 i
  5 p$ |* a2 G' o- Q. _3 {   run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  4 F9 I* A7 W5 d3 u3 f* Z
  3 ]! C2 S2 \6 Q7 R9 \6 y3 q   ready=ready->next;  
  
  
• 
  1 D8 [4 Y' o2 z0 z5 g1 f
     run->state='R';  
  
  " \' O. v9 B5 n( W" O( ?
• 
  + \) _1 ^% n5 P
  5 j) U% v2 ^* x9 W5 O}  
  
  ( [  U( ?( t; q  B
• 
  
  5 k0 l. f/ W0 Z/ ?/*优先数调度算法*/  
  5 |6 C& W! t+ j# }* y
  
• 
  
  priority(char alg)  
  
  : J$ k; B+ C1 V
• 
  8 q6 D. c4 U, j/ u
  9 ]  r) N6 O% h4 r; T{  
  9 k4 W8 V9 R- ?6 L: Y7 z
  ) n  h9 E: X& s; H4 g$ o
• 
  & G# E6 T0 F4 m! j; N
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  $ H! V/ `; K2 y4 b  B
  
• 
  
     {  
  ) y9 g6 v0 m6 ?/ X: W
  8 P" o& A* C, Z( H3 W% h
• 
  . r0 Q0 ^9 l# u% r+ ^+ I" _4 T$ g
        run->cputime=run->cputime+1;  
  
  % `% z+ E8 n: p6 k8 [8 e
• 
  
  ; y5 v9 z% P& e& c      run->needtime=run->needtime-1;  
  
  
• 
  
  1 W: n4 \. {' i9 D' @% a      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  
• 
  ) t  c! ~$ Z4 j9 E
  2 e# i* T* S; _: ~      PCB *p;
  
  6 Q8 j% U& F% D8 b% i
• 
  
  0 T7 K& P2 L' P9 S      p=ready;
  2 `: i; H: `8 z  q" t/ o) g
  
• 
  6 }  h( n) c) q6 k3 ^
        while(p!=NULL)  
  
  " A/ Z4 e  h/ R% w1 L) X
• 
  
  ; D% S% P+ w' B( \  `      {  
  
  
• 
  
  7 n. M* E, e# x$ w( k8 ~          p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  / }& x" U; `: b4 N! K
  
• 
  + U5 H; D4 K$ e/ i4 J5 c0 v$ `: y; G* |
            p=p->next;  
  + R, U& F4 R) `7 n1 v! i$ y) A+ N% n
  4 u% v9 N) Z4 {. A2 m
• 
  
  " Y: T! N6 e+ t1 I2 c% G( U      }  
  
  
• 
  
  0 t9 L% e' b, C! X$ [      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  
• 
  & p) t2 k( j0 @/ U0 \
  & q& L# `; y3 R; N/ q      {  
  
  8 W* Q3 P& @. r# T
• 
  . l1 O0 K8 d# W0 l2 T
    Q9 \) U& M; G' j8 h* l         run->next=finish;  
  
  
• 
  / `* `3 c0 U7 A+ [* O1 l
  ! n, Z$ ]. ]  K* I: h         finish=run;  
    d. s" X- ]& A+ J
  . f1 _2 B1 \, M+ p0 j$ m
• 
  3 Q  C: g! t6 ]9 A
           run->state='F';  /*置状态为完成态*/  
  & u3 c% U/ l8 @( x/ {
  : {% s* s. M. q  m+ H. Z" h8 U$ r
• 
  7 J  O* W  S+ t' k: T, d% A
           run=NULL;  /*运行队列头指针为空*/  
  2 E- D0 w/ @7 ~8 l1 W7 R
  
• 
  
  * K- @! I9 {$ W5 J% y         if(ready!=NULL) /*如就绪队列不空*/
  7 Z9 [; z8 \; m1 Q- p: [- C
  
• 
  
  - y, M) k. W; I         {  
  
  # P* ]' B$ O- l( D7 K
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  - x' j3 r0 |8 `3 t
  
• 
  % E7 h2 P  a8 K) X3 l/ J
  0 g, c, t  ?$ ?0 c' u: ]& s2 _* x         }
  
  
• 
  
        }  
  
  
• 
  
  7 D$ q& F( S/ `  h/ ?8 f& f      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  4 X& \5 P, }' d3 ~% l0 P$ P* A
• 
  
  & Q0 R$ V( i: l* G2 X" k     if((ready!=NULL)&&(run->prio<ready->prio))  
  
  
• 
  
  3 H( w" g2 A- ]+ H7 H     {  
  
  ' T# I  q  t( i, @0 P1 C
• 
  
          run->state='W';  
  5 D$ E2 B8 \2 T
  1 K' f" b+ y4 r* Z6 X% r3 u
• 
  
  . `$ b% t7 h( Z; @7 u  x        insert1(run);  
  
  
• 
  
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  9 g8 {1 ^/ ^3 ^0 V! q
• 
  
  0 V/ h% _6 B2 A$ F5 R/ H- G; B     }  
  + P+ K" y+ z  \7 {- ~2 l
  " b" V# A! I' N8 a* c1 z& Y  a
• 
    V+ i$ ^8 a4 f+ U3 \
    Z& c/ F) U0 B5 \      prt(alg); /*输出进程PCB信息*/  
  
  
• 
  : Y8 _7 I+ |8 z9 h) ]* z6 r
  $ w5 _; ~8 \2 A( W   }  
  . p" |% t  A9 ~
  0 I2 l5 `. b: A
• 
  , c" e0 v" K2 l: C
  }  
  
  
• 
  , I# v) ^3 ?  ?# j( T! J! V' F- C* U
  /*主函数*/  
  
  
• 
  ( k( I4 @8 P- i0 j
  7 ?/ a) L$ d8 e3 H6 Fmain()  
  . }- ^; v3 }# O3 |9 B# }
  9 {: U) p/ _4 |& I6 o
• 
  
    d8 o8 \- }% P# H{  
  
  ' d/ o  }/ h# X* @+ r0 L
• 
  + X, H2 v/ K. M+ Z7 w
  . B, O* }7 }$ v1 F   char algo;  /*算法标记*/  
  ) I1 F% ?+ E% s( L- |+ F
  3 S0 m1 g$ r3 t* m2 h& V; u
• 
  
     printf("输入P确定算法：优先数算法\n");  
  - O: ^6 t6 M0 S5 A5 l
  6 n" `6 V( I5 t" {" d5 V/ r
• 
  
  ! d. q( u" _, l% l   scanf("%c",&algo); /*输入字符确定算法*/  
  # E, f* Y/ B! P5 p
  / n% G! ]' g4 @) H! S9 ^
• 
  
     printf("输入进程数：\n");  
  1 h; Z1 R8 d2 f4 b5 v1 i+ V
  % [/ \( W8 P3 f' _0 L  M. T
• 
  2 B8 y0 j/ w- Z! @8 w
     scanf("%d",&N); /*输入进程数*/  
  
  
• 
  7 s% N0 V8 s7 [9 i. K; P9 `
  , ~( o7 C) p- y# a# t   if(algo=='P'||algo=='p')  
  
  
• 
  
  + d$ y. B* \! s# O! v% R   {  
  
  
• 
  
  4 M; g' y8 `) v6 {3 D      create(algo); /*优先数法*/  
  
  
• 
  ( n" d3 t. H9 k% V+ @& f
        priority(algo);  
  
  9 L+ Z: c+ R5 P9 G$ h
• 
  
  - a3 a: _+ B  U- v# ?   }
  ) T4 S5 X5 v! q9 |
  
• 
  - j: y& A9 A: f1 s0 `" }
  }
    `+ C9 Z! e$ a5 t
    N+ q* V' z) {! ~1 b
  

8 S, B& R; b; K& [2 M输出结果：
7 M. u  n: _: @4 C# G; V

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

' Q, _5 a& C2 j. j, c/ O