优先级调度算法

杨利霞

优先级调度算法

算法介绍
# R( i3 s% E* R0 G优先调度算法的类型（用于作业调度）
( U  Y+ ^% ]7 M, f1）非抢占式优先权调度算法
( L- R  F) Y$ J- i1 y7 x系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
0 h. R8 k' H2 Y( F/ r. j2 A" H% s2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1 }& g. x+ G. K3 U3 L) a1）静态优先权
$ R  y' g. z, B& u" g静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
# f$ M  E3 p9 H+ Z8 G3 Q

2）动态优先权

算法实现

抢占式动态优先权：

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

• 
  
  # M1 n9 ^: ]7 z7 U- k& q#include <stdio.h>
  : O- T. A/ \7 }
  
• 
  & R4 q6 T$ \! w
  #include <stdlib.h>  
  
  
• 
  
  #include <string.h>  
  
  1 D' y1 g. ]+ N/ e
• 
  
  & i7 Y# V, E9 ytypedef struct node  
    v  S+ w7 f: h% e  j+ y9 d* K
  
• 
  
  , ?7 p, ~2 o4 b9 ], O/ e$ {5 ^0 v{  
  1 k/ p$ s4 |1 o7 y& D. C/ Q- Y
  
• 
  7 R+ U+ G, C, L( j5 h9 n
     char name[10];  /*进程标识符*/  
  2 G7 i& H8 r+ m- r9 Z
  2 M# Y1 @7 i, W8 X% Q) V9 v4 }3 P0 J
• 
  
     int prio;   /*进程优先数*/  
  2 \0 y9 O, F: |: W1 N( N5 X
  
• 
  % @1 [' O! _9 p! M
  ; [' d0 r* u# W: e9 R   int round;  /*进程时间轮转时间片*/  
  % t) i' v: }8 L: x# E4 p
    D- P5 H$ @1 r  y9 i3 e
• 
  " h5 |. j/ b9 V* g
  . G9 ^! q- F( i% ~* A/ w- ]: g   int cputime; /*进程占用CPU时间*/  
  
  6 ^( l7 ?0 Q3 Q7 I: k0 ^1 D- e
• 
  
  1 X' ]  |( n" l  `   int needtime; /*进程到完成还要的时间*/  
  
  0 d' C& b9 ?5 `) Z0 N
• 
  : ~4 j- W- B$ M& i7 N% G
     int count;  /*计数器*/  
  6 s! S% h. y1 l2 H
  
• 
  
     char state; /*进程的状态*/  
  
  ' k/ n& W, M2 V. g2 o
• 
  
  / T3 x$ ]( k: u" g) f( h+ B) E   struct node *next; /*链指针*/  
  
  
• 
  * I( {% f1 r  S; o7 g4 J
  $ ?$ h  v% Z5 t: I2 u  M0 p}PCB;  
  $ O3 ^& p' H5 {; l1 H; i! w
  % p+ n4 u# p/ K8 G
• 
  
  / |$ x4 @/ p! s; uPCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  
• 
  
  # d; M  a: o+ K- _) x$ O8 ^) j* \int N; /*进程数*/  
  
  
• 
  - f4 y& s1 d' V
  /*将就绪队列中的第一个进程投入运行*/  
  % a0 n8 q" ~" S- K) H2 @- y; s
  4 o; R; u9 A' P' h# T+ W
• 
  - f5 ]/ a0 W7 X9 z  R/ q
  8 N- {' ]  }5 N' k6 R! o4 ]2 }7 R8 c1 b4 Hfirstin()  
  
  / l, d8 l. `, E. p0 i
• 
  
  & P+ P! X1 s3 A5 h- b5 [% p{  
  
  8 y6 n0 |( k0 A
• 
  
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  # C( s8 Y& g: r( ~; `' ~- h' v
• 
  
  $ x" u2 Z- f7 t1 j5 a; @   run->state='R';   /*进程状态变为运行态*/  
  
  
• 
  % I- m- I5 ]9 I/ I1 z; w" r
  . M6 D) u# p5 d5 @   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  
• 
  
  }  
  & u# I% }3 A, [# E1 ]- k& e
  : D/ K! I7 T8 o5 o2 U& n) `! M5 ?* ]
• 
  
  /*标题输出函数*/  
  ! t2 t2 c& {$ B5 |* F' ~$ b$ m. h% G; e
  1 L( ]$ G8 V& v
• 
  6 r5 L3 x7 j4 _- K- f/ V) s5 T! N/ `
  7 b( z2 L3 p, l4 O8 N; Z% {" dvoid prt1(char a)  
  
  ; x0 v9 J8 t1 @2 E5 n
• 
  : y' B% A2 D& J3 q
  {  
  & \# X+ `! e: ]5 i$ u
  
• 
  / U+ U' b+ F( n
  9 v- j( N6 q1 @   if(toupper(a)=='P') /*优先数法*/  
  6 C! p) u/ A$ Y! |: @
  ( ?) a, p! X5 a$ Q- L' M1 B5 Q
• 
  ; Q7 E4 F3 }$ v7 E( l' Q
  . m; _# v0 X7 ~: N      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  8 x# C4 e7 i, g& Y# t3 b' {1 [
  # }) e. F0 [* f8 N( b/ n  J   else  
  
  
• 
  
  , ~3 b4 \3 t, c      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  6 d3 Y+ x4 M" o) y4 i- Q
  
• 
  
  }  
  , @; C" p, @% ~- x- j) z! W
  
• 
  * R* l- ]9 r: |2 t% a0 ^
  /*进程PCB输出*/  
  
  
• 
  
  void prt2(char a,PCB *q)  
  ' c1 \( Q$ x" d/ T& c7 W1 F
  
• 
  # p7 P! H, U' ]2 s% _9 V& J
  {  
  
  0 u% u; w; R" x; _8 {
• 
  
     if(toupper(a)=='P')  /*优先数法的输出*/  
    t2 l" v) i. t# N$ w  @  |
  
• 
  
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  , W; A1 G, r* }: l! Q
  2 O# m  D6 J! `% N3 C
• 
  8 J; |4 ~. N0 t3 n- z1 d5 N: u
         q->cputime,q->needtime,q->prio,q->state);  
  * K; G6 F. l; `; \# O
  
• 
  6 {7 l; I5 v( e( }
  & P% X; x; `7 l: b8 E* U   else/*轮转法的输出*/  
  ( |: f# @3 D5 N
  " t+ J+ @% r  ^- c2 w
• 
  1 q1 h# M0 g# y- i
  # t0 s3 j$ ~. `; u- A4 n      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  ) O' @. [: J: F3 b! `6 d
  , T5 R1 l! N' Q4 v5 [+ }6 f/ s2 d
• 
  / i$ l' m: d$ Z
         q->cputime,q->needtime,q->count,q->round,q->state);  
    T& i" P/ C' K1 H) O2 C
  8 [0 X$ I3 l* R. [9 E& w$ D5 S$ q
• 
  ) ?% [7 F  L& A3 G2 n+ O$ Q9 T( j+ o
  }  
  
  ! X. Z1 f% @9 q
• 
  
  /*输出函数*/  
  
  " F" h9 q# ]  j+ o* s
• 
  
  % E6 _. G7 Z4 c6 A% g# Qvoid prt(char algo)  
  
    g. t, w5 s4 e  }: n4 c
• 
  9 P- F& f" L; A% Y  ^3 O5 f1 Z
  6 M2 r& b" c* l  w$ K; }{  
  
  % Z% q$ b$ ]  e+ x) \" v4 R! e: u
