优先级调度算法

杨利霞

优先级调度算法
, n3 {1 t, J# c* n' m

算法介绍
) f- Z* q1 X/ S- P8 g优先调度算法的类型（用于作业调度）
( y& f: A8 S5 f0 k+ [5 E1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
9 F! m" G* o2 y" @2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
( c7 O! d  S3 h1）静态优先权
9 s+ n& K) E6 N2 @6 A静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
! j$ a3 F' ], Z! X; A

2）动态优先权
. ~$ A2 }  ?9 u

算法实现

抢占式动态优先权：

& }- l  f. Z+ KPS：本人认为非抢占式静态优先权没有实际价值。

• 
  4 a% `3 L0 e5 D7 Z. H0 m
  ( O# s# U( _& g. a# ~#include <stdio.h>
  
  
• 
  
  ; e6 P; \; u( C& r$ ^9 ~6 @6 j; t#include <stdlib.h>  
  4 X( {+ R2 |  h' N4 }
  0 M2 ]6 H* ]( N7 \! p) P- W, r
• 
  " N2 q- w4 A2 \9 |# H0 g& z
  * K# Z8 c6 M* _# |) w4 L#include <string.h>  
  , X% _  [6 d* g) l
  8 t6 p, }( _) M5 `$ {3 ]" ]) u
• 
  8 w8 `5 M3 ]( E& N% {
  + T. {: t$ I5 B% |- Rtypedef struct node  
  , W5 {# K& s+ F9 B! k, z
  6 ^, q+ A: T+ [
• 
  
  {  
  - E6 x+ d# X# U4 c8 ?) n; D
  
• 
  3 L, F; L$ C0 |) r
  * ~- H- F+ S" ^. S1 q   char name[10];  /*进程标识符*/  
  ( [' v- J% _1 ]  d6 }) F
  
• 
  5 z6 h7 b# s1 X5 d# M" z: H
  4 F6 @7 n: z$ j% i   int prio;   /*进程优先数*/  
  
  4 c' V  l4 b1 P
• 
  
     int round;  /*进程时间轮转时间片*/  
  
  
• 
  
  - s! R2 Z8 E$ {- M2 }* T4 E8 h   int cputime; /*进程占用CPU时间*/  
  
  2 T6 J& f; Q3 O4 k
• 
  3 A7 m6 `" O2 g7 v  N( y
     int needtime; /*进程到完成还要的时间*/  
  
  
• 
  % `5 K. s. U2 }% R5 h5 L3 y/ `
     int count;  /*计数器*/  
  . U: w7 B3 X, h' l
  
• 
  
     char state; /*进程的状态*/  
  6 L; g0 N  B4 ~. t# O
  
• 
  5 f& I! u# g& H# @3 t) Z$ \2 Q
     struct node *next; /*链指针*/  
  
  ( T' T1 d! f- }2 C' p! f
• 
  8 R1 c$ V" C6 Z; f
  , C: c: R5 H/ u; l; m}PCB;  
  ) K9 z1 _4 J' n
  
