优先级调度算法

杨利霞

- Z% p- [% A$ n4 ~8 D6 r优先级调度算法

算法介绍
% [3 z- M$ y- q  U; [) r6 h优先调度算法的类型（用于作业调度）
9 V1 q# ?; t5 o$ ~7 K, [' a. U1）非抢占式优先权调度算法
( Y/ D  P. @, b' K9 u系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
3 s! y4 N2 Q# N4 h; a, L3 I只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
0 G0 u* X) o) S" z8 C2 w静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
; \2 _' [4 s% ^  ~& F

2）动态优先权
9 {1 h- h( h8 d: `

算法实现

抢占式动态优先权：

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

• 
  % s: w) I2 m( b8 s- i1 W; z
  ( J* z. f  C0 p3 m; ?5 d7 V#include <stdio.h>
  : a' Y. p! ?) l: I
  
• 
  
  : N& `5 m# p+ i1 f#include <stdlib.h>  
  ( O6 e/ g4 a& N* `2 N4 t
  # I7 o2 Y0 n, h3 n. C8 Q7 p
• 
  
  ' C. v8 R5 H! |, R$ i#include <string.h>  
  ) f8 Y% x  _7 _* `- X/ z
  6 l7 D( k* F- h! {, b) W
• 
  - k/ y% G5 w* U3 J" Q
  * l$ s% A; h$ m; J; |5 M; @7 \typedef struct node  
  2 z* Q5 f1 X- C8 Q* ~/ l1 G
  
• 
  
  8 \" {% i/ x# {{  
  * K- j, S. a% `% z# y8 i& v
  , l! n- ^7 E% M8 V: ^
• 
  6 ~0 q' s2 P  x: M0 }1 V0 b
  ( |' i" s, K* F/ L2 d- K! N! q   char name[10];  /*进程标识符*/  
  / `$ O% B; y, p5 L9 y: x
  
• 
  
     int prio;   /*进程优先数*/  
  % i6 \; T6 o" ?4 q7 C3 b
  
• 
  
  5 b' K( x1 u/ G3 H   int round;  /*进程时间轮转时间片*/  
  , T$ p. H" M3 A  `  H
  
• 
  
  8 |" F6 Z1 E1 t) P7 G/ ]   int cputime; /*进程占用CPU时间*/  
  ' g$ W- Y& P5 c. R6 d& R5 ?% N% [
  
• 
  
  , O, f: t) B' H3 G/ e   int needtime; /*进程到完成还要的时间*/  
  ( U! A* `' ?+ `6 F2 M. ~- X
  
• 
  
     int count;  /*计数器*/  
  
  
• 
  
     char state; /*进程的状态*/  
  6 j8 \" L3 G4 X* Y% u+ Q: W
  
• 
  
     struct node *next; /*链指针*/  
  ) n0 R" Z. D5 n& I
  
• 
  3 `% H$ q+ N6 B( @2 `& K& Y' B( e( b
  ; ^  A  V! ^/ x& K3 R/ Y}PCB;  
  3 `1 Y" N1 j' U
  
• 
  ! l" P" F8 c9 h* l% [  o
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  7 |  d$ P# e8 p+ o- ]
  $ O. |: O, P; ]2 Y( d! y+ u: B
• 
  " f; A, f: S1 {
  int N; /*进程数*/  
  ) n" ?5 S- ~. N: ~: E9 G
  ; ]" M* ^$ U: k# \9 N, e
• 
  
  /*将就绪队列中的第一个进程投入运行*/  
  & J  p, b* J% d
  8 y5 a0 d4 ?5 V/ G0 b
• 
  . P5 r1 l4 j8 R6 Q) L5 ?) i
  / o! R. K$ S0 m, P+ J) efirstin()  
  
  : v4 B, x4 ]  U4 U: ]8 d8 D
• 
  1 {; E: N4 H0 x
  & J3 E) r: o: ?' p: @* z4 J' ^* Q+ b{  
  ; ?$ s; }/ C  Q* l$ H
  " P# b9 Z1 [! |* |
• 
  
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  3 b! D6 r: [6 W- _6 b
• 
  : E; B( \8 D0 s
     run->state='R';   /*进程状态变为运行态*/  
  
  . R6 f; N4 w6 A2 n7 U* f2 K
• 
  " V0 Z$ c& _# ]) e3 P5 Q+ @* f* T
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  ! P" `$ E8 U+ K. I
  
• 
  $ ~/ z7 x) e- O6 F; A& g9 ?
  }  
  3 V/ b+ u$ S! c+ R
  
• 
  
  % {. x3 Z- p; ~& x$ g% {4 `5 f/*标题输出函数*/  
  1 i: x  \0 M( o0 u, f* f
  3 M5 D# J: X5 j; o  Z
• 
  3 {+ k3 g5 Q& N  D. F1 @
  void prt1(char a)  
  % Q0 n* [+ B% C& m) u' }
  
• 
  
  {  
  
  9 U) m1 ~4 m+ s* |
• 
  * i5 `& }+ p' K" \% X( E% ~
     if(toupper(a)=='P') /*优先数法*/  
  
  
• 
  ( `& A0 n$ d1 m0 L
  9 Q1 `9 j0 L7 j( x7 N/ J3 F/ d      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  
     else  
  ' ]+ i, N7 R0 i1 @  l
  ) B3 e  l; T7 m% `3 E7 ~9 e5 f
• 
  2 S8 A; M; ^4 G7 }% a2 T
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  
• 
  ' J6 u) {& c) K+ [5 v
  }  
  $ U+ d: O  }2 x0 l+ b% w) x" n
  
• 
    Q% G( ?2 Y4 E+ J0 {( x; R
  /*进程PCB输出*/  
  
  
• 
  
  8 E7 H4 _2 `  V  ]% B6 F4 _void prt2(char a,PCB *q)  
  
  
• 
  
  {  
  
  
• 
  2 \5 }0 ~" }: c0 K% w3 n6 j
  1 \/ C1 h' i) K6 h   if(toupper(a)=='P')  /*优先数法的输出*/  
  
  0 ]% f$ C. D6 y" e/ P8 l
• 
  
  ( c8 q8 [) G8 o( d4 f- F      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  
• 
  
         q->cputime,q->needtime,q->prio,q->state);  
  # _: d6 b  j7 i& T) ]' p; Y. Q
  
• 
  
     else/*轮转法的输出*/  
  
  . ~( F( c& Z# h$ e9 W4 M
• 
  1 n; g/ f( }/ p7 V1 |
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  ' s3 M% x6 c8 I8 _! ~' g0 V
• 
  , I9 P$ {, t0 |& o  i  e
         q->cputime,q->needtime,q->count,q->round,q->state);  
  4 k+ b2 X3 \2 A& S' B
  
• 
  : g3 I2 b7 N1 [& c' V+ m: D
  - @6 U% ~0 p$ e# F2 t}  
  
  
• 
  
  ; Y4 v- U0 L* H0 W: R/*输出函数*/  
  9 w6 w5 V( y, J7 W1 g9 F8 S5 T
  
• 
  1 ]7 u% O3 p6 ~# H
  ( A& a! k  U) l3 Zvoid prt(char algo)  
  
  5 e' s, B/ _1 R2 \, {* K
• 
  $ d8 e- M9 Y! @, j) s% M( u, I
  {  
  
  
• 
  
  6 q) e, G5 L9 w   PCB *p;  
  : m( d. n" x1 k! ]4 Q4 D
  
• 
  
     prt1(algo);  /*输出标题*/  
  
  6 [( c% q5 J* G5 `/ }
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
    q2 b  o; k, ], @
  1 V; L" j% [: G# r5 S/ j, F* ]* ~
• 
  
  ) P/ a+ x* G4 Q& l# o      prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  ) f4 o: }& X) @; [6 }& p; o
• 
  
     p=ready;  /*输出就绪队列PCB*/  
  1 x+ P% {0 P* ]0 ^) B
  
• 
  $ l4 s3 |+ o: K
     while(p!=NULL)  
  
  
• 
  $ B3 Z" S; b4 F' K- N3 S* r( l$ ^  v
     {  
  ; x! O" w0 E3 m; O8 `
  ! E. i0 s- X! X$ {# u6 R" c8 \# F2 ]
• 
  0 \& t/ z5 _2 Z9 g" @6 Q  a+ N
  # X& `( `( S' I) A      prt2(algo,p);  
  ' y. u/ M% S5 v" T
  
• 
  
        p=p->next;  
  
  
• 
  # Z: K$ \2 s+ @9 n& L9 M5 _6 k3 X
  : Y( w7 Y- r" Q. Y% Z   }  
  
  
• 
  ) w) Q1 c: E8 n- c& O% {4 v
     p=finish;  /*输出完成队列的PCB*/  
  $ o8 a! `( f5 B5 @1 q1 l! w
  0 o( F/ a$ {4 v2 o- L
• 
  5 ^4 W( ^9 K5 h7 t1 ?6 s
  + k7 e( d( q/ d  \   while(p!=NULL)  
  " y9 n1 c' l# L
  7 N. K: V9 m9 z
• 
  0 ]! o6 J5 @1 S+ H
     {  
  9 l1 h6 ]5 d& I* C/ H& V
  ' q$ l+ ^1 h% F' o9 i4 P
• 
  7 C6 I, O( ^0 {1 z0 E/ Y6 s+ `
  : V" m% v% `. ~# x      prt2(algo,p);  
  
  1 ?2 \: r5 d" B, n
• 
  
  # |( U+ U$ k& c% m$ s2 u8 E      p=p->next;  
  
  + ~" @- x& F! ~; K
• 
  
     }  
  9 ~+ ^" ^$ Z- D5 k. _- x  K+ U9 B
  
• 
  6 k, {" ~1 a6 |2 Y
     getchar();  /*压任意键继续*/  
  
  
• 
  
  6 L  I4 s+ S% @& n}  
  : m3 b( T+ S. y
  
• 
  5 }" V7 X( r  j
  /*优先数的插入算法*/  
  ; P2 F: L. |$ W- w
  
• 
  
  6 W/ ]( q5 V' J1 X. v4 d+ ~insert1(PCB *q)  
  $ E: v* \+ F& d# J" g5 Y+ ~
  
• 
  
  {  
  
  - Z$ v4 L& R! _9 ~; H
• 
  . }- u+ p; U2 {. ~! V. Y
  0 D! B/ m# K2 a9 n9 Q6 K# |% N4 o   PCB *p1,*s,*r;  
  8 ]  O: {) q6 k# J7 B
  2 V3 z) O6 f% h. D: F
• 
  8 u. c3 d/ }" l, `; S
     int b;  
  : ?) @% N2 n2 u; Z3 r: x5 h
  2 Z  ]4 T' u( R) g
• 
  6 {9 Q# b! }. D8 H. o2 z0 [2 l
     s=q;  /*待插入的PCB指针*/  
  
  
• 
  ) B# p8 y# z, i  c
    i$ ]' Q& q& a) ^" T1 N7 m" P& Q   p1=ready; /*就绪队列头指针*/  
  
  
• 
  
  : n( A# v" `* V- s% T   r=p1; /*r做p1的前驱指针*/  
  
  
• 
  
  , ?) c* Q1 M- e" H3 j   b=1;  
  
  6 \) x! |. r, K( s1 R  r; M$ j" d+ R4 h
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  ( s3 u* L, A# \& o% S# [/ N% h
  
• 
  5 G- p$ r4 N4 K* [9 n
  4 g0 ?6 o/ Q3 W      if(p1->prio>=s->prio)  
  
  8 h4 b% X. @* o& V, O
• 
  : v; ~% @5 G& K! i% u# l
  7 V3 R: t! V- ^! T2 v. ?7 w- v4 l4 s      {  
  
  8 U- m  x. G: p/ b
• 
  
       r=p1;  
  
  
• 
  
       p1=p1->next;  
  
  ( u" s3 p9 U8 S) b9 q' \
• 
  % t2 \% O2 r: k5 s
        }  
  0 \$ ^1 M  t. @- i; P; ~3 S
  $ n9 [  a- J# A  \0 }# ]
• 
  
  1 V) W" H) @+ t; K' ~3 O      else  
  $ X8 |$ N( T% y6 F
  $ g  l. ^, Y9 e! U
• 
  
  8 B# d: Q5 Z- ^6 z1 v     b=0;  
  
  
• 
  
  2 w) {+ \0 n$ H: Z& v& ~   if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  9 o2 z7 ?, G3 }; M' l1 N
• 
  
     {  
  
  
• 
  
        r->next=s;  
  % I* b! ~- C0 J& U7 R
  . z* Y! T8 S4 q( f- k. \/ y
• 
  ) a* P$ u8 y# d# K4 X4 ^7 K
        s->next=p1;  
  # W8 J. w/ P# \
  5 \+ Y  ~, K, V: b
• 
  ' B$ K# R" v* T7 P4 Z
  . v1 H1 [5 j. b1 H0 ?  I" m   }  
  " U3 t2 B9 p% j
  # T0 R4 B5 G$ f* Z4 a# V
• 
  
  # m. R! f/ ^# R; f% C' K4 j2 ^   else  
  
  
• 
  
     {  
  
  7 k3 ^' z2 f: o) `8 _
• 
  
  & l! f6 K0 d; ~      s->next=p1;  /*否则插入在就绪队列的头*/  
    ~2 @7 n: K1 d* X
  1 ]0 t- w# U6 f* {% w
• 
  
        ready=s;  
  $ Z" C; b: D! v6 |; J
  
• 
  
  , U/ p% O+ X  B0 `   }  
  
  
• 
  1 }6 b( m' s3 `: G9 t4 t
  + O* M* o  h" S5 C- s* \+ s}  
  8 y: i% @2 c, M) K/ u) v: s  P) K
  " Y+ ?+ [/ }! r
• 
  
  /*优先数创建初始PCB信息*/  
  9 k/ ?6 I3 O) J7 Y7 L% P3 q
  - D! n. h4 A4 l# P2 S
• 
  
  void create(char alg)  
  
  
• 
  
  {  
  ' Y% ~. \3 N9 K5 y, l9 F1 A
  . g2 Y) z+ U: C, s
• 
  ) W( E% O, q! }; ^3 ]  a  ?4 p1 g. p
     PCB *p;  
  
  
• 
  
  2 I7 d* `( U+ z' W- G   int i,time;  
  
  
• 
  
     char na[10];  
  
  ) C/ \9 U0 P1 z4 B4 x* y" r
• 
  1 N2 g" w' S: _& z; S7 l
     ready=NULL; /*就绪队列头指针*/  
  9 `( m: r  L- N2 r' e4 W
  
• 
  7 J% _: G& Z' j' j: _5 Z1 a" C
     finish=NULL;  /*完成队列头指针*/  
  # p0 V6 B; ]; f6 Z3 C
    [% K% c6 O/ m3 q/ v- z# m
• 
  
  ; G" ^% \0 h" }2 z' `8 U   run=NULL; /*运行队列指针*/  
  
  $ G4 O1 d. y4 A9 l. O0 J/ k  S" t
• 
  / S0 w7 X" x/ W
  ! j9 c& M2 z& k  Y- r; h9 O( ^% u   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  6 D, p% H$ i" R/ m: A# d* i
  
• 
  
  7 k5 x) r# q6 E7 W, K   for(i=1;i<=N;i++)  
  3 E! W4 M$ s4 ^9 e, a% M
  # c$ {" d% F  a+ V( `# m5 @
• 
  
  % V/ m! Y) y! w   {  
  
  3 Z( F2 B: w$ q2 z4 y0 R: ?
• 
  
        p=(PCB *)malloc(sizeof(PCB));  
  2 i+ n8 q( K+ Q
  * F/ V* b6 d# n8 D3 ]6 W
• 
  
        scanf("%s",na);  
  5 m1 X9 r1 `, @# v- n  h  U
  
• 
  
        scanf("%d",&time);  
  9 U. d$ b# e# z5 k; N
  
• 
  4 `& s# I7 G  T  _) W
        strcpy(p->name,na);  
  # E* J; G* H. k9 ?+ ?
  
• 
  ) r9 x8 \5 W3 e) A
  8 b) p1 I( z, p8 O+ I      p->cputime=0;  
  # e' B' r& M# u$ B/ t9 w8 c8 c$ }
  1 {, }& d0 R* D( e: V' A5 I
• 
  
        p->needtime=time;  
  
  
• 
  ) a! I: l1 s2 `0 k1 b% ]3 }
  ( q4 n, e  ^& T8 y5 V) s      p->state='w';  
  " G$ A( N, }9 K& \- I- X1 U
  ) R8 p% S& i: {2 L2 w/ F2 }) D% l( C
• 
  ' P: |2 \9 q  |5 s
  5 |4 M7 n3 n/ @( V" J      p->prio=50-time;  
  0 Z; F3 @9 U! V1 K5 b+ x
  ! u8 R& R4 i2 E& y* k
• 
  
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  0 {& Z% J; i; E$ d% W% u3 o, [) p
• 
  
  7 E. g: H/ e- q0 t* E; z' w5 f     insert1(p);  
  
  
• 
  # I2 `4 ^- n- f4 ?; F/ z9 d8 s  ^
        else  
  
  
• 
  5 M8 o2 l  J- i8 ]
  ) w* `) F/ T/ S5 s6 e      {  
  
    s! R, ?! _' [, @* ?
• 
  ' {$ M) m1 D4 ]1 q: l) W+ v! g
       p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  ) p  ~  y' z2 J1 x. z' k
• 
  
       ready=p;  
  , k2 H* j1 ]: J/ p4 _" \+ Z5 A( E
  : t2 x6 C3 C+ u% _$ Y
• 
  
  % O! `) |$ c8 T& Q+ b8 M      }  
  - m- L0 B$ G, [' u
  
• 
    t  l* u" P7 m: d; `$ B( o! s2 B
  8 @9 i8 t1 k7 z, T; \5 T# x   }  
  
  
• 
  
  , C9 f! \  Q- S* x9 w, M1 n   printf("          优先数算法输出信息:\n");  
  
  5 U/ l% @0 L/ C# `! A
• 
  
     printf("************************************************\n");  
  
  
• 
  
  ' ~  z, F3 p- D$ e) |: F  Q   prt(alg);  /*输出进程PCB信息*/  
  
  7 q, i/ Y+ f+ w  [3 r- B/ A
• 
    K( w7 U+ u3 v" G6 ?
  " j! z2 N. V8 n/ }& Z& d% Z! E2 V   run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  0 k2 p# l# I# u' F8 t9 U) x- k
• 
  + E8 o- D( E) d0 X2 N: T- W7 l8 C  z# ]
     ready=ready->next;  
  
  
• 
  
     run->state='R';  
    ?, I5 K! f7 U$ {$ j, z
  
• 
  
  }  
  
  
• 
  & w/ M! l3 u1 A8 H7 P
  /*优先数调度算法*/  
  
  
• 
  , j+ Z! R4 L5 v
  priority(char alg)  
  
  
• 
  
  {  
  , u7 Q6 I0 K% h
  : u* p7 M6 i2 i- X8 O, s
• 
  5 A, g5 W. ?* v/ ~' P. E) W) n9 |
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  
• 
  8 `/ }$ S" B: u- D. B% v1 A
     {  
  
  2 ?* x7 e; G" N
• 
  9 o, |' W! ?* k4 u- G, q" C+ \
        run->cputime=run->cputime+1;  
  4 v! ^" E0 P, @# U
  
• 
  8 q& s- A8 c0 @1 M# ?
  . k, J" g# _4 w  ]% @! X+ [      run->needtime=run->needtime-1;  
  ! e, |2 B( r8 b; E- s, y# c
  2 [: O1 d/ `+ i$ d6 C1 @  J8 z
• 
  
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
    P" q6 u8 t5 E: p2 e2 g: ?( `
  3 l, f0 f. U* p7 U2 ~$ H
• 
  0 g/ ~9 p) p2 F$ B, x
  - ]; t( e2 F$ j0 ~1 g% s' T      PCB *p;
  
  * @# F7 Y& Y! E, B% S9 N% I; X4 W+ {
• 
  
  6 b7 v! m% v- o. j% Y      p=ready;
  
  
• 
  ' F* o- k+ r9 m( ?8 T
  8 m* R' A. Y5 J: v      while(p!=NULL)  
  / W: J. Y  e* [! g5 w
  
• 
  
  & U; g1 B6 K1 L      {  
  
  
• 
  
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  0 d7 O6 m4 K& f& p1 ^1 s; X
  % z. o. {; `8 U2 J' ?+ X, S
• 
  
            p=p->next;  
  * l, t0 L' z9 S+ ^, D: j
  
• 
    x, ?. I: W: ?6 Y" q
  ! d1 x1 L5 [: S$ _5 [$ g+ N7 x      }  
  0 T/ P3 d1 A- v: F% r
  
• 
  
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  0 b/ t  Q  w1 f! d
• 
  ( n9 y9 S& b9 g& o7 W* s
    o6 y7 }; I! n" m% s5 \# j      {  
  
    H9 Z8 p- n. E' C
• 
  & ~9 c3 N+ P/ E9 x! X
  " s1 P6 i4 D2 \( ~4 p9 J$ @         run->next=finish;  
  
  6 Q1 l2 K$ f  r: x" `9 m6 Z( t% }( X
• 
  6 h, i5 Y3 m9 w' G
    \" N9 P0 f' p- a2 v         finish=run;  
  0 f4 J" I( e# m/ a! n7 W) D
  
• 
  5 G  e0 t- U2 e) O4 W) u6 T9 [
  9 I+ @" I: s9 q# J. E         run->state='F';  /*置状态为完成态*/  
  9 G" i2 i& M: T
  
• 
  8 y; S. p. e' a
  8 I) N$ h2 g' f+ t1 D4 z         run=NULL;  /*运行队列头指针为空*/  
  : X5 N' L7 r( D0 Q* _! U4 u# I8 X& R
  
• 
  0 V$ J* h( X1 _! i! B
           if(ready!=NULL) /*如就绪队列不空*/
  
  
• 
  / |  @0 g+ e$ s' ~
           {  
  0 ?' f# B* |1 b7 s/ F* o1 c& {
  : D6 |  J) T% C, m& f6 ^# c
• 
  
  6 ^6 Y0 h+ p( A" q% j, |3 X( G) y            firstin(); /*将就绪对列的第一个进程投入运行*/  
  9 }* c: h; R& r# m3 ~# A
  " n- z  i$ J1 q$ p4 s* O( \* K; u$ l
• 
  / Z0 _' O' w, k/ k
  6 R. g0 V# T; j/ M0 o" b! M! @         }
  
  - U1 @- F" s' M1 G  n
• 
  - `5 y# h# f( S0 n1 Y4 h
        }  
  , W3 q) s3 d; G2 v, }. i' @- d
  " a- T; z- k3 j+ o( B
• 
  
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  / D8 v# E  c' @5 `0 @
  7 U' \5 C6 Z' w' x* m( j! k% ^* ]     if((ready!=NULL)&&(run->prio<ready->prio))  
  
  
• 
  
  ! q! m5 f: H% l$ r$ G. J     {  
  
  
• 
  / Y* ]1 V4 }4 `, `) Z' S& r
  $ p7 p( w" p( R2 S( F# W2 a, m5 d& F        run->state='W';  
  
  
• 
  5 R- S6 n0 ^( \( K
          insert1(run);  
  
  
• 
  
  3 p" t) k7 I( X+ g: c8 n        firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  + V  M; P$ ^7 J# G
• 
  $ R. s. y8 q+ ~
       }  
  
  
• 
  
  7 X- `; t. b& ~# R& c+ `& S      prt(alg); /*输出进程PCB信息*/  
  
  
• 
  
     }  
  
  
• 
  ) G/ |0 [1 S* P# i
  : Y2 u% ]: C; g7 q9 J5 {# E}  
  
  * R( ?/ \3 p; O* g- r
• 
  3 g+ n, L4 l& P* _* ^/ U" U+ C" k
  /*主函数*/  
  
  0 b" b1 g+ C& i+ a) B3 T# @
• 
  1 ]( i. z! f9 {+ C" A+ g. `4 D' K$ f
  main()  
  ) o6 G( c8 H. D1 d  O
  $ ?( ]5 P& C5 k
• 
  
  9 t# S" \0 X0 H2 F{  
  / Q( R+ P% Q/ d) y, [- U) l
  
• 
  ( m0 c2 b! K6 l( J
  4 d# E  o6 x* p. \! b1 r0 Q   char algo;  /*算法标记*/  
  
    \( {& k$ e& c5 G' n
• 
  ; a; r# R' e5 D' R
     printf("输入P确定算法：优先数算法\n");  
  / ^3 ^! ^: [3 X4 B7 L3 f
  
• 
  $ R9 P6 \( e4 F% U5 h1 F
  # ~& |8 |9 ?- k) l  c0 N   scanf("%c",&algo); /*输入字符确定算法*/  
  
  / _( b, ]1 M! ]6 A
• 
  
  7 g+ \. H! e. o5 L* `   printf("输入进程数：\n");  
  
  ' R% X3 l3 [8 \" N0 j( A3 g
• 
  $ p: U3 N. R( h, A, T
     scanf("%d",&N); /*输入进程数*/  
  : ^4 r+ ^4 q. G$ ?% Q, q. f
  
• 
  
  / j9 t# H) @2 x- ]2 S* P/ o& K   if(algo=='P'||algo=='p')  
  
  
• 
  
  8 P9 Z6 X; R4 C' _2 H9 [   {  
  5 z! ?& _) ~9 t5 ?* V
  6 m5 X) S5 I  y  \% N2 C) Z2 V" v  Q
• 
  1 j( \8 {6 b8 w& I3 u, Z, F
        create(algo); /*优先数法*/  
  6 \1 i. _2 i! b( a: {; B/ q$ ]
  
• 
    _' d" h* ~2 h% D6 m$ N5 J
  5 h1 w8 @3 G0 F! v; ]+ I$ e      priority(algo);  
  $ _% a4 w/ }5 d# Q' J+ l0 r& P
  : N: z7 W8 ^8 g, f0 r4 f
• 
  . B+ [" S5 W: a4 f8 R
     }
  
  
• 
    }" X" c$ i- P- I
  }
  2 X" I/ N0 ~/ L1 K' `0 b
  / H4 O) J8 a5 l
  ' d2 c$ c9 }6 F5 v4 s( J& o8 I# i

& ^# ]4 u" v% b1 u: q8 L& @输出结果：
1 W) u& a/ Z$ P9 l" f3 B+ q- }

, @( }% E# S# h原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

) }/ Q' c; Y9 Y6 m- {4 J+ K/ F