• 
  / ]* M) J9 }8 Z  i4 Y3 }9 r
  7 t' Q% g. m2 l9 \   PCB *p;  
  ( g% H' V: z3 V& \, p' ?# W- z
  
• 
  * T: a$ E3 f( m0 m
  3 G( p! D. h# O: N& d1 t   prt1(algo);  /*输出标题*/  
  
  
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  - q( G4 ?4 ]- |- |' x& b
  1 B4 C9 w& e. O" m/ h1 a2 D
• 
  . f) Y) t) `1 k, g- N, H+ s: P
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  6 W' S$ g9 z1 G, B
• 
  * c4 D6 k2 E4 r1 c0 Z6 ~! x, o
  2 p$ O  a9 L$ {   p=ready;  /*输出就绪队列PCB*/  
  ! P5 }$ ^# W- a' _& l1 Z
  2 d3 X! S% o' z/ U. i  f5 Q8 D
• 
  
  * ?! ^) P/ c! ^* x   while(p!=NULL)  
  5 f$ R/ G: E5 v$ k: B/ F
  
• 
  $ Z2 V6 U0 ]! I$ j* {+ _4 C$ M  Y
     {  
  
  9 w8 ~' o* E  A& ~4 U& Q
• 
  
        prt2(algo,p);  
  
  
• 
  
  , O' `4 r/ y7 l* f7 |) [      p=p->next;  
  0 K: {' y# }) _/ S
  
• 
  . K! a( M0 Q: s7 Y* k* L& i
     }  
  
  
• 
  % i0 x1 i/ e4 v' ~- V
     p=finish;  /*输出完成队列的PCB*/  
  * ^/ s( N( E# Y+ S
  " y1 n% X4 k7 k
• 
  ( u) \( e! R+ y7 c
  2 ~5 d3 r/ V" m1 ^% \  V# T# p   while(p!=NULL)  
  
  ! t3 p# {2 G# \1 V( H5 x' K
• 
  
  : q: _8 \  S) H9 ~   {  
  
  
• 
  
        prt2(algo,p);  
  + A% {4 U% l) g. K" q5 X# K7 x
  4 g1 q% k. u. C, O4 x$ T5 Z: Z
• 
  
  $ g/ u0 P* P# Q- \) V' x2 I" M      p=p->next;  
  . b) a% z: e( t& s1 {$ z/ e
  
• 
  $ @. u7 f8 e' g7 Z. r7 p, M* L. G
     }  
  . f5 b" {' Z. o
  + C4 ?' g& T; F
• 
  
     getchar();  /*压任意键继续*/  
  
  
• 
  ; z, m9 M2 z- f8 b/ @# K8 A  {2 D
  ) S5 _2 T9 b- H  k}  
  
  5 r. N& \' u& u4 q3 ^, c4 T
• 
  
  6 n1 \2 {! p6 H- H- [/*优先数的插入算法*/  
  $ F4 ]. @; E* Y% z3 j& Y5 A9 k
  
• 
  4 C  R4 h" o0 u; c' _
  insert1(PCB *q)  
  
  9 R/ U8 M( n( z  s8 S
• 
  
  {  
  
  
• 
  
  # o' m) t7 J3 |) [1 E# @: c2 s/ t1 L   PCB *p1,*s,*r;  
  
  ; S0 B9 E( M* S: S
• 
  5 p  T+ z4 l' I& G7 Y' O' \1 {- U
  4 ?0 m, D5 _( y2 K5 S   int b;  
  : L$ D1 Y! Q: u8 A/ D" R9 p  [
  * r% H: Q/ h2 |! G3 _
• 
  
  4 M) K4 a! V6 j) u5 p# y   s=q;  /*待插入的PCB指针*/  
  / K  G6 }: ^* Q  B7 `% `
  ( _9 E  ]1 O! v* V2 B9 t2 G4 M& h; I
• 
    |1 a8 t- Q5 O/ f) e! O1 j" q
  9 r0 N4 O  [4 s5 m   p1=ready; /*就绪队列头指针*/  
  : q2 i/ f7 c- h7 m5 S
  
• 
  * D7 N1 M$ Z' h& Y# L$ T( j" X
  ; f( o  L6 h% L3 r; q5 s7 [   r=p1; /*r做p1的前驱指针*/  
  6 n/ D/ h& Z+ v) Z# U# \5 I/ @- z
  
• 
  
  . V3 z# |$ T. k3 o4 f   b=1;  
  
  
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  % U. ]5 O1 o+ }5 _
• 
  3 ?8 \* R  v2 W5 \' \
        if(p1->prio>=s->prio)  
  - O  V: }" ]  b/ U5 q8 Y1 k
  - k& q- t- y( h( `
• 
  
  3 u0 R) x" R* s) T+ y; j/ T! y      {  
  + t. W8 y- @% @- {; s
  
• 
  
  2 W; S; l3 S6 ^& R' f     r=p1;  
  , \' E; h- F; l& ]% G
  0 v$ T0 b) @4 Z; v
• 
  
       p1=p1->next;  
  # \; F4 Y. y( C
    E" V$ P' Q& x8 G7 J5 f
• 
  
        }  
  
  
• 
  - j/ c8 T  H; y/ {$ ~4 ?9 U
        else  
  
  
• 
  0 |* M& a# H" ~& ]. P3 M
       b=0;  
  ! t, p! C/ s3 l. @7 S
  
• 
  
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
    q% ~. \5 z# r
• 
  4 G9 S& g3 @  G4 ?$ N
    W# e( g: g4 U: @* t% a7 ?   {  
  " E. T& \$ N9 ?9 j
  
• 
  / ~& U$ D4 V+ {; C
  - K: N% |4 a2 R      r->next=s;  
    @$ k; h1 p2 G, P" M2 P1 r
  # H3 ~7 b! u$ {) ]
• 
  
  7 C& j( p3 u# ^( B      s->next=p1;  
  
  / n$ i1 R; Q% Y% o) W9 Q3 ]
• 
  
  2 K' \9 \( C$ c% }; Z; g* q   }  
  : \; p" n8 P2 j
  
• 
  
  ) z$ Q& C6 N2 R( N' b5 P9 M   else  
  ; a5 E+ ]+ `- n* M6 Y; M
  % @$ M4 f8 k4 o
• 
  
  " h3 s  X4 A1 g2 A   {  
  3 h. U* x* ?1 V  y7 [6 W% t( K$ Q
  ( I5 F5 j: _. I0 ~
• 
  # f" _& ?3 o9 }! \7 ?" N- y
  6 z, a1 h& `( u" N3 |0 s      s->next=p1;  /*否则插入在就绪队列的头*/  
  
  
• 
  " R( H! X3 C5 e  f* V
        ready=s;  
  * t4 o& G* J7 Z- F% U
  : a" v6 f2 @/ \- ^: L5 ^0 C
• 
  : o% e" k& C$ \- m
     }  
  2 t. d( b1 \% K' s: R$ b4 h
  
• 
  
  ' ^. g  C! B5 v6 [1 l$ p) k8 D  A  b}  
  ' n  a2 p1 V$ ^; f7 p
  
• 
  ( s* a4 z. @6 i5 y1 ~3 u6 _
  ! q' d/ J. l* G; n; v/*优先数创建初始PCB信息*/  
  
  # W8 o$ _3 b; [! h! _' ~& z& @
• 
  & }& v: ~; P: B7 i# c9 W8 W5 q
  ( ^  A6 B% j, z8 z8 [, gvoid create(char alg)  
  ( `0 k; w; P3 H/ [  L  X' G8 V
  4 q$ e) ?6 I. O; N
• 
  * M5 _9 B! m. |
  {  
  
  6 {0 F  e9 X5 H# _
• 
  $ N, d; M- D+ N1 L. O% y$ _
     PCB *p;  
  " Q# T% B2 m: Z. K+ e
  - S: M/ {" v# F& Z# a' {, k
• 
  
  ' M6 E9 V7 d" r   int i,time;  
  
  6 R" e/ z9 s+ E( p
• 
  
  / C/ S1 ]6 S% @4 k   char na[10];  
  " ~* H( M$ T( F
  
• 
  - w5 L8 x) \2 q1 t: \) c
     ready=NULL; /*就绪队列头指针*/  
  
  
• 
  
     finish=NULL;  /*完成队列头指针*/  
  
  " @( g/ G  ]/ u4 w2 A, t  E
• 
  / |% v' `3 j# v& B: I- m
  / ~  z* V1 v4 \6 g8 M/ }8 M   run=NULL; /*运行队列指针*/  
  8 X9 F5 \( f' A9 i! b9 y
  
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  
• 
  
     for(i=1;i<=N;i++)  
  
  + [1 G4 ?; l0 ?# B% F* t- z. s
• 
  
  6 j0 @3 R5 p$ h. P   {  
  
  7 x& f' ~  L. I  k, M" m
• 
  ' z" E. O0 n& q1 ^+ r" d
  4 D: g3 q# a' y  @( D+ v      p=(PCB *)malloc(sizeof(PCB));  
  ) B9 k" l. I5 d( g
  $ z% Q, Y4 s  d0 t8 q/ {
• 
  
        scanf("%s",na);  
  
  : L9 r. f( E- }$ Y  B( P: a6 @
• 
  
  / u. j+ S) C+ x" X      scanf("%d",&time);  
  ; v: V; d; Q  L, Z1 y7 B0 q
  * J' L: X; `5 }- J: R! A) W$ x  D" {
• 
  
        strcpy(p->name,na);  
  
  $ y& P* `6 C: E
• 
  
        p->cputime=0;  
  ; N7 Y2 Z& ^6 P. K
  ' ?& @; r7 ]7 u  \) `5 j9 R- P
• 
  
  & G3 ~' ?1 n/ h# r; V+ i      p->needtime=time;  
  6 O9 p+ W7 I3 B2 d2 L
  
• 
  , E# H! x: r1 G7 B9 o3 ~, q
  , {! ^! E. A9 j1 U0 K' Q      p->state='w';  
  
  
• 
  ; U  F* t7 S- v; N  `
        p->prio=50-time;  
  1 y( L9 E, c. f! b3 x
  9 Q) Y* I; |: E) t7 j0 s, |( V+ r
• 
  & W/ n% z$ A+ O3 Y
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  " Z8 E' E# Y0 a4 R$ W; o/ ]
  
• 
  
  . b1 a5 D% b* [8 u/ |& O4 E$ _2 p     insert1(p);  
  ( y2 C3 s) G. f7 G( g6 F5 @4 X
  ) ]# `* e# _1 [. r
• 
  
  ! Z5 o1 |- @/ u0 e) C- C4 Y2 M9 @      else  
  
  
• 
  
        {  
  
  7 ]' K3 g! T  l$ n0 p6 A
• 
  
  ! j( r+ I  O( B' R     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  " _& M) h/ Y8 U* Y: L2 B0 I  ~
• 
  
       ready=p;  
  
  / J$ F5 L0 T* [8 y* k1 \
• 
  , R7 b, T, n0 p- s0 h8 j) t+ O
        }  
  $ H+ k& R  \/ z8 _' |4 {. v6 U; u
  ( O6 V( J; g+ C( J4 H
• 
  9 Q3 {& @& l# ~/ L  ~  {
     }  
  
  " V+ l; b) {6 L2 D* ]/ J7 A6 i
• 
  
     printf("          优先数算法输出信息:\n");  
  : X* }7 O, L/ V5 C6 V
  
• 
  
     printf("************************************************\n");  
  . G/ H6 ?( G& [( I8 R
  / e4 P: B( D) `1 t) k2 d# ]
• 
  
     prt(alg);  /*输出进程PCB信息*/  
  # o$ x8 l8 _: z$ g- i
  
• 
  
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  
  ( G$ Y5 q8 r6 c   ready=ready->next;  
  ! d, Y1 B+ q6 [9 `  r' _& n. R: p- m
  
• 
  
  1 n6 u" @: O( `   run->state='R';  
  
  % Q+ {6 f! l8 C: w, b
• 
  
  }  
  
  
• 
  
  2 d0 ?2 y6 m- t; d/*优先数调度算法*/  
  ; R- D7 h$ U3 j" g
  3 k* D! V' s/ v: k. [* i3 `5 p6 X
• 
  
  priority(char alg)  
  
  4 ~7 ^; \& K) L, b3 j8 J' G
• 
  . p/ Z/ s! |7 p, G$ p5 k
  {  
  
  
• 
  9 @+ k9 i/ `& k; k" {5 @
  ) n' n' c& p6 O2 ~! o) ^& i) v5 ^   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  ; j& C9 t8 z, s' ~
  * N- Z, S. b# s( }3 W5 O
• 
  
  + Y9 t4 N! B$ o* R& ]$ D6 h1 M   {  
  ' k7 n; Y) U8 @* g% o& J4 K: B
  ' h8 j/ i( R  ]1 j- Z
• 
  , b; n+ V( V* N( j1 V) m( E; {9 @. p
        run->cputime=run->cputime+1;  
  & e: i, S! {" l
  
• 
  7 N7 V7 O* T* j' [% v: d
        run->needtime=run->needtime-1;  
  2 d; U) x) B( l- v  s4 O' N
  
• 
  5 j  Q5 w4 [& Y% U7 i: R
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  # D2 U7 M/ {. q, R: O% Y, ^# L
  : x# A! L2 {& {* V, B
• 
  
  & V- C; g/ Z" g6 `. N1 S      PCB *p;
  
  0 o) b/ x2 b, U
• 
  
        p=ready;
  
  ; l. K) h/ v0 @
• 
  2 X4 g0 q* f6 y: F. N
        while(p!=NULL)  
  
  
• 
  / S( L* v' k+ }% V3 \9 |" q" b
        {  
  8 f4 }, Y: O6 B2 O4 |: l! h0 _. n
  ; B2 U# S. Q$ `. y8 ?& ]1 N
• 
  1 }6 V. _7 S& M
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  - f3 y1 c! r$ I* s4 k$ \  x
• 
  " _$ A& m$ C' v' b/ i
            p=p->next;  
  " W: a3 `$ H( l( g* ^
  
• 
  
        }  
  
  
• 
  
  , f9 h8 Z& u: ~8 E& E  a) @      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  / x9 z$ `( l6 e! T9 e2 o+ N9 P2 r
  
• 
  
        {  
  
  
• 
  0 e, w% J. j) K0 f9 z* C3 V. A
           run->next=finish;  
  9 a  }) _! A* |' ?  J8 l  u% g  k
  
• 
  # A# f/ D& u. m- M' G
  " O4 Z6 W4 f8 T( ?3 x& t2 R         finish=run;  
  6 s' e3 d) v( d: F+ @* ^2 R% ?
  
• 
  8 C5 Q  |. R- S1 Z( g# T
    i" [' G1 j4 x( _$ D5 n2 m+ w         run->state='F';  /*置状态为完成态*/  
  / ~( J: T' T% L1 h+ Z
  ' z* ^+ ?+ x$ v
• 
  & g) d: Q) T8 g8 M) z2 \
  " h. z6 `( E( M5 L. ^! B3 e         run=NULL;  /*运行队列头指针为空*/  
  
  * J* v9 ~% M3 R# p* L
• 
  
           if(ready!=NULL) /*如就绪队列不空*/
  
  
• 
  
           {  
  9 i+ A3 N! k1 K7 u$ O9 ^
  
• 
  0 \" R2 l$ g$ ^( w/ Z2 `4 n
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  " Q& v0 L+ B% E# I" W( X
  8 N0 x: B" p  ^# e, M
• 
  
           }
  
  5 y& m* a0 `( d- B! R6 J
• 
  . r: Z; I- v' h, B0 S& D
  ! t, `) f) M' o2 T' n7 A      }  
  
  ! U0 x  ]6 Y7 ~9 k  I+ G3 Q7 I$ Q
• 
  
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  ' @9 ^+ u4 P0 ^& M  g* {
• 
  
  5 u5 a: J/ ~$ w/ m' y0 l     if((ready!=NULL)&&(run->prio<ready->prio))  
  * P1 z1 M% |( z- O4 i$ A
  
• 
  
       {  
  
  , Z4 j7 [0 \" }2 M6 d
• 
  ' N- q, ^; ~* }$ y
          run->state='W';  
  
  
• 
  
          insert1(run);  
  
  & z" t  _& e1 B0 z
• 
  , o" q2 ~+ F5 I8 u
  : u, z# o! [4 H4 C7 x9 z; c: _! ]        firstin(); /*将就绪队列的第一个进程投入运行*/  
  ; m9 e! u/ V9 t) g7 z; u
  5 B! ~0 t) C) A3 b! {- C
• 
  
  $ p; b4 N. X; y' ?     }  
  9 i* q; V5 A; _2 {7 b% ]- M% O
  
• 
  ' B( z, C. y# Q: h( q, _. t: _& a
  3 a/ K' R5 F, Z3 M* ^* z6 s" k      prt(alg); /*输出进程PCB信息*/  
  7 g; o  `/ B( b9 f4 o/ o6 A6 |
  * @! `  G. w/ \. ]
• 
  
     }  
  # `& r( n- V$ D1 i. _0 g! P; J
  
• 
    ^1 X- m6 a. n3 _9 x- ~9 |
  ! }9 ]4 e0 m7 V+ C}  
  
  
• 
  4 @, _( K, |+ i1 W3 `0 K% P; H
  1 z/ F$ v/ V/ N9 X: `/*主函数*/  
  
  
• 
  
  main()  
  
  " R; L( |: L% Y2 }
• 
  
  7 D: l$ U6 M4 J& g( p: H5 w{  
  & p7 w! n1 r7 b5 D9 @$ b
  ' M+ w3 Z3 {1 i# H3 I, K8 ?
• 
    k& ?, q3 H6 q" V! I' F' `
  . p- f( w# D* F) U% F   char algo;  /*算法标记*/  
  
  
• 
  ; s, D* A: k/ c1 M1 _9 ?" V/ Q
  & R: k9 M/ h$ ~) z" |   printf("输入P确定算法：优先数算法\n");  
  
  
• 
  
  0 m- B. D4 n* ^5 e% |! P   scanf("%c",&algo); /*输入字符确定算法*/  
  
  
• 
  # `. K- [. k4 y# M! s: b  A
     printf("输入进程数：\n");  
  ' G: r, L1 u  I& R1 f5 E$ g
  
• 
  : I( Z# N- G- _; A
     scanf("%d",&N); /*输入进程数*/  
  ) S! j# ~0 B( R3 U. W
  
• 
  9 V3 `) w0 g# `, F/ I' C% |
     if(algo=='P'||algo=='p')  
  
  
• 
  
     {  
  . o/ t2 x5 \; e# T0 |% k' Z
  
• 
  
        create(algo); /*优先数法*/  
  
  # G% A; r6 |! N: f. Q
• 
  ! f3 X, ~5 o; c/ K  K: Y
        priority(algo);  
  
  
• 
  ( n) g+ l! V! Q8 z& X+ {
  : N+ v; l% j5 W9 b0 A   }
  
  " i/ M+ ?6 u0 D( D
• 
  $ p- _) N% N  e  M& i
  0 I5 o- o4 u: e/ U5 ], C4 f7 g}
  & P" B2 ], |/ S) f. N0 {7 I1 R: a
  - G1 G' Z: a; c" r! E! s9 ?
  ; e6 y" ^7 B; B- V" b

输出结果：

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