• 
  
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  ( _1 `- V4 l4 ?" D: A3 G3 w# D
  7 ~' ~' D3 n/ c' i  ]
• 
  7 v. ~/ S8 \1 V+ g- ~
  int N; /*进程数*/  
  ) a1 E% l" y$ S( K0 q. U* h
  ' b' y; L! l! N2 I  F& k
• 
  
  /*将就绪队列中的第一个进程投入运行*/  
  , X; }; Q. i$ L3 V  p& f% I  x  d" g
  " m) m" T3 @  T: b* n! \
• 
  1 D5 Y' p. ?* b1 [: [7 i. v
  firstin()  
  
    Y! O3 }, c5 E6 m$ ~/ S' l5 T/ p
• 
  & Z5 k! e& W: B% O5 |4 a5 W9 e. u3 X
  9 z2 S2 O9 t8 I# K{  
  8 ?$ a: _2 P. w3 s3 M6 T2 Y
  
• 
  3 c: F% J& |: E* J$ z% z( f" `
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  ( l+ s5 T- L. W/ _% m# _( K- X
  
• 
  
     run->state='R';   /*进程状态变为运行态*/  
  0 R' _6 a% u/ H$ `: P
  
• 
  4 X( o1 b4 q$ ]& L. S' U5 p* i
  , D% y* r* k* X   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  
• 
  
  " ?; {$ X$ A! e5 d% N' r}  
  . C4 ~$ A: c/ W+ [* I2 L; ^4 d7 n1 }
  & Q: F0 `" I0 W4 w9 x5 |- r
• 
  ' r: A0 R, Y3 s9 k  {0 R: Q
  /*标题输出函数*/  
  
  $ B) G: g2 q- L4 U  k7 G
• 
  
  7 b! o/ R' N) z7 tvoid prt1(char a)  
  
  
• 
  
  7 e6 p8 S: s0 S/ E6 N( w' V( f' S{  
  
  
• 
  8 Z3 F. }" I; {7 w: \
  0 d9 \( I9 [$ C5 w0 p9 ^' O: _5 y   if(toupper(a)=='P') /*优先数法*/  
  ; _7 L. _$ k; n$ g. G  W
  
• 
  
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  & p5 i! j- z  |& T7 Y
  
• 
  2 ?( O0 x' W7 d! R0 l
  2 l7 r$ M4 z# z, z/ a   else  
  ! X' n* l* Z3 h* X) Q2 c; H
  
• 
  3 Q4 w1 H: Q0 X$ {( I9 k( H6 T
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  
• 
  
  2 X& a4 T  T8 B( E. s. i; p}  
  # N1 G+ N: {/ Z8 j/ W& F
  
• 
  ' z: m9 x; E- m+ U
  /*进程PCB输出*/  
  
  $ B* Z0 n; ]5 ]" E. f& c7 z. A
• 
  1 q( y: z& |( A3 g0 o3 A
  / w! k% G# f; l: }7 ^2 a- wvoid prt2(char a,PCB *q)  
  & ?2 J  B, Y# c* [1 ?
  
• 
  9 J" B; Z9 ]3 f1 j6 z( r
  4 A5 [6 a" Y2 W# n$ k7 V{  
  ; g3 W" g) I  a) t7 T! v, `9 m& O7 e
  
• 
  0 }& U8 _& B& |7 S
     if(toupper(a)=='P')  /*优先数法的输出*/  
  0 U1 ~9 z1 K: m* c
  
• 
  ' p  J0 s" ^0 c" Q) V- o! p" h
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  ; f/ k2 w8 g8 t  [( j" V/ _7 f
  
• 
  
         q->cputime,q->needtime,q->prio,q->state);  
  
  
• 
  % G* b6 @4 j% _) t
  , g. d; z" c. V) i+ P   else/*轮转法的输出*/  
  
  
• 
  + Z$ d) v5 X2 p/ J
  ; |, A! q4 K4 p# ~% l! H      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  6 H) S4 l5 s; S7 U9 Z* ^
  ! t* J( p3 m/ l: O' P! |6 }
• 
  
         q->cputime,q->needtime,q->count,q->round,q->state);  
  
  
• 
  ' [$ C0 ^; J. o
  }  
  
  + B1 W/ K: E* D1 j! Z  B) r
• 
  
  /*输出函数*/  
  
  
• 
  
  " y* d7 Q# e" g- E" Rvoid prt(char algo)  
  ; h1 ~7 s+ P4 a& K
  
• 
  
  : z# c7 Y+ i! I' B2 f9 u4 i{  
  
  
• 
  : ^; _3 Q) \  H6 l/ o: B& e7 [- o
     PCB *p;  
  
  
• 
  ) s9 D0 i8 g  X# S& Z+ j
     prt1(algo);  /*输出标题*/  
  8 G: T8 C& e. j& K
  # I& s7 R, I9 k+ T# b# p+ v
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  
  - C8 }- z) H$ X3 r' n6 ~
