优先级调度算法

杨利霞

优先级调度算法
; d* M2 |5 ^! V  }$ M8 z$ D

算法介绍
优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权
3 z, R) j/ J3 Z0 R) t: C

算法实现

抢占式动态优先权：

; o4 ~- @" f, u0 I$ v) APS：本人认为非抢占式静态优先权没有实际价值。

• 
    m* \/ o& o0 I. b9 [8 @; m
  4 V8 A, R  q' u7 ~; j# @7 \#include <stdio.h>
  ' J7 B' C8 A. a/ K  `
  
• 
  
  #include <stdlib.h>  
  
  
• 
  
  #include <string.h>  
  0 @/ ]# N, L1 X2 {; w( ?1 Y) {
  
• 
  0 H3 g# I! A3 h' c$ x3 ?
  typedef struct node  
  $ w% h' d7 H4 J" ]+ _4 l3 r) o( P
  4 J3 P$ Q# Q# |" H9 [8 B5 H2 i
• 
    F" H8 m/ s; ?- u1 P: j% C5 j
  {  
  % \: Z6 L# d; X! [3 y3 i
  
• 
  
  % P$ B; z  q8 j- J( y7 g- U& p   char name[10];  /*进程标识符*/  
  
  
• 
  ; j- k6 j: L. M9 r
  & \$ j$ o% U4 K2 z3 W* x/ ]- G$ S& y6 }  a   int prio;   /*进程优先数*/  
  
  
• 
  
     int round;  /*进程时间轮转时间片*/  
  $ Q5 Q( s2 n3 j! {$ w) z
  
• 
  $ F% O# B6 k! Y1 `3 O! k* p
     int cputime; /*进程占用CPU时间*/  
  ) ?+ d6 @  B. ~% j: X% d2 A/ M* \
  
• 
  
  ) r- ~; K6 O1 U3 S% K6 S4 [% Z   int needtime; /*进程到完成还要的时间*/  
  
  . D5 L8 g8 S$ O5 H' s7 Z
• 
  * I7 g$ E: a% T7 @9 }
  + J, C& n! ~. d7 s0 l. |2 H8 j! |   int count;  /*计数器*/  
  0 J9 G9 G) ^6 C- `
  5 I) B+ V( v$ Q
• 
  
  8 \7 d  x  k% F" ?7 [& a! W   char state; /*进程的状态*/  
  
  
• 
  
     struct node *next; /*链指针*/  
  / I0 A+ O' L( r; y( G
  
• 
  / b% q" t! P; Y1 P! i  `! u
  9 s0 a4 y; c9 m7 P0 U6 U}PCB;  
  
  
• 
  
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  
• 
  
  : U3 M; t2 X& Z; Q" n4 Jint N; /*进程数*/  
  7 k& Q+ Q/ N" p9 O$ p/ |0 [
  
• 
  
  # k9 O" {5 C2 a/*将就绪队列中的第一个进程投入运行*/  
  
  
• 
  2 O- J; K+ A6 n9 d1 i0 g
  firstin()  
  $ s# |5 C3 v3 ^. F# J- \" C
  : @: @- `3 H' Z5 U
• 
  
  0 E3 ~! h# l1 X* ?& {/ U8 O2 B{  
  
  8 N5 H% p: R0 ?8 {/ m
• 
  * m8 C% x: o) \2 e% F
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  2 d9 n7 X8 E) _
    p7 k7 v! A  }, @  y2 n* X) Z
• 
  
  , n5 T0 W  m* j2 m/ V2 C   run->state='R';   /*进程状态变为运行态*/  
  , I/ A% h2 z8 q
  ( s. n- f1 t" P7 r* _, t
• 
  # q: x/ D1 |; X( x! Z
  $ X3 W# E% U  D/ C* L7 |: ^   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  3 N0 h- u, c1 s" G2 B
  
• 
  
  - m# K( `* F6 Q}  
  
  
