优先级调度算法

杨利霞

优先级调度算法
+ Y2 N( n1 L* A( P9 Z$ [8 ~( j9 p

算法介绍
8 A+ @- z2 E: C/ v9 u3 w优先调度算法的类型（用于作业调度）
5 i/ `3 y: O) t! v1 C& B1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2 B4 E! N+ r# c" `- b( g/ n. u2）抢占式优先权调度算法
0 C- ]" {' L# K. r. d只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
* F- G' ]& s  E  F# }2 q1）静态优先权
4 I4 S1 C, l8 A1 `/ v静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
  y( s2 y  D+ S1 Q0 U

2）动态优先权
. @1 [( W. t; Z+ R/ \0 A4 v

算法实现

抢占式动态优先权：

% z% b% t; ]5 v3 j$ j! f. E, C( o$ xPS：本人认为非抢占式静态优先权没有实际价值。

• 
  % Z0 D$ B; {. Q1 ^% h+ a9 Z
  #include <stdio.h>
    c  F% _% T5 r* z
  " L1 ^+ M  ?6 j2 D- f9 h: {
• 
  
  4 ?; l9 ], ^5 N) T7 I5 R#include <stdlib.h>  
  
  
• 
  & Y' g5 H# _2 o0 k6 q+ e% B& S
  3 D3 o: c& F# i) A: T& ^#include <string.h>  
  
  ! }8 S) A3 Q; }, |
• 
  
  typedef struct node  
  $ t! g! u& h1 B: j& P& _1 F
  
• 
  8 H9 H9 o$ C# @/ q) j
  $ w9 Z; X3 a$ F- m! t{  
  - J4 Z& [' b5 G# `# z. y7 x
  
• 
  
     char name[10];  /*进程标识符*/  
  ( o  o, p3 F$ G8 Z6 x: p
  
• 
  $ b! ^. Y5 c7 V6 c
    t0 Y4 F! k" W0 `9 [& u   int prio;   /*进程优先数*/  
  1 R" K8 ^: V6 \5 ~6 @4 [& v, V
  6 d0 `2 E2 R6 @0 Q
• 
  
  - J! [5 @+ j9 F/ Y4 W) O* c! m( q   int round;  /*进程时间轮转时间片*/  
  0 d, ^; {# D6 N( b
  
• 
  7 M2 u, D( W+ L  U4 L+ A2 B% ]
  " n6 ?5 O; J/ A   int cputime; /*进程占用CPU时间*/  
  
  + T, R, N2 w0 W. j- `/ v
• 
  
     int needtime; /*进程到完成还要的时间*/  
  
  
• 
    w3 k. I) ?" f& [% L
  9 Y" \  ^" t/ j1 r$ O4 z   int count;  /*计数器*/  
  7 D" `; e! s5 I& t& g  v8 g
    r: t( r: r% [) p
• 
  6 X' T% K/ y) Z8 M+ V
     char state; /*进程的状态*/  
  
  % Y  Z# J# e& u% L& H8 j! ]
• 
  1 s- O3 P* L5 E" S2 }
  ) Y' x& g" J5 R- {/ s# q   struct node *next; /*链指针*/  
  
  
• 
  
  : _6 N- c) `& I# w) J}PCB;  
  
  ! v3 N$ C( \! s3 Z: i
• 
  
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  , u1 E$ B/ N5 I$ z
  4 r; ?3 x. k! w( C) z7 C# I
• 
  
  int N; /*进程数*/  
    x8 p) H! t1 }, O
  9 \7 Z( e* F% ?$ y9 v
• 
    U0 D6 d0 t) _* b9 h
  /*将就绪队列中的第一个进程投入运行*/  
  6 e# ]( }+ {( D4 B! X' f
  ! b2 h3 H" k  ]4 j1 C3 O0 [& O0 a# Y
• 
  + Z# i+ z  o( ?  f; P
  $ o5 _; K3 }, \firstin()  
  
  . j# h7 K: y' f' o' q3 Q
• 
  ) E! w9 C6 ?; X( z+ p. I/ J, ~' n
  {  
  
  
• 
  ( u; G1 y" i2 K+ {6 \1 W4 x& Y
  5 I& d: b  B0 l* O4 T# Q% E: R0 R   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  
• 
  . v' k! Z) ?' d* x$ b
  , T8 Z; {* J9 e7 b; S/ |/ \5 D   run->state='R';   /*进程状态变为运行态*/  
  & Q/ Q8 ]6 L* z+ y: L8 q
  " r9 O6 s) ]1 K: d: r' }# C
• 
  
  ( y( M  s. O6 }* A   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  ( x, s' @5 f: @4 ~7 W
  
• 
    E. ]7 u4 I' @3 b+ Z
  }  
  
  
• 
  3 d7 U% X; j! ]  B0 T
  0 J3 k) x% N1 b' O% p/*标题输出函数*/  
  
  ) A6 ~. x7 n4 Q0 O4 v. c
• 
  
  void prt1(char a)  
  
  
• 
  
  5 u2 G; q1 q& c: l* g" f( r{  
  ) {: c, G% ?' L+ t! L6 M% V; c. h
  
• 
  3 x& q7 D' w9 k, u3 S+ k
     if(toupper(a)=='P') /*优先数法*/  
  9 f3 z5 {4 Q' a/ x, d
  
• 
  - a7 ^: _/ P. }$ w4 }
  ( Y5 |, y/ U/ f      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  ' G+ k( ^) s) L$ d1 E7 W
  
• 
  * ?! E* S" x$ I2 W) z8 H
  ( t: n0 K* x6 W  y( }) F- D   else  
  ) L# p/ ~, b8 Q% z  M! I/ E+ K4 H/ m& ]
  : ^8 c8 l% a3 J( {
• 
  
  " R* R# u4 s/ c+ j  k6 W( b" e: m      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  7 L# [- U, F, Q' k8 T% I* B' t
  
• 
  ( F" j1 ?  ^' l
  * A5 `5 D3 [0 K/ T. K}  
  + p+ j& Y' w2 E' n1 X
  
• 
  . ~0 K* p* o/ R9 P
  % L4 G- \& ^( g3 j4 R/*进程PCB输出*/  
    g+ K7 `7 ?1 E  s( |6 K  A
  $ T1 X, C4 ?* Q2 |
• 
  
  void prt2(char a,PCB *q)  
  
  
• 
  
  {  
  
  
• 
  
  . ^* e7 S$ J0 l: Z. V   if(toupper(a)=='P')  /*优先数法的输出*/  
  ; u0 V" p. a9 u" Y9 a6 m" m. `3 U
  
• 
  2 _4 H1 {) ^. @' U
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  9 p* C2 c, |3 O2 E7 E
  2 [; ~( p! Z/ U' b
• 
  % z0 y& ~  I' }$ C
  ! J3 V" [. k: x" b& |       q->cputime,q->needtime,q->prio,q->state);  
  
  ' v: y$ d' Z( m2 ]2 X) ]' C
• 
  
  6 f! ~& {8 o2 t$ p  a2 p   else/*轮转法的输出*/  
  3 _; l' }: z6 X
  
• 
  
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  / S1 k$ c$ ]; ]6 p7 S+ X" ^
• 
  + [" e1 |6 P& E6 M# x4 h6 L8 h) h
         q->cputime,q->needtime,q->count,q->round,q->state);  
  $ r6 t7 E* x* j0 J
  9 m7 C; G( E$ ?* a3 G
• 
  , B; I( A8 o$ N. y  E
  }  
  0 X* g3 l9 s5 J
  4 S+ u+ N0 `2 _
• 
  
  7 e' {/ N1 |& S' G/*输出函数*/  
  " c2 U( x. g4 _5 M
  
• 
  
  void prt(char algo)  
  ) b: D( q8 F8 Z) a. ]( ]
  : G/ V/ j" _. O$ H/ U
• 
  1 `( b! A8 F6 @( o3 r
  {  
  
  . t; l( k% A% [( y, m2 c( r- B& j
• 
    O) H$ w) |( q& l3 ?- P/ i
     PCB *p;  
  
  
• 
  : v2 K7 @! Q8 B) f$ p
     prt1(algo);  /*输出标题*/  
  ! h0 J5 e: q. A$ d) G: A
  ; Z- B* _/ |+ d
• 
    t! g- H  _: h# ?$ j( E" h
     if(run!=NULL) /*如果运行指针不空*/  
  3 d7 ?3 h- |$ E( p2 \$ x
  8 Q/ N- H' e2 v. C4 W
• 
  5 x& b: `6 E! z; p
  ! N% w( q& s3 Y( ~7 k      prt2(algo,run); /*输出当前正在运行的PCB*/  
  2 ^: J7 A' R* E5 b/ s
  % O8 N/ K9 ^/ F: Q3 O) G- b
• 
  
  0 A5 l( w6 j$ ~2 ~; z   p=ready;  /*输出就绪队列PCB*/  
  
  
• 
  
     while(p!=NULL)  
  
  1 T5 E' m4 X8 \8 e- i( t5 x+ p6 t4 K
• 
  
     {  
  
  
• 
  
        prt2(algo,p);  
  5 k$ I( c' S' [
  
• 
  
        p=p->next;  
  ) c' x  H# [+ y, p5 H- K
  
• 
  
     }  
  / p1 u" w) m7 ^/ u0 e- ^
  1 E4 x% O3 S  s& T
• 
  , O6 p8 x. U" O  M, E
  ( D& T6 B9 m8 L5 a+ ~7 s   p=finish;  /*输出完成队列的PCB*/  
  ; X+ O- m$ s" G: U
  ! H9 j3 J1 e7 y" S1 o7 v% w
• 
  
  ! C8 a$ n& |  ^5 s3 D   while(p!=NULL)  
  
  
• 
  1 H& ~7 G* {; w! u- H% P
    C. R9 z) s5 ?% Y! R6 p0 @   {  
  
  ) s) d, ]; e; O, h$ |
• 
  $ i5 Q7 g* C/ w6 o
        prt2(algo,p);  
  
  
• 
  + M! E* j, E- P4 y6 v
        p=p->next;  
  
  
• 
  
  ; J3 |" v  ~3 N& `- F$ P" D   }  
  + k1 y# b) D7 g! B
  
• 
  ! o' V, k3 U1 b4 e) P* k
     getchar();  /*压任意键继续*/  
  
  8 [: R# C. e" e! V! Z8 G- g
• 
  
  : ?6 v' D: B( T& S9 X}  
  
  
• 
  
  + Q! S- y/ P  G1 M/*优先数的插入算法*/  
  ; O+ y* Y" d! v# g# E2 `
  
• 
  
  insert1(PCB *q)  
  . I$ f% k* F; s. _7 M) {
  " _0 [1 |5 y! d) Z8 t) t
• 
  
  . x4 T: T8 ^! I2 m; h{  
  1 P( z! t2 y8 x) }4 K6 J0 t
  
• 
  3 T5 ~: n8 O+ v, O
  7 F0 L+ }0 t1 d8 U   PCB *p1,*s,*r;  
  
  
• 
  
     int b;  
  
  
• 
  
     s=q;  /*待插入的PCB指针*/  
  
  
• 
  ; e; n. z1 Q1 S1 D
     p1=ready; /*就绪队列头指针*/  
  1 Z: |( Z4 b. }& C% R+ [
  % e* _0 U. P/ ?
• 
  0 R3 @4 S% r0 x
  + R7 K( a; L1 I7 n4 j2 G' B) ?7 D   r=p1; /*r做p1的前驱指针*/  
  
  
• 
  
  " f& a. Q; ?3 A' U  E  C   b=1;  
  
  + I  ^& q$ B3 x2 J( t: L: F, q
• 
  3 Z5 i  }; J  u
  - C- R- |" A& _! F& A  Y6 D" F; g   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  , Z, H, r; K' B$ _2 t4 q* D" `2 T4 U
  
• 
  ( S7 `0 h# U. Y% y0 Y* o
  8 [6 \" @" x. }/ v5 P7 o      if(p1->prio>=s->prio)  
  
  
• 
  / B3 G* G) E) K& v- t
  5 b' M( R" Z2 T      {  
  : P! u7 p) W) @: T
  
• 
  
  / r( |1 j# |$ _$ m  o8 J, M& }     r=p1;  
  
  6 g- M3 r  b" `9 X: _0 \; R
• 
  ) L" E6 p, ]" k6 V
    a; F: o( q6 f9 S) v/ Y. P) j     p1=p1->next;  
  
  
• 
  
        }  
  
  
• 
  ! P& q7 v% T; n# g2 ?4 ^
  ; }1 V- q4 G0 `+ I. J' R7 ^      else  
  
  , S5 ]0 c' S, ^2 V+ p
• 
    L! L5 r; {, w$ j( Z
  6 M" y" i. b- f" U1 q6 n     b=0;  
  # b0 |7 A% x# p3 V3 e: g% f
  
• 
  
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  4 D/ ?2 j' i! ?, Z: i. z
  ) a: A, C4 v; ~( l! V
• 
  
  - H. s6 R+ m9 ^# A& {   {  
  0 l3 }2 a# y0 g2 Q2 U/ y3 F) f
  
• 
  8 d; t$ L3 s" X
        r->next=s;  
  8 h! a" ^2 _; Q: t
  - t" D  E4 f) l& R5 x
• 
  ) k9 I9 ~9 _" r% y" p
  0 B! e$ [: q9 `2 c      s->next=p1;  
  
  
• 
  
  , B0 Y, x; r; g: ~   }  
  
  1 L/ o' U0 K' R: N
• 
  ' {1 D( w0 C8 k3 p4 M) d
     else  
  
  ) m/ ]* V- h0 X- A' }' L  [* ]
• 
  0 H% }/ n. R! I  W4 V2 Y
     {  
  
  
• 
  
        s->next=p1;  /*否则插入在就绪队列的头*/  
  
  / k# o. _/ [, v0 a2 m
• 
  
  0 K7 |2 E8 X1 G9 b2 ^5 a      ready=s;  
  
  * P8 z' b) y( R' n; h
• 
  % }# J8 _; y7 l4 G+ t
  # f4 [8 E& o4 |! o   }  
  
  
• 
  4 e! _! D+ D5 D1 q+ A- x/ e3 L
  , D, u, v/ C* Y( B0 `' e}  
  
  
• 
  $ q( @3 X& q; I' s& {
  . T! I& d$ S- |8 U- G- _% B/*优先数创建初始PCB信息*/  
  
  9 F& ~, |1 ?0 u5 [
• 
  
  void create(char alg)  
  
  $ c5 A7 q) j+ n1 Z2 G7 {
• 
  6 O5 [4 S2 f  F9 [0 j
  . F) ^: h5 Z, ?- O9 g{  
  
  ( J5 j% A) J2 z3 D" s% ?5 w- w
• 
  ' A( y! O) O& E1 M/ B4 D% F
  ! a, K3 y6 t  D4 L$ {% z% k   PCB *p;  
  
  
• 
    Y  a& ]  W' M+ J3 m5 V
  $ L) l+ v6 q. C; ]* E( T. u9 c   int i,time;  
  
  
• 
  
     char na[10];  
  
  7 Z- V/ p; T6 q/ s8 s2 @( p4 F  T0 Q; q
• 
  0 d: z& x' J% D0 p, X
     ready=NULL; /*就绪队列头指针*/  
  
  
• 
  
     finish=NULL;  /*完成队列头指针*/  
  : ?' n/ t* i$ @! V
  
• 
  
  6 n# ]: x/ @: T8 c: g& N   run=NULL; /*运行队列指针*/  
  : b) i- B0 y, O' v+ d! X$ [2 W
  & f3 n4 k/ O" K. Y
• 
  9 w; e+ c4 s) h7 u. r- T( Q
  ! t2 R! x. A$ a: R0 a8 R: w; x   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  ' O! v3 @, W: h2 x( g
• 
  
     for(i=1;i<=N;i++)  
  * d' R: K" x/ B1 J3 E7 _
  
• 
  
  , m6 `# X8 Z7 s+ f$ z& Y   {  
  / U" b: o( ]& B5 a3 I: W) m
  % V. l4 h) ~7 h  B2 h
• 
  3 x! X! ?) c/ j% e
  ; r8 H( D/ H: _5 ]% e      p=(PCB *)malloc(sizeof(PCB));  
    B! q1 ?0 I+ M" ^5 R& z# @: P
  ( _$ b2 ]& p6 g' S' B
• 
  
  & h, ]$ g$ _  @7 P      scanf("%s",na);  
  
  
• 
  
  . P$ i5 ]: t. M! P. k8 |+ a/ Q  L( T      scanf("%d",&time);  
  ! X" j. ]0 o. L# l
  
• 
  $ j! B; R/ D6 M- ]
  1 @: K+ N7 {, f. z' `2 g: {9 t      strcpy(p->name,na);  
  # b8 Z/ Q% N; p  u9 T2 b
  0 {' G% L' g" B1 b; e
• 
  & P4 b6 L7 _: R
  , I9 d; O: `3 @# \      p->cputime=0;  
  " F8 u. e& z: h7 Z- z
  ' r# `  \+ V5 a9 |7 W
• 
  
        p->needtime=time;  
  , r0 x2 s+ _& m4 |2 s( k9 z% x
  
• 
  
  5 C9 Q5 K" O! B; p' g& q  q      p->state='w';  
  * ?( @* a- T( F
  
• 
  
  / W3 Q6 U* y9 Y' Z. v      p->prio=50-time;  
  
  $ i0 X( U2 \* Z+ d  A8 Q
• 
  
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  
• 
  
       insert1(p);  
  
    k! e9 J* ]9 ?. o
• 
  3 o) B7 \1 ]& S+ |) y& P( l
        else  
  
  
• 
  
  ; V# l: H' u- d7 a! q      {  
  # Y! f5 B7 E8 |5 ?
  3 u5 \: }) q% O9 g2 {
• 
  . N( J/ T& T7 M
       p->next=ready; /*创建就绪队列的第一个PCB*/  
  1 N8 P- r( w' a2 S; ~
  
• 
  " `/ y5 U9 ~$ O. {; |4 q9 S
  2 O- E( G! a9 m+ b- `" e' e' T     ready=p;  
  * z1 f8 d( M/ r- {# f& @
  
• 
  
  # T/ K3 [" I. {, O      }  
  ! H4 \6 N. s0 h, {4 s# E& f# |
  
• 
  7 W) G; O& }8 @1 X
     }  
  
  
• 
  
     printf("          优先数算法输出信息:\n");  
  
  
• 
  
  0 d! B. [, t8 ]   printf("************************************************\n");  
  * Q# F# w" D$ D% o# y" X3 @
  
• 
  2 [# d" o% L6 X# ]* }; W, a
     prt(alg);  /*输出进程PCB信息*/  
  5 f2 E3 v- B8 K1 c8 G. H+ Z
  
• 
  
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  4 M! F2 T9 ^: h  k8 ?
  4 i. p. V2 M) q+ ?. v. B& x
• 
  % y& r3 f9 e& s7 t
     ready=ready->next;  
  
  
• 
  
  7 ?% S6 u" F9 v, X7 O" a8 k$ i& K   run->state='R';  
  ; x- k1 J0 V2 R% u6 x1 B1 b0 C
  
• 
    F6 Y& K8 {6 ?4 U
  ( R  V9 Z: R1 I. X  x% n# n}  
  
  
• 
  
  / q& H3 w( R* ^, [' ~% n! o( W/*优先数调度算法*/  
  
  
• 
  
  / G+ ~# P- m8 t! x+ Z' ~priority(char alg)  
  
  6 K3 ^4 _0 Z" m2 O2 D1 s
• 
  
  {  
  
  6 V5 E9 W3 g- N  W
• 
  8 h( y0 b. Y0 S5 ?% t) U. G. I' K
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  , u9 i; B) O  R0 l- ~
• 
  7 n% H$ }& v& u5 c8 F  D; t( T
  * P+ K2 @0 m4 h8 a: f! L   {  
  
  ; v# w  X1 r' F$ y& K& a
• 
  4 W/ |) N# Y# A9 C+ u2 g" D' n! l, b
        run->cputime=run->cputime+1;  
  
  ) K# H3 ^0 L  w5 O  v& u5 {- V
• 
  ! d7 i* t, v* q/ I& ]% M& [8 y& }
  & F: d" t& X2 w) ]( `      run->needtime=run->needtime-1;  
  
  
• 
  
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  " s6 A! s: u: k8 ~7 |" M* }- U
  1 f% b9 ]$ x9 b% V
• 
  
  - s' |1 V& R1 R4 N& ~8 K' {      PCB *p;
  - c+ _: V* j* `+ U, t
  9 C! t1 S" q1 a( Q! A: g6 Q+ V/ y
• 
  
  0 a+ G( N6 D) }      p=ready;
  ( S" f* C* p  t. C* l/ ~; B
  # h" d( f' e# y) M& k
• 
  0 N. F3 F# w4 b! g* h' n0 O* c) ?
  6 h1 q  N/ G4 Z& L* S      while(p!=NULL)  
  
  ! J' `! P0 J3 h/ S5 r. f
• 
  
    @! N9 H: F7 ]" U# R" O% ]      {  
  
  
• 
  
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  * ^/ }$ f1 c  V5 l+ I* u
  * w8 c. N( z3 w6 Z0 S+ O1 n' q3 e
• 
  
            p=p->next;  
  - g6 p0 n, K( B- G
  
• 
  ' s$ b. _" B& S- [2 N6 g3 ]
        }  
  / `5 L0 i; j; U( W" X/ j+ q7 d
  8 o/ w% \# Z: M. S, {
• 
  
  1 c  B" \: Z$ Z, e3 l7 W. D0 n$ J# Y      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  
• 
  
  * D# H. y- L) b2 k; u! O5 k      {  
  
  - q& R8 Z# ~0 I5 z
• 
  , [/ D& T0 s% o! R# Q
           run->next=finish;  
  
  
• 
  - r( d" e% r6 @# K2 S" S5 N% W
           finish=run;  
  
    {* c5 K( m: ]2 _% k4 g8 r2 u
• 
  1 R9 S$ c  e9 |: u" b( j
  ) Q4 z9 L, a/ b. \, H5 R2 D         run->state='F';  /*置状态为完成态*/  
  
  
• 
  
  3 n+ Q& K* [; _1 h, B: m         run=NULL;  /*运行队列头指针为空*/  
  & I( l* r9 i+ ]/ }9 k
  
• 
  
  * r; d! {' H; Z! b( P0 k         if(ready!=NULL) /*如就绪队列不空*/
  + e  u8 q$ @2 u$ v
  
• 
  
           {  
  $ M- x3 U* ?5 p# W* E
  
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  
• 
  " V1 f% O2 p% @$ w8 J! e; Z
  5 K/ Y6 L% Q2 R$ v5 J  R, M4 j7 L         }
  9 S6 J- h, f0 ?6 K4 u2 d) h
  1 l7 S: g. g6 C: M
• 
  
  * H. ^4 {+ R: n- {* a) E      }  
  ) j2 p4 F% l4 I; |6 w
    ~4 t. s8 ~. w/ m  V& S9 H
• 
  # l3 _9 e2 O) @6 J
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  
  : X+ j- J; Y( N& t7 f# y     if((ready!=NULL)&&(run->prio<ready->prio))  
  
  
• 
  9 ?' G: x& P9 y6 `
       {  
  ! ]* A8 ]% R! k% c" p
  ; B  b2 W( O, X, J2 J5 K7 K
• 
  
          run->state='W';  
  9 u( w9 y9 v, D$ l9 B8 s
  
• 
  # W/ ^. X2 l# d6 D: l) {
  + {  v1 J! d3 s' ]7 C        insert1(run);  
  7 w) x2 E* M# E
  % G, d  s7 j# ~% D! ^/ g: I2 s
• 
  - ^0 h3 R1 p5 @1 g6 f4 u
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  . h$ y( ?, [0 s3 k/ f( z
  - ]$ H' {  L3 ~3 D# X# J4 ]. P, E     }  
  - ?. G5 Z0 u" t0 r* c( x
  3 o, B6 v3 d4 c4 G* I
• 
  
  8 p& x% S* X9 Z# H! J" P% f9 k+ E( w      prt(alg); /*输出进程PCB信息*/  
  
  
• 
  
  1 j* Z  `. R. N, O9 k   }  
  6 C( N% X& s3 Z* W
    F5 d2 I. @8 h0 |+ Y; Y8 c
• 
  
  }  
  
  " t/ m% M/ V  E
• 
  
  2 D7 d1 k/ [4 z' A- d/*主函数*/  
  / U: Z8 J7 ]% w1 X6 ^+ G/ O+ ]! U
  
• 
  4 n+ P( Y: N# Q1 N3 ]- n
  main()  
  & T+ v2 p  j! G; b
  
• 
  
  {  
  ! G* @& A6 w! I4 o  t* x3 O, @
  
• 
  , J6 C% R3 D1 P
  0 R' g6 i4 N! ?6 \8 j3 Y2 |- p8 r   char algo;  /*算法标记*/  
  " i, ]  [( p9 f$ d0 k0 i$ o% X
  
• 
  8 c% z' Q7 M' x, a8 B4 n5 p
  0 z1 ~. y; V- i8 A7 v/ J# [   printf("输入P确定算法：优先数算法\n");  
  ( b0 C/ D+ ^" P6 d$ Q( _; F4 A; Q3 T
  
• 
  $ v9 [# a1 p/ p4 @: c. y& m  a4 E
  ; t/ X0 ~" Y0 T* K   scanf("%c",&algo); /*输入字符确定算法*/  
  
  
• 
  
  1 _% s  n+ P( u7 ]: j  n9 @' x' h4 |   printf("输入进程数：\n");  
  
  + H$ y! i( ~+ _% q! b9 u/ L
• 
  
  - g9 l0 _& {, R" L/ i% u- f; m   scanf("%d",&N); /*输入进程数*/  
  
  ) D7 v7 \% W- }: n
• 
  
  0 Y1 T/ U5 E' w   if(algo=='P'||algo=='p')  
  
  . r' @. z! c3 J
• 
  
     {  
  9 j  Q  J% X7 u) L8 P( q/ ^) |
  
• 
  
        create(algo); /*优先数法*/  
  ' i4 m; v4 y' r) o
  
• 
  + d" H" _, J3 f, S& l, k6 h
  1 R; U6 G$ E: H# e- T9 {- \) g      priority(algo);  
  ! N: s! ~) m2 |
  
• 
  
     }
  
  0 p# R% z% |" h, q- u5 d% u/ ~) j1 V
• 
  
  }
  
  
  

输出结果：

2 P* ]# h  K" R  m8 w4 R  s原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

1 l+ F7 l0 D8 K# o+ G