• 
  
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  % S, r- H. }! w9 `5 L) C
• 
  ; G8 s6 u1 v( F5 V
  0 I2 s. q0 `. a  s: {1 x* O% v   p=ready;  /*输出就绪队列PCB*/  
  " k) N7 s( k5 U% U$ Y
  
• 
  
     while(p!=NULL)  
  
  ) T2 b7 E; K3 F% R
• 
    ^; M$ I+ _, p3 r- j: C/ X
     {  
  
  
• 
  # Y  X/ t" ?# j8 g* m- b, n! T
        prt2(algo,p);  
  , G+ A  _! Q: r& Z
  
• 
    E, C' D& ]# z% G: Z& l
  % n- g. f1 B; K8 x& N; R2 _% e      p=p->next;  
  
  - I. b' O# m& w5 k
• 
  0 v' Z' G4 d3 e
     }  
  # y) W* G/ S; o* k6 y
  
• 
  " o! G. D7 Y8 S! O
     p=finish;  /*输出完成队列的PCB*/  
  7 {+ O; `0 `& a3 S( S2 H4 H& U$ f8 v
  + n: F# j! U0 a5 F
• 
  9 t+ ~+ j1 C' _% d$ h
    l* w5 Y5 b' P! g   while(p!=NULL)  
  $ K1 f  `0 U. p1 Q' W0 f, }6 H
  
• 
  + ]- J' y( u; i' U  }
     {  
    a: O4 Z1 r0 J
  ! Y) I2 ^8 B9 A2 F* P
• 
  * @7 z2 y( d1 M4 C. Q( c" }' h
    t) q& P2 K( Y  r3 {4 o9 ?9 h      prt2(algo,p);  
  
  
• 
  
  - X! N; ?9 G4 I# e- o/ a: z      p=p->next;  
  4 c% m6 I. ^! ], F1 ?7 z9 ~; B
  
• 
  
  2 R6 y# h# `; U# {; D   }  
  
  
• 
  
    m9 F; F/ F% v- Z+ `' ]   getchar();  /*压任意键继续*/  
  
  
• 
  
  7 P/ R7 U- Q' E}  
  
  4 o/ B2 E1 s5 G5 R! e2 r. k& B4 C
• 
  
  /*优先数的插入算法*/  
  
  6 c7 `# Z3 [/ j( W  g7 L* U: N
• 
  ' R3 {; s! d4 |! U, l- F
  ! W; z& {0 y& @; hinsert1(PCB *q)  
  0 n! U! t0 t' w) P2 H% s! q; _
  
• 
  ' ~, ~9 h3 N; x2 [1 [% L% u! T
  ! q# j3 V8 e2 P) [+ }{  
  
  
• 
  2 J. W8 q! ?; y+ Q( k" K
  6 o+ y3 d; i' Q$ U' z# t   PCB *p1,*s,*r;  
  7 a5 m# H! J9 t" }( E5 d
  ) z  e" q4 p* \% E
• 
  / ^0 u% r2 @/ }" L% p
  3 W5 Z  B) i; J) K. _" O- c   int b;  
  
  8 K' k% Y# Q5 o