• 
  
  /*标题输出函数*/  
  
  
• 
  
  4 g! ^" ]) M+ ovoid prt1(char a)  
  
  
• 
  , O' A* J0 D1 \* _) f" i+ D
  {  
  3 y' S, t1 n+ }, M3 E  N4 T$ I8 @
  6 x( N4 k0 o; a$ o7 X
• 
  5 W, L# \# a$ Y( e6 v
     if(toupper(a)=='P') /*优先数法*/  
  
  + n8 t* K* D% a% ?6 f4 E: E
• 
  
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  ) w$ s2 k2 Q/ {% C8 n3 m- Y
• 
  
  4 E3 @; E+ p1 s6 [% k/ \   else  
  
  
• 
  
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  ) ~  X+ m0 t/ r! w' y4 B. |
  ; Q8 L& Y8 o2 J2 m: }# C
• 
  
  }  
  
  $ D  G7 [4 M! Y5 l/ X. {% Z& z9 O
• 
  
  , V% S7 _$ t$ A! M4 v/*进程PCB输出*/  
  8 S- A8 h3 V6 {' Z0 c7 c! S, ?0 y
  $ R& [6 n+ |9 ~, T$ D
• 
  + ^' u6 u! h" z% ^7 m8 I* d, B+ Y- t
  void prt2(char a,PCB *q)  
  
  ' n8 z- G3 ^6 H* X9 g" |0 H
• 
  ! ]5 n$ `6 N( }. S4 L
  {  
  3 ~8 j& h- H! b. D0 Y
  
• 
  
     if(toupper(a)=='P')  /*优先数法的输出*/  
  ( g( h8 Z9 G6 J7 W( s. P% x
  % F! E4 U+ N( F! t4 ^
• 
  
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  / L, Z& [8 B) e, G+ I; T3 B
• 
  , U7 W8 e9 u' B1 Y2 m* m
         q->cputime,q->needtime,q->prio,q->state);  
  : Z9 W6 u7 r# d3 _1 d* K
  
• 
  
  2 H% t. X/ j* b3 _2 s4 o" ]+ t! [" v   else/*轮转法的输出*/  
  
  
• 
  
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  8 ^7 J8 g: |' f) {
         q->cputime,q->needtime,q->count,q->round,q->state);  
  
  
• 
  ( N; W$ O: I8 f  [
  }  
  3 x; Y/ F; y% @. Z% g; m* d; G
  ! Q& b8 P. C' f
• 
  ! J7 r: k$ z3 ]
  3 ?1 t; w+ z/ j$ C' B5 V6 L3 ~% k- |/*输出函数*/  
  
  
• 
  
    ]0 r+ a- g0 |9 j& ?1 rvoid prt(char algo)  
  
  
• 
  * C0 i+ |& F4 m2 w5 B
  {  
  : B3 _6 a; R. [3 `
  
• 
  , i. g( V6 e; e! U1 U) v
  ' `- ?0 j) ~0 \: Y( N   PCB *p;  
  
  
• 
  
     prt1(algo);  /*输出标题*/  
  
  , H2 E4 [+ b2 L, k1 m
• 
  
  4 ?9 g7 u. \( o4 K$ J, o+ s   if(run!=NULL) /*如果运行指针不空*/  
  ! A$ @% c; ~1 ]* z" {
  
• 
  
  : \' U2 Q' f7 ~* y$ @% m6 ]4 V      prt2(algo,run); /*输出当前正在运行的PCB*/  
  6 o- D. f9 L$ l7 t" h- i( [6 z! I
  
• 
  
  % [! [3 Z6 @9 W+ p4 H! Y6 [   p=ready;  /*输出就绪队列PCB*/  
  
  8 T0 q3 d1 l. d
• 
  
     while(p!=NULL)  
  
  
• 
  : H) o0 V2 [# ?$ V
     {  
  , f# T( a* f" s( @# v
  
• 
  & N9 `/ F5 k2 t2 j7 C" R
  ; Z1 N5 x. S  i      prt2(algo,p);  
  
  0 G' I( H* w- a3 z. H- p
• 
  ! F! l1 Y/ k" D# x. e# ?3 w2 A; N0 ]
        p=p->next;  
  - \9 y0 y# h$ h4 P7 Q- x3 g
  + k) R/ K5 G& A% I3 {' T0 R
• 
  
     }  
  6 B9 L' w: j4 N5 d0 n: }4 H- {5 [* K
  & j5 v2 |; O9 {$ M% S3 ~( v. V, h  }
• 
  " i" Z" }# _( M9 G4 Y0 R
  * F5 @" B3 Z+ S: b0 y   p=finish;  /*输出完成队列的PCB*/  
  1 J! M, T$ J; }" |
  7 E+ `# X. I- e% f; g
• 
  4 c8 S0 h! m" [/ ]7 e2 p4 d  Z4 t
  4 @( q; p) I+ T' {5 S   while(p!=NULL)  
  
  # R% e" L  b8 ]! a! f
• 
  + p$ z% D4 {# G) q. I! J2 y; j3 I
     {  
  
  # T6 Y( e0 C3 u( _& P
• 
  
  5 [4 j# {/ x" O+ u( e      prt2(algo,p);  
  
  " o* d' q( t0 J" z
• 
  
    u9 a5 h. r/ @) i$ y# j      p=p->next;  
  8 ?7 b* w9 \- U8 A' ]) m0 J
  3 n! Y1 I7 G5 `7 L6 j7 P
• 
  ! ^& E& s! r) h
     }  
  2 x! w# `" h4 z% e; C7 U
  
• 
  % V: O3 ~. {: y4 F8 F0 @% B
  - ~+ Z1 J( T: h& M" u$ Q   getchar();  /*压任意键继续*/  
  
  
• 
  ! O+ P5 L% h# ~
  , w8 _( x1 G8 h9 X+ W1 t}  
  
  * N% e) _/ n7 u# W& w3 L
• 
  
  ' M0 @: T1 r4 \6 `( ~/*优先数的插入算法*/  
  
  
• 
  8 E. u5 P. r6 e9 m" n( h- A8 u- P, f# t
  , k. l# y4 P  [9 V" {8 K* hinsert1(PCB *q)  
  
  . }: c; o+ g( K2 h" Q% \4 f
• 
  
  {  
  7 S" i% T/ j' ]0 B
  
• 
  6 `) a- T0 z. f
    {1 q; `, I0 }2 ~8 i. z   PCB *p1,*s,*r;  
  ) [5 n: m8 H9 Z3 w  t, C
  1 W5 e2 {* \( [) f/ a
• 
  
  ! s8 L- p- l! e3 [! ^3 g8 [4 I: [   int b;  
  
  
• 
  - T" ?; x9 p) R8 D$ y
  1 m' |$ d' F+ ?& l, f# U) ^) e   s=q;  /*待插入的PCB指针*/  
  $ O4 B! `; G) U! S( R/ f% e  h9 @
  8 n/ A1 ?/ t0 l! A. Q( ]+ O4 `, p
• 
  
  % n1 M+ V$ i2 G% B5 f! b   p1=ready; /*就绪队列头指针*/  
  
  9 L. h& b/ a% h+ s8 j7 T
• 
  5 A- ^# Q( r2 E- _" v  {0 ~' A
  - v* o& }' {, J( R   r=p1; /*r做p1的前驱指针*/  
  
  
• 
  ' n! Q  m/ g2 k
  6 z7 s% L+ |4 k4 I! F   b=1;  
  
  
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  * Y" i1 v0 i& m
  
• 
  . D4 V: l, F: L' M0 S% ]
        if(p1->prio>=s->prio)  
  " J6 Y  j2 v6 @" b# j* y2 I
  # X5 y) L4 N$ j8 q4 c
• 
  
    N  T" y7 z( I, u9 T      {  
  
  
• 
  
  1 c5 m3 e; O4 m8 V0 a6 N7 p     r=p1;  
  
  
• 
  ) c; G* @4 e- g+ k3 h
       p1=p1->next;  
  
  
• 
  
        }  
  4 @2 Q5 B% Z* i4 j
  ' N0 r5 A+ H3 R; \* ~( ]8 H
• 
  ( l: k/ }- `0 t, Q
  ) L8 f# n5 V* I$ {& F4 ^      else  
  
  
• 
  / q3 I& C: d, \& ?! ?; L' N
  , I, S' l, Z" D# N     b=0;  
  & ^: J4 P) L6 m3 m3 d! J
  3 U0 G& S; \! c: P1 Q
• 
  0 ]: i1 w5 i+ {
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  4 v; C+ [3 {! J6 m# j
  * X$ ]' x- s3 \) Y) ]# ~   {  
  
  5 ^5 R4 y! ~! J+ _
• 
  
        r->next=s;  
  
    f1 I& q$ b% ?0 m2 T" y, F
• 
  
        s->next=p1;  
  : P& F: u" F( s: t' M
  / l1 ~6 c4 j. y* e& O- v1 U2 [6 b
• 
  
     }  
  / t) o3 K* E; L' e) @8 `' k
  
• 
  
  0 g  I& G$ W- N: ]6 f* q( Q0 W   else  
  
  9 l% b+ v+ f, a6 d" M
• 
  
  0 \) k6 G0 _# d+ A& g1 c   {  
  
  ' \# ?4 u3 D$ t2 I
• 
  
        s->next=p1;  /*否则插入在就绪队列的头*/  
  ) |% N2 m# {  r7 D
  : R4 V1 m' \* H  ^) J- n. G
• 
  
  " [  ~( Z! p5 t9 j+ k/ w      ready=s;  
  
  ; p# r4 }4 W: F, B, g2 b
• 
  9 k' p1 a* b- x  m6 i" X& P
     }  
  5 A. W: R/ c0 K! C% U$ `$ W
  
• 
  % y+ l  L1 V9 E& H
  0 _3 V, _- F& j7 b' Q9 z' ^+ Z}  
  
  
• 
  
  /*优先数创建初始PCB信息*/  
  * c& h0 e) G+ D; f+ S! t, N) p: S
  " t8 C" F/ e+ \( _: E
• 
  ( b) ?5 s3 m' q4 z( I- {
  void create(char alg)  
  + q. f! i% h5 p8 w4 n  h
  , l3 ~: r& d8 ~" S
• 
  
  {  
  
  8 @5 s7 n; \7 k7 t% F6 w+ d
• 
  
  4 J$ `' X7 Z$ A   PCB *p;  
  
  
• 
  
  , N9 I5 @' N! X6 u+ o1 _1 B   int i,time;  
  
  
• 
    a; B6 Y6 O: K6 x1 M5 X. G$ s
  4 G' l  V4 Z) I5 G   char na[10];  
  
  
• 
  3 {" E! J7 P% }: w0 H3 u
     ready=NULL; /*就绪队列头指针*/  
  
  
• 
  / \( V& D, t+ ^1 b9 ]" I# q, j
     finish=NULL;  /*完成队列头指针*/  
    H$ j+ F6 w+ \3 `! }; S$ x# i
  
• 
  
  9 k# _! |5 ]. G   run=NULL; /*运行队列指针*/  
  4 {" u/ ^  `) y, X
  
• 
  + i  z% C( [' s( V" H9 s
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  + \' U2 q/ b4 r# L3 \: a, i
  
• 
  
  9 i" [5 k6 B6 w" D. y! A5 |   for(i=1;i<=N;i++)  
  ( _0 Z" o: I; g- X1 z! }
  ; j( N* }# D. U
• 
  
  & R# g* u* k4 x( Q* j% m   {  
  
  ' }" m$ @& ~. s3 k; a9 y1 q
• 
  5 |( Y6 |1 @% `, J7 o1 h" E
  # B/ |" U; R, s7 W. M      p=(PCB *)malloc(sizeof(PCB));  
  
    J1 g* d4 w" T- l
• 
  
        scanf("%s",na);  
  ( ?+ M; a3 o6 Y# T  u5 {
  0 R) o, f, I; A% `' ^1 S, m
• 
  : z8 |6 F# m; H
  7 [; q4 t1 X: F      scanf("%d",&time);  
  5 j1 Q( S5 e9 h4 x- c. J# b2 c  Q4 t
  + ]4 z- `' D" O( L: w, _. n
• 
  5 a; r  c8 [! \5 n" k6 H$ r* o5 s- e
  % m5 F( s* U+ g) C& _1 N9 ?      strcpy(p->name,na);  
  $ o6 C! {- j6 j- E: V( p
  : t6 B! L# T6 w- n. G& g
• 
  " n! B; d, {/ z5 j; d( p
        p->cputime=0;  
  0 F  T& q) S' H' d" l3 `% i, D. W
  7 q8 t. }9 r# N
• 
  
  7 n8 M' `: N$ H5 j& L      p->needtime=time;  
  
  9 b$ J# [9 s; [
• 
    A  A. A8 B' Y6 K5 {
  + f0 s% `3 k# {& z      p->state='w';  
  
  + v; X; V9 B2 s4 `; X( ]. v
• 
  5 q# x3 w8 h, o5 z8 O" a9 P
        p->prio=50-time;  
  $ {' ^1 E5 w! B: Q; Y
  ) Y- x0 r4 b# O
• 
  
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  
• 
  ; D# f2 u. l6 B
  9 G( q' ^9 N% h& Z     insert1(p);  
  
  - S: M* p0 i, Q5 U
• 
    J( b7 a. x$ Z5 v; P6 S; d
  ' P7 f* v/ H7 Y      else  
  
  
• 
  
  2 {/ O; C6 @0 ?3 Y      {  
  
  . q* H8 A9 D' ^4 L) }2 D, c4 F
• 
  1 y8 o- k9 y! g+ x5 T
  : Y9 C  U6 _9 S. U# o7 e7 B* h     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  3 z7 y4 t2 N% @' J8 |) m
• 
  ; I; S" `, F: s
  5 k+ _% H- R2 w8 l. _: [     ready=p;  
  ) j* `3 S# F* J, N% w# H
  ' I- x' z; {& h2 ]2 v
• 
  
        }  
  / {+ J& d& }, Y3 Y+ T
  
• 
  
  ! ~; T+ Y( g* d# ]7 z( c/ |9 v8 h   }  
  
  * F  E, z3 e. _4 ~1 ?
• 
  * B) P  G& R; f$ T! n
  6 ^% B. a) H5 [% J   printf("          优先数算法输出信息:\n");  
  
  
• 
    [. l1 p& Q) q: j" p4 b! C
  + R7 m5 x. U3 r" O' t! N   printf("************************************************\n");  
  9 b; ]: f+ r0 M, u
  
• 
  
  , \! ?( A: X9 U4 Z* E7 |% ~   prt(alg);  /*输出进程PCB信息*/  
  2 N) a- p/ _+ h
    P; R+ c5 T/ O" l# K
• 
  " _0 m; X2 \2 O4 Y* g. h
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  / [% w; i5 _4 w) l# g0 h: w) V
• 
  ! b1 \9 V7 }0 h) ?  Y4 K7 k
  ( t1 i& d/ ?( k7 h' g' p; n   ready=ready->next;  
  
  4 l8 b# t5 i! P8 }8 s
• 
  ' s4 u9 f. s! H) i0 |  h& _/ d
  1 A/ [) Z# h/ B, y3 a- M   run->state='R';  
  # T5 ^# _+ K" Z; ~3 x% Z6 Y6 L
  
• 
  
  9 i( z4 t  b' y" I" O# z5 e% ~/ F}  
  
  + g( k! x: p. n& S4 D+ c
• 
  
    i7 Z8 u! O) O! i9 l; I7 k, p/ S+ a8 n/*优先数调度算法*/  
  0 X6 B3 O, d& K/ k/ X6 v
  - T4 l' ?( Y6 {& U) l
• 
  
  1 s2 x9 z4 b: F" u7 N2 ^! {priority(char alg)  
  
  
• 
  
  {  
  
  4 w4 @$ ]. K/ d! ?2 E- x$ A
• 
  
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  * G3 D2 p5 k) R  P: H# M* q/ n
• 
  
  . O+ h$ K( R) {" N   {  
  
  
• 
  
  4 ~; T* }, b" X$ j& R      run->cputime=run->cputime+1;  
  
  ' ]* M2 L  n/ X8 W
• 
  / h7 I& O$ ?9 U& z
        run->needtime=run->needtime-1;  
  
  
• 
  
  ) K. S6 E; R! Z- k+ N      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  ) b* |) f" E- }1 I$ S: Y
  , o5 @/ Y( {, |
• 
  
  ( K4 N' L' G3 N$ g" T& T      PCB *p;
  ; W' Z% l* }5 y4 Y
  
• 
  
        p=ready;
  0 x4 b: K" M; B- ^' l* i
  6 D/ n' k* d( H+ N
• 
  / l. u- ^# y+ ^# {# _% N5 G
        while(p!=NULL)  
  , q9 [( C- j% ?0 D4 e4 F
  
• 
  
  6 Z. I7 D  V: ^7 M      {  
  
  
• 
  : M! j0 i8 E, w5 A
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  
• 
  . P: s6 }2 F& o0 S2 g' E) X8 h9 g
            p=p->next;  
  # ^' Y/ c/ O: @7 m! I
  5 S6 r! D" E* ]" a$ I, T$ y
• 
  
  & Q4 x, [% S8 w) p) x      }  
  
  / A3 I/ c3 U  b% Q- a) T) P
• 
  2 K5 n4 l9 g. a& p
  , X7 |, o+ D$ ?) O      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  ' s' D& C% L# f
  
• 
  " z" B9 A: I/ J9 N6 }6 X; o
  7 j" Y6 b1 I/ p% Z- o      {  
  1 _" I- p) s- B2 {1 N  I# B1 [- P" q
  / [( F; v1 z, a. S7 Q' X; h
• 
  ) X: d8 A  z" E1 F) b7 w
  3 U5 P+ ^: F) q         run->next=finish;  
  
  
• 
  
  % e4 m9 K/ H1 |         finish=run;  
  , r  F& l9 J  m! G/ c
  
• 
  9 k5 g5 {& Q! G- D/ W9 h/ i
  ' N4 T6 f* R( O! \0 A         run->state='F';  /*置状态为完成态*/  
  
  , S, B8 T/ ^  ]7 R
• 
  6 L7 P: y1 {  ]" Y$ p
  9 K8 i2 g- c3 \0 q" ?& m$ h         run=NULL;  /*运行队列头指针为空*/  
  
  0 K) P4 i, l4 I# y' V( L4 h8 g$ ]+ U
• 
  / T3 Z& e- C- C) \! T
  4 o1 r6 ]9 I8 d) E% z% g         if(ready!=NULL) /*如就绪队列不空*/
  ' E: j9 }' n& _
  + a) I/ m0 L- h. U+ o# @
• 
  
           {  
  
  2 k. c  q9 A* v: k$ t1 e( y1 u
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  2 M5 f9 D. R# E& U; `( N
  * c% U! S0 H6 S; V1 q2 `
• 
  
           }
  
  ) z7 C5 q& s1 T& ~
• 
  5 R6 t0 J$ E9 r( c& H
        }  
  
  
• 
  
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  
       if((ready!=NULL)&&(run->prio<ready->prio))  
  / T& X1 U. \- H$ k
  
• 
  / ?; e# i  z- |6 E
  : c; N" o- U, l0 a% a0 S0 z     {  
  $ l0 M' B! U/ d' G
  
• 
  4 e8 }& s& @6 M2 T4 q# \5 ]
          run->state='W';  
  
  
• 
  
  4 I+ K# i" @' j) M' o        insert1(run);  
  * ]9 g4 X0 K: n% z% t; h/ w$ J. R, R
  
• 
  ' k  g* B& _# B. q$ \
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  / g8 Y' G) p  D' x0 o; d
• 
  - k& G; o" f, p2 G  G  `
       }  
  * \, ^9 F- b: j, H0 o
  
• 
  
        prt(alg); /*输出进程PCB信息*/  
  
  $ Y) @1 s: d2 |8 Q! j
• 
  2 A9 B! M- d1 S7 [! f- p0 l
     }  
  
  0 o2 _# m1 H: A: @) i* K
• 
  / ^5 R2 |% _- w9 d/ t
  ' ^$ w/ z1 L7 Q2 _}  
  
  5 q* `5 i1 X# H- E7 [
• 
  7 z7 M% o7 ]  ^% R2 R  {9 {+ K
  $ u" A+ U- `  ^& @1 l9 D/*主函数*/  
  ( o3 \7 q# a# F& c  C3 L* g: w  L
  ; k- K8 d, ]! v& H
• 
  * |& c5 r  m: I
  main()  
  3 S4 |- b* \& v
  
• 
  
  {  
  
  9 a6 u. Y) |" }1 |( n0 Q
• 
  
  6 ?6 W/ i1 v- ^) F   char algo;  /*算法标记*/  
  & k& l+ I7 l* I4 L3 p  m1 k
  + L, F+ a" A: C) m; [+ O: {
• 
  $ u6 p5 o# S4 Y9 g% ^2 c0 d
  . H- p" ~2 D: |/ F# T% Y7 B1 K   printf("输入P确定算法：优先数算法\n");  
  6 ^. k  [, o6 E
  
• 
  9 M0 k/ p6 E/ h# e
  2 h. x! m2 _  |7 ]1 X5 T   scanf("%c",&algo); /*输入字符确定算法*/  
  , O6 L- p6 [5 @; S( H
  ; y/ m# _3 K& X( n2 X! [
• 
  
  5 |& K+ o! z0 E   printf("输入进程数：\n");  
  
  
• 
  
  8 Q" u) n1 I1 ?, q   scanf("%d",&N); /*输入进程数*/  
  
  
• 
  
     if(algo=='P'||algo=='p')  
  ; W) w4 d6 R6 u7 d* p8 J
  
• 
  
  ; W& C$ B* _0 Y, ^' p   {  
  
  8 T8 W& n- B5 e: L
• 
  
  ! y! H0 ?* c* E; `% Y& [% f      create(algo); /*优先数法*/  
  
  , ?9 U; S) a3 P+ z6 w
• 
  + U" |4 D; ^6 p  o- m% w
  5 r6 `: O4 V+ w      priority(algo);  
  
  
• 
  . O4 p: x* ~% i7 k
  ) _) z$ {! N2 V' O: V   }
  
  ' g( R; }9 N0 t) S& r$ v/ R
• 
  $ t; t* _& q' f4 K
  * c1 w+ Z+ R0 S}
  9 m" m3 N$ j( G
  * f" ?- _. p7 t6 ~8 ^0 V
  

! x' q, [. A1 y/ n输出结果：

; Z7 F, ^$ p% i) Y' Z! |& N$ U原文：https://blog.csdn.net/weixin_40962955/article/details/80072769