• 
  3 d8 A4 o1 O1 J) q1 g+ p/ H7 p. I
  % y% {  o7 z. v$ K/ V+ X   s=q;  /*待插入的PCB指针*/  
  
  ! ~5 i* r8 |' u0 _4 |
• 
  
     p1=ready; /*就绪队列头指针*/  
  2 S" S  _  u- }& Q* J% q
  
• 
  5 g4 i( H' \) g
     r=p1; /*r做p1的前驱指针*/  
  
  
• 
  3 F6 R6 Z6 @) O6 J+ `9 P
  + M) M) Y: U: T  T- [; u   b=1;  
  8 n6 U0 B- J, I. z1 F& m
  ' f* H( |+ K$ I$ F  ]
• 
  * O- N. v5 ?; L) I/ Q9 j' N" h
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  ' s* ]1 S  s( z% {
  6 s5 B8 x* ]. j
• 
  
  9 Q+ Y) M; {) y9 v6 [! U      if(p1->prio>=s->prio)  
  
  & b- B7 V$ {- A4 R! [/ H
• 
  " i( _' _% u- ?  X. f7 H% W( p
  8 n5 E: B/ \! V1 b8 \5 O      {  
  
  
• 
  . k* O: p5 n: v- G8 j( r2 F
  9 B2 U6 X3 F( e+ p     r=p1;  
  ( T9 s1 {" C# \. U
  ; b) \& B% W5 n4 r- g
• 
  
       p1=p1->next;  
  
  # k- C; P- `# b
• 
  & G/ u- `" V0 D+ F# u1 g! F' A
  % V" U% Y) J1 \5 C      }  
  / M4 z7 [- V2 Z( W7 ?5 M( a" E
  
• 
    \/ B' w* B' y; [5 P
  & i& i0 \/ u2 X3 M* X0 S3 R% s1 T) W      else  
  
  " @3 z2 H6 _! z7 {- @# z. K2 }
• 
  / K4 O8 Q. ~) t! @5 m
       b=0;  
  
  
• 
    J. N" ?! O/ @, z) e% q# S: @
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  7 @5 Z* U* o4 k0 S
     {  
  4 Z: J& b- K8 k
  
• 
  
        r->next=s;  
  4 i8 {8 _2 t$ z. W% i8 f8 V
  
• 
  7 v6 _9 U  L  Y, k5 m
        s->next=p1;  
  5 n* ^* @% j! o" P
  % i) q' ?& V; v
• 
  
  ! ^8 m9 v; j; ~. ^/ N7 C   }  
  + @( X1 ^$ e8 S: e2 g/ f$ E
  - B9 B! i8 \7 I4 O' U  K# v: g5 }
• 
  
  5 M+ c! F! r  M$ _6 T" b6 g- A   else  
  $ t4 J) F3 W$ _$ ~4 i9 U
  
• 
  
  8 N( }6 ]7 P" q  l; S+ ^3 Q   {  
  
  7 o  k+ ?8 w8 V% q4 X9 a' f
• 
  0 l8 \. G6 ]2 L
  / O% R3 {+ |: D      s->next=p1;  /*否则插入在就绪队列的头*/  
  
  % d8 y( a$ \; B5 Z! G/ z
• 
  : X; X( }( J/ C% B/ T
  5 g6 n; u& N3 L) g1 P5 D      ready=s;  
  
  ! I" p. [) Y: L; S0 \
• 
  # |5 F! ]& L: t! N
     }  
  
  
• 
  & X: X/ E2 U3 E$ E/ H! P' _" B
  % F5 k* b1 g+ ^2 O! m8 R}  
  
  
• 
  ! |+ m( J- y$ B6 W. _7 z- k. O5 _
  /*优先数创建初始PCB信息*/  
  ! G+ |' B& B2 ?2 ~
  ' _+ b. W) j" W$ U8 J4 T' \: {
• 
  
  * ^$ ?# Z: n& X  |1 r. h/ L, \void create(char alg)  
    ~! s! C- l9 A+ F7 A
  - C: j' L7 r( W$ ]& l
• 
  8 m; R- u2 l& j; ~1 k* }' Y
  ) @4 @+ d# e: N* ]# N  T  e+ Z+ O& M{  
  
  
• 
  
  ; Y2 ]& @. m3 [2 U! M! t! f- f9 B- L   PCB *p;  
  2 C' o4 [# a) z( g
  : ^! T/ Y( ?, k' @6 h
• 
  
     int i,time;  
  1 m& p# Z" d7 v" h
  
• 
  
     char na[10];  
  - j4 {# `8 t' Y5 `
  ) N4 P# f; v! u6 \  o
• 
  6 g9 h% y) }, j0 B  r* J4 f9 I# i
  / C! k- C. |) n) H   ready=NULL; /*就绪队列头指针*/  
  
  - H0 B" B, z$ F0 h, r# N4 s
• 
  ' \! g( A- X8 D. I) P
  ! f4 L1 G! s: g) |   finish=NULL;  /*完成队列头指针*/  
  6 Z* f: t3 K4 u5 o& e
  
• 
  $ y* g0 r& Z, |' B% Y% P9 k
     run=NULL; /*运行队列指针*/  
  
  3 ]' C$ x/ P+ q# r; L/ v8 [5 v6 K
• 
  " [% ]. G3 j% ]5 M7 y& |
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  
• 
  * Y) g# M* L( |' z  G4 v
  ; t" C3 q( O* ~. v   for(i=1;i<=N;i++)  
  
  
• 
  
     {  
  " O1 P* J  m3 j' N( B
  6 T! N/ f* |* t' p0 G. s7 {
• 
  ; a. |% X! _* q1 s  V! ~
    D) N. n) m1 m1 _: M2 b+ @      p=(PCB *)malloc(sizeof(PCB));  
  6 {. d: ?; z  R* F& ^  E& K
  7 E3 Y% y0 a- e# ~1 V) u; w
• 
  & {% O- u) g; L' l# X
  + C3 o; z7 y* T( E      scanf("%s",na);  
  
  * i. U6 L- T$ x# n% V4 A- ]
• 
  7 d' r) ?% k' Y2 c  J) Q
        scanf("%d",&time);  
  
  ; G3 C$ @! H% R$ F! q
• 
  
        strcpy(p->name,na);  
  . z4 s4 n  m! c" m
  
• 
  $ A" Z9 Z& }5 @+ J- }% ^: r
        p->cputime=0;  
  
  8 E, F& _, X0 u/ j; W( G" D# A
• 
  
        p->needtime=time;  
  3 k0 \- H0 y- T0 l6 {: @% S  r, v
  7 z2 ~! p) ~' l: K4 ]: u' t
• 
  
        p->state='w';  
  * O% o, i7 x" l7 ~8 q
  2 N  {, h8 G( l& V6 n: p, z
• 
  
        p->prio=50-time;  
  
  
• 
  6 r- ~$ c* [! l, C  ~
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  0 m" v) ], k4 O; f) l8 Y% D
• 
  
  $ t; O% J0 r2 L! j  M- W5 v% H     insert1(p);  
  
  ; D3 ^. ^  D, j
• 
  
        else  
  
  + p8 D' w  i, X; j4 F6 u& h
• 
  
  # A1 t8 O" q. k6 I" {: }& ~* D      {  
  ( d% z( T) r5 s( z9 r  q
  * W/ q6 t: f* b
• 
  2 z+ `+ r3 M, r. @- `
  6 v- W- ?& j7 h) a& W+ f     p->next=ready; /*创建就绪队列的第一个PCB*/  
  2 _: n+ k2 M5 W* A0 h
  
• 
  
  1 J0 M" i! l$ \     ready=p;  
  
  ! G& q6 y  d$ E  {
• 
  ' w; E5 V% ~" C3 P5 o. C% _* }
        }  
  
  7 {' W8 C# b; U& W5 b4 W4 b
• 
  4 H) }/ B2 A% v: M5 p  `, O* [. j
     }  
  
  / r& D. U: b( F5 Q! `; @
• 
  ; G5 L  K6 a" u; V# x6 G
  ! U1 D" W* W/ |# {( C; T   printf("          优先数算法输出信息:\n");  
  # `2 [7 ^! D  ~0 j5 L- j
  % `' u! J9 l' ~
• 
  
     printf("************************************************\n");  
  4 K5 j/ ?( v; k
  + d9 {  x9 ]7 e) m
• 
  
     prt(alg);  /*输出进程PCB信息*/  
  
  & k9 s: C% b: N
• 
  
  5 }7 W2 S; ]; m7 e* Y; m   run=ready; /*将就绪队列的第一个进程投入运行*/  
  ' J) r! M2 I. X& [* U4 \
  ' s$ g  y/ U; ~5 y. T& ~
• 
  
  * B( V+ _+ y6 H' |4 r   ready=ready->next;  
  
  
• 
  
     run->state='R';  
  
  
• 
  
  }  
  
    t- @3 G" ?8 B. E; Z: W
• 
  
  1 K& j* V: y2 l7 H, t7 ~/*优先数调度算法*/  
  
  
• 
  
  3 f4 v8 j# ?( O$ g) G/ s6 r+ Z& {priority(char alg)  
  
  
• 
    g7 ]: i0 b% O0 r) P: q
  8 C) P/ s" v9 m4 {' V9 p4 m) |& y& @{  
  
  
• 
  2 @, i5 T. f& x6 u
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  
• 
  3 M  p6 s; T, ]9 x) Y0 ?2 n# l
     {  
  
  # L, [( U$ V, w7 F, @7 a% h& b* l
• 
  
    ?: f2 c0 J: U  ]6 W, A. [      run->cputime=run->cputime+1;  
  9 }3 [; ~" L$ ^3 p4 P; r: u
  
• 
  
        run->needtime=run->needtime-1;  
  
  
• 
  
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  4 C$ Y6 I+ ^' n2 f& `
• 
  
  ; x8 f6 z* T0 X5 I3 }      PCB *p;
  8 X8 w+ l! @( t& k/ I5 |1 p  }
  * v- C/ b# L/ Q
• 
  0 [% ^4 f( J8 F) N& Z2 i) Z
  , l' q5 Y& H7 c- \- p      p=ready;
  
  
• 
  * q7 W& Z3 w* f" O$ f3 e- T: Q
        while(p!=NULL)  
  : K1 G- e$ f, B; u8 I& y  }
  % j  f6 p, B5 L6 E! L
• 
  
  # H+ F5 o3 k8 x' S" _      {  
  0 m% H9 _5 A6 q: L2 j1 O9 I
  , v: G8 G4 u4 o( X: t
• 
  
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  ! L6 x- h4 e- [( W7 M- p  K% O) `
• 
  $ C; V% ]) A, q/ j* Y
            p=p->next;  
  # v) d! [, z* C0 W
  
• 
  # ~3 U2 `+ O: d% D0 F
        }  
  1 D, p' B2 C; A0 ]" J
  2 o' ]# }$ \" U/ Y, r" G$ t
• 
  : H" y. }" ^( G5 Z& l
  " F+ k9 b3 B% W      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  4 z( K  T: I/ d7 [
• 
  
        {  
  
  
• 
  4 b! n* L- ~2 A. o( j
  . b+ S  l6 u' I& J. r2 c         run->next=finish;  
  
  ! `* \5 X% j9 g+ j- Q) s
• 
  ) ?% s: E. q# |$ ?% a+ o8 e
           finish=run;  
  ; _% d4 W& E$ p! j
  9 s& m. y, R% N. C' R
• 
  , j0 h- }3 x  V5 O" t4 p8 q1 l% ^
  3 y- k  I" _: m  r/ ^& V         run->state='F';  /*置状态为完成态*/  
  
    b$ P" s/ t" e4 B1 _
• 
  ( |4 }1 O; X. S, g9 e
           run=NULL;  /*运行队列头指针为空*/  
  
  
• 
  
  ( W; L2 f) u, z( O# J- j         if(ready!=NULL) /*如就绪队列不空*/
  
  
• 
  
  % u  A  K* \9 Y# U  O2 o) G         {  
  $ S' n5 z3 z: h8 t  V
  
• 
  * Z; d& p7 B$ P
  4 W! ~) _) [6 Q" P$ y            firstin(); /*将就绪对列的第一个进程投入运行*/  
  " A$ U: P. b& K; N) R& c5 [$ |8 f
  
• 
  
  % y+ {6 P; m* r6 q& M& ]         }
  
  . n* c# I# {, l5 S% M; H. C! S
• 
  - Y/ Z6 u# P) {
  ( d2 P3 _2 X9 @5 p7 V6 K      }  
  % N. [5 U" r1 O& H
  
• 
  / x8 [3 t+ K0 s% m+ B
  4 R& D7 O0 T1 m" z4 a# W) L/ z      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  , b# Y9 n" @: u. q7 T: B
  " ~4 t% O8 I3 v5 o: X2 K0 ]
• 
  
    w& d# Q1 o) k! {     if((ready!=NULL)&&(run->prio<ready->prio))  
  
  & k, h- w; a. P, B
• 
  
  ) @2 N  v' m. p! F' K     {  
  
  1 P# ?6 X8 l  ]/ m( z0 }9 k0 D7 C
• 
  
          run->state='W';  
  ( q$ [' _. O" b7 A2 i- Y# A
  : j' f$ S* q# L3 i* p7 y
• 
  
  : w3 k; d, |( C% `        insert1(run);  
  ) Q* c3 B! `0 q: N% f1 L' R
  2 @& j) g- G& N& Y
• 
  
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  0 J, l0 M$ c3 H. M3 x- |) k5 P  L
  
• 
  $ @/ N, R1 g2 J5 a
       }  
  
  8 W" U* t' m8 a4 z. ~* _
• 
  3 z9 }) {8 E' m  L, M
  5 @4 p% m+ ]0 T0 a, y8 K/ Z% i      prt(alg); /*输出进程PCB信息*/  
  
  1 o  ?# D6 t' u- G
• 
  * G( V. r8 k9 b6 \! C# }
  3 q9 K1 N8 B, L, j4 \   }  
  
  
• 
  4 @1 r; i9 w# B- e, _
  }  
  
  
• 
  
  : G1 W1 ?9 \; W! Z+ [/*主函数*/  
  % n& s/ d/ A3 N: i; @$ F6 v; f
  
• 
  
  " s* [& @9 C4 z( hmain()  
  2 c4 J: L- I. p# s! a
  7 N" j' a  o0 D, F- W, L
• 
  " k: g/ v3 R" Z8 p% J! w1 U
  + p" u0 A$ U1 F1 u7 X" G. J  M{  
  3 O0 {( X- w9 Y$ ]
  
• 
  
     char algo;  /*算法标记*/  
  
  
• 
  # n2 Z0 @6 ], l, H7 O1 X( F7 j
  8 `8 m: a+ C: L6 b4 K7 O   printf("输入P确定算法：优先数算法\n");  
  
  % B" {$ R9 X1 n1 S1 W$ i; Q1 Q% X
• 
  - X) ~' P- d+ G& T; P
     scanf("%c",&algo); /*输入字符确定算法*/  
  
  
• 
  ) X7 \; O6 L0 e1 [. p0 Y
     printf("输入进程数：\n");  
  
  
• 
  
  " |* D; b) m9 Q: C' M) \1 Z5 ?   scanf("%d",&N); /*输入进程数*/  
  
  ) S9 B  C2 }+ c, X8 {+ W
• 
  6 ~- w0 m2 N  v# r1 s. p
     if(algo=='P'||algo=='p')  
  
  * d! G" a  u) D. x  P+ a
• 
  
     {  
  ' F& w- P4 z8 i, k# R% L
  5 z7 y  x8 T& P% z9 {8 b/ t+ A
• 
  
        create(algo); /*优先数法*/  
  
  - ~6 T. s3 z2 I/ j
• 
  
        priority(algo);  
  
  
• 
  
  / ^3 \7 {% p2 k2 K   }
  4 B' s* y# n+ U1 L. w
  3 Y+ u. q: t! c
• 
  
  }
  . X: o  j3 I4 n$ k3 P2 F/ U
  
  8 T$ g/ R& _& v8 l! \3 T7 r0 g% H

输出结果：
# X0 S& H2 _  n9 z( e, y7 g

& j& a  Z' @8 F5 `) G+ i原文：https://blog.csdn.net/weixin_40962955/article/details/80072769