优先级调度算法

杨利霞

& {6 \- ~0 _7 M4 c& I! b优先级调度算法

算法介绍
, v! l$ x( i$ H& n5 U优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
( a, v: C# X3 [. |" ~只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
0 B2 X4 W' Y3 _! U9 H静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权
* m. L. K' C0 C( \

算法实现

抢占式动态优先权：

6 c: C" a4 G( OPS：本人认为非抢占式静态优先权没有实际价值。

• 
  / ^4 X% k& o- ~6 Q; {1 ]" @3 d
  #include <stdio.h>
  0 n6 o. M2 ?& k  _; x
  
• 
  
  #include <stdlib.h>  
  
  
• 
  $ H! Q2 G( H" w. f: T
  #include <string.h>  
  
  
• 
  
  6 J+ f2 ]) c9 Z+ S8 ltypedef struct node  
  
  + Q; c9 y: P' a4 Y7 ^
• 
  
    y  x8 Y* x3 C3 a/ @{  
  2 ]: j" \; m( ]$ J' h: k2 N) T% I: M
    i, G. l* ]9 W3 x. j1 L  e
• 
  & [8 x9 B0 X' F+ l
     char name[10];  /*进程标识符*/  
  
  
• 
  
  . u6 }2 P. l: T2 [% U   int prio;   /*进程优先数*/  
  
  
• 
  
  2 r5 T' Z3 [  l   int round;  /*进程时间轮转时间片*/  
  
  % V8 a6 ?% ~# k, D6 g- R2 o
• 
  % Y( C* O. ?7 J/ Q
  6 q* @: E" O# C: m, c- X5 O1 Z2 G7 l2 Z; Q   int cputime; /*进程占用CPU时间*/  
  9 v2 _( ~+ L# f3 M3 O
  
• 
  
     int needtime; /*进程到完成还要的时间*/  
  ) u# t9 d, X; B+ k4 i4 d( C
  
• 
  * Q2 e8 P) B$ a3 B
     int count;  /*计数器*/  
  9 E) B5 x+ q/ j2 W/ D( `
  4 e* g9 G* l2 [7 F: V1 t
• 
  
     char state; /*进程的状态*/  
  9 Z6 d0 b8 z1 n7 ^2 h
  2 Q7 `8 ~% c/ f3 p  I
• 
  
  + G8 E5 c: w5 o# p- `8 E" G  g   struct node *next; /*链指针*/  
  9 J! [  z+ F0 J, }- f9 D' A, r
  
• 
  + E* t1 W" ?, R- G. m
  . u. P" m& n/ q" f}PCB;  
  - V9 Q% V, P* R6 u
  ; p" |) i' J, X
• 
  
  $ {4 q4 x( y/ A5 u/ M1 F/ cPCB *finish,*ready,*tail,*run; /*队列指针*/  
  $ j5 Q% `+ J1 N- Z
  : d* f8 b, O! ~7 O, G+ [
• 
  7 H5 x$ O% V5 s: }) P
  int N; /*进程数*/  
  
  
• 
  
  /*将就绪队列中的第一个进程投入运行*/  
  / s$ q. U1 C9 [* O: i; p
  
• 
  
  ; N' w+ _& y7 K0 k9 Nfirstin()  
  ) B2 F6 a1 e, s7 n" Q
  
• 
  
  {  
  
  " m' o! a" E4 j0 K$ V2 C
• 
  ! k" G! `2 {# R
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  8 C# v6 f. @2 ?
  
• 
  " K: I; N& {& K
  / U" e1 w" h% X% M, K   run->state='R';   /*进程状态变为运行态*/  
  - x- ?' _1 X. l' j: z5 U- N+ F6 o
  
• 
  $ R3 Q! _- U  q
  + F9 j/ |; f! D9 p3 m8 x   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  0 K2 L0 ]3 C) g* @' ~* Y
• 
  
  3 f) Y/ C; Z. _$ ]1 U}  
  + b  e' R- I  B* J1 d
  8 \/ M/ x9 Z! z) _. |
• 
  
  , A5 v1 `6 [: y7 Q8 l7 L3 K/ |/*标题输出函数*/  
    g. }2 K) N* o1 K9 O9 a* l
  
• 
  
  ( Y, W- \2 u1 Z! J/ L& h5 pvoid prt1(char a)  
  3 i( t6 [& a6 a/ W! ~
  
• 
  3 @1 @5 u: F# n
  3 e3 C* z8 P! i) z; ?6 R9 t3 n{  
  7 T& x; r3 ]& N. R) ]
  
• 
  
     if(toupper(a)=='P') /*优先数法*/  
  & Z9 h9 R2 T0 ~3 T$ T
  
• 
  " J- ^" @0 e  D3 R: U5 c# s
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  ) Q9 Y! ]: g4 D' v  \8 |
     else  
  ' L& `7 W3 g) x) B
  
• 
  , i4 _' Q: ^4 |# I1 U% z1 ]2 G
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  ! P: c( J7 m" w. Y6 |4 O
  
• 
  
  1 m+ a2 B. O$ O" f1 T9 r}  
    Y2 Y# r1 }; w+ P" p; L$ _$ {
  
• 
  ' i9 u$ |9 e2 w$ Z2 L* G8 L
  0 Z; Z8 s1 y# |: Z# g( u/*进程PCB输出*/  
  
  3 D- I' h! h  j+ N- j) v% B/ e
• 
  " {# j5 V$ u' _& _2 f3 M8 r
  void prt2(char a,PCB *q)  
  9 W3 m! N9 b' {: `" n
  : t, r9 U9 }3 I6 _
• 
  ) C% M: F5 I  J4 m& |0 b: `
  {  
  
  " K9 [$ R! ], m+ @0 s" n2 g3 z& Q
• 
  
  6 Y( X5 v' g: j8 c   if(toupper(a)=='P')  /*优先数法的输出*/  
  
  # I: ~! c! ~- U$ N. j+ K! X0 R: B
• 
  
  4 P# U5 d6 U9 v8 B6 _      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  ) B3 U7 Q: r7 w. R0 @0 W  o
  ( J# |! t, l! l2 i4 }
• 
  
         q->cputime,q->needtime,q->prio,q->state);  
  
  + a: K& [* {2 @& S( X2 \: P# q) m
• 
  
     else/*轮转法的输出*/  
  
  . N# `3 S4 y* \
• 
  ) J; [/ X. ^; y1 Q" _. f
  $ ?) M) [! e0 O8 M% s      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  9 [6 c" M4 j* y0 \
• 
  " J8 A! |9 f" D" f8 R
  ( b! o( T* q, P5 y! i       q->cputime,q->needtime,q->count,q->round,q->state);  
  7 T1 N2 E! P! F! T- Q
  % m, @7 u! a- u$ e( ]
• 
  
  ) a. a: Z' C$ c}  
  - s8 s0 _7 V2 Y6 q* c* c& B* y  K
  / ?, [2 `1 e# S# W
• 
  
  /*输出函数*/  
  ! p7 C% Y, w: |  O! C
  
• 
  : r) a7 v8 C# }5 H
  " {1 Y, U; H+ W' w! lvoid prt(char algo)  
  
  % e3 O% ^3 _- \0 z- k' B  o
• 
  
  1 V* j8 X; H# q# [8 g2 A{  
  
  # [  o% _" L8 N: H3 [" e+ k7 Z2 G" J* b9 h
• 
  ; c. _2 n  h7 [" r9 y7 ?5 I
  ! J/ O+ K* C  q8 t6 Y   PCB *p;  
    I. s. m. p0 @( U
  
• 
  
     prt1(algo);  /*输出标题*/  
  
  6 \: e6 W3 f7 i* ^7 z6 M7 _
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  * }+ r" z# C, H$ e, K, |! j8 |& j( _
  - t8 `0 b* S% W) X% D4 y0 K: W
• 
  
  % x; m4 L7 x5 I; w0 o3 t  U      prt2(algo,run); /*输出当前正在运行的PCB*/  
  & o: B" _1 ~$ A2 `) ^5 H
  * r7 a* }5 f2 K! C- t/ v$ k) F
• 
  
     p=ready;  /*输出就绪队列PCB*/  
  0 l! z% {% H) t4 y' C
  8 H# _4 O7 a: t
• 
  8 P, W/ T' ]4 v/ t& M
     while(p!=NULL)  
  ( q8 ]$ g. ]8 X4 W
  
• 
  
     {  
  , S( q3 N- o' c
  2 V- Z' {: c, b% x( ^6 E5 k: @! Y  B8 t$ A
• 
  
  . j1 [: J8 J! E2 ^+ c      prt2(algo,p);  
  7 M8 }, [% D5 x; c3 l. i; v/ D4 ^! b+ H
  2 h3 D  F" X3 `6 o5 D9 F/ Z0 b
• 
  
  9 r2 J; {7 @8 m/ d8 y8 _+ m      p=p->next;  
  
  1 h9 ^& V; J8 @. m. ?6 d1 \
• 
  ) c" F8 C! ~6 b9 ]9 S! D6 F
     }  
  / \, Y1 Q( G7 b# e$ V
  
• 
  
  , S( K2 A) u: y0 V# N( k4 v   p=finish;  /*输出完成队列的PCB*/  
  : n8 b5 Y3 {( U& ^. H
  
• 
  
     while(p!=NULL)  
  ( ^8 g/ g! c5 K  R+ D
  5 Q5 A! |. A: A8 Y
• 
  : r# N& t9 `  P" J, z: _3 Y
     {  
  
  * S, A* l* l& d, H$ m4 u# {7 @5 E; M
• 
  
        prt2(algo,p);  
  ; h" R0 l2 F2 K; ]+ z# _! k* M
  8 d& V& W+ ~5 l; x' F7 W6 `( N
• 
  $ \- A3 E# R5 D1 Y
        p=p->next;  
  
  
• 
  
  - l# j6 v8 K# D  g& x   }  
  + u" q0 Q' \: E5 u6 l
  4 ?) x1 A: ?+ A3 K* X
• 
  : b  w/ n( t2 R: Y0 U( i8 `. q) m
  1 ^' }) \& G! v9 h" L   getchar();  /*压任意键继续*/  
  
  4 e$ J* s: w. _4 o, V  R
• 
  
  8 S) w1 Y7 G- {! F: K2 |* S}  
  
  
• 
  ; `9 O7 B$ A# M/ h. i
  ) |5 W/ z/ ~0 J: ~# q' ?& q9 E/*优先数的插入算法*/  
  
  
• 
  
  insert1(PCB *q)  
  
  8 e% z' x; E" }* r
• 
  7 B. R: N3 d; K
  " L" J5 M4 Z* ?{  
  0 z* P6 O! c& b
  ' g8 j+ G! W- p1 p' [5 \
• 
  % C2 c5 G; k* F" F! r
  ( x) w2 y0 ^7 V/ W0 @1 y+ m' r3 i# z' X   PCB *p1,*s,*r;  
  
  
• 
  
  ( M# W& ^& B* g9 r/ @) p   int b;  
  
  4 {1 [, L7 P- s
• 
  
  7 ]0 z' _" r- u& J0 u% @4 p   s=q;  /*待插入的PCB指针*/  
  ' }  E3 w& H# [! |# @  m
  . Y. q7 S. W% O4 Y3 ]% y
• 
  3 w0 S4 Z( y/ ^! e# Y
     p1=ready; /*就绪队列头指针*/  
  
    C0 |  v- b* {6 l
• 
  6 ~# O; z2 g+ h3 c' N
  / ~$ N0 u1 M# m5 j! k+ U9 I3 u2 L   r=p1; /*r做p1的前驱指针*/  
  
  
• 
  0 k4 K! P( [  P% z3 A' G: r
     b=1;  
  
  
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  4 v0 k( j$ Q3 J. T' B+ C" [5 h
• 
  
        if(p1->prio>=s->prio)  
  
  
• 
  ( I+ e1 g+ A+ c1 a1 |
        {  
  
  
• 
  7 r! Q/ ^8 k/ p8 `/ n: P
       r=p1;  
  % @/ T5 C/ z; f- t+ P
  
• 
  
  9 b9 _. g1 e% z& N; ^  K     p1=p1->next;  
  3 m7 `! N8 s0 O% L8 t
  $ m5 T4 W5 p0 S* [
• 
  1 V% r3 I* F6 T% X3 n! c9 {2 J7 `
        }  
  5 C: h5 _- S5 _: n' T, e
  3 p" D8 v/ x+ {7 ~$ a0 U  I
• 
  
        else  
  7 \4 J/ W7 m  J! W
  ! g& j/ a! A% e
• 
  
       b=0;  
  
  
• 
  
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  0 T9 T2 Y( `! A* N! K
  # A1 d& k5 ~% H! U
• 
  & X8 a% n+ v2 Z+ v
  ( ?$ Q# ?- C( e2 Z" e1 _4 I: x- p   {  
  / t, D# t$ X4 |3 l
  
• 
  
  8 X6 u) |5 o" o1 I      r->next=s;  
  0 k7 ]* p6 `! [" x6 |) V$ {$ I
  , ]4 }3 s$ X' [' ^/ ^. D8 N4 V
• 
  & U! D. L5 p& d, u
  . M1 s2 U- ~0 e1 m      s->next=p1;  
  7 e7 e* \0 K$ |
  
• 
  
     }  
  . _5 |/ W, O9 |+ }
  $ R5 x% T$ D8 B6 }
• 
  
     else  
  % w5 M, U8 d: W7 [
  
• 
  . @  y; m; }; y: |& V
     {  
    P. W% d# }7 m, b; o1 I
  
• 
  
  ( ^7 s8 _9 Z5 a& ?5 b      s->next=p1;  /*否则插入在就绪队列的头*/  
  ) i! b5 n- E6 i9 i9 K
  
• 
  # ~3 T; p* z0 x6 }4 v0 R/ @1 \
    D2 e( [+ p  U. t+ Z      ready=s;  
  % D: `4 @, a  l2 Q$ p/ U; s& @# n# b
  1 C' @  _, t7 j- R, e
• 
  7 P$ P: {5 [' m
  " \+ |' L- a1 R9 _   }  
  
  
• 
  
  }  
  ( F# V3 L* e- D+ K' P
  ' T6 E9 ^5 G5 c1 O* w, v$ P
• 
  2 g$ \+ o/ g2 W3 i7 f( w1 r
  /*优先数创建初始PCB信息*/  
  
  ' M. ]% E4 A4 {2 m) H+ R7 \1 `
• 
  : O4 w# v; w5 n+ z
  void create(char alg)  
  : ]+ c" v9 Z% H2 K8 @# g
  # ~7 l- v! F. d% H
• 
  " h" |: r& X1 b9 [
  {  
  
  & G$ Y0 |7 }8 l5 ^0 v
• 
  4 i7 }4 r( ~) Z1 Q, ?$ r, L  u
  ) Y8 I8 x: M  j, b" y0 n3 J/ F   PCB *p;  
  * x" @6 [* N6 `4 M* e% T, E
  
• 
  6 F6 ?1 L+ Q! K
     int i,time;  
  
  8 a2 m6 J+ [- Y, z  W7 D% G; D
• 
  
     char na[10];  
  4 R' i# x+ s$ l; N8 G# D  R' T
  " o) w' u# ~( W4 V& [4 [
• 
  ; \! v( W6 I. p7 v% [8 l! K6 y
     ready=NULL; /*就绪队列头指针*/  
  ' U5 r3 C0 t; n! s. {! v
  4 b0 f. @6 [: \+ q* `$ m
• 
  
  & E! P- f3 Q; P& g0 [8 i   finish=NULL;  /*完成队列头指针*/  
  0 F& o1 u  ~, ~1 n8 K( Q8 Q
  2 ?' d' u* j' |# S
• 
  
     run=NULL; /*运行队列指针*/  
  
  
• 
  6 E$ A$ q( l. V+ b0 |# |& T5 S
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  & E0 d6 n1 i; R: [; ~- W
  ' B6 q1 |' Z/ C) V. E, d
• 
  
     for(i=1;i<=N;i++)  
  ; X/ b8 d" x$ V0 `
  
• 
  5 I" c+ h5 Q( G2 z- u
     {  
  
  
• 
  - e$ q# Z0 [8 F; @9 A: K! Z) P& }5 k9 g* R
        p=(PCB *)malloc(sizeof(PCB));  
  
  - a4 A, V4 I5 k$ V' c
• 
  
        scanf("%s",na);  
  
  8 M6 g0 z( k( {
• 
  
  0 m0 `; q1 `' m, I7 [# p. y, {2 ~      scanf("%d",&time);  
  
  + I) J- m) }' K) s% m
• 
  
        strcpy(p->name,na);  
  - x9 i2 O! e  ^' `- Z
  : B$ o" S  S. _6 q" T
• 
  9 v: ]5 v8 F" K7 r8 f6 l
  4 d; g' b/ a3 y$ W      p->cputime=0;  
    a- A& c* ^  ?4 N! g
  
• 
  
        p->needtime=time;  
  & d, g; [/ f1 T+ L5 F
  ) l* v+ l6 b' r9 ?$ Q$ d  H+ V
• 
  
  2 ?% ]2 T# b  O      p->state='w';  
  + N$ }1 i3 |! f3 O! X
  - ?7 Q" r5 u& W. E
• 
  
        p->prio=50-time;  
    J  Q, I7 u9 a$ k, J
  
• 
  
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  & j/ n; w, ]& q% o6 |& |6 ~3 O
  2 e1 W* B9 r( I  [$ x5 `/ H- ]' R
• 
    d4 U$ ]$ z3 ?  O. K: h
       insert1(p);  
  / j% n: J) |: r+ T+ L
  % c8 E6 c4 o  b0 ^6 V
• 
  
        else  
  
  " I% [/ l6 Y/ Q8 T0 A  {' L  E" e
• 
  
        {  
  
  / |4 Y5 C/ w3 D( H
• 
  5 X, N( q5 _* ]& l. o' L+ K2 w
  $ O1 p. _: S+ F& N2 G( v6 ?  a     p->next=ready; /*创建就绪队列的第一个PCB*/  
    v) n' E0 P# x
  
• 
  ( G9 E- T' `# L  R
  # d/ O( \" k, v4 i     ready=p;  
  
  5 {6 H3 I* `6 p3 R
• 
  
  : W$ u9 d; k% r% e6 w& F6 Y7 x( F- P      }  
  
  : H( A1 @0 _7 f
• 
  9 p) O! Z- ~& D: S4 v
  " V- V, H* D  A* {8 j   }  
  1 w+ e! _: a) B. J
  ! t1 k; q& F; v) z+ |$ Q7 V/ T" y
• 
  
     printf("          优先数算法输出信息:\n");  
  
  4 }) q; u+ J3 o) v$ O
• 
  
     printf("************************************************\n");  
  
  
• 
  
  4 G/ ^5 f% O$ m' J, Y& a5 y   prt(alg);  /*输出进程PCB信息*/  
  . F" K- a2 G  v9 d+ @# C& H3 m
  9 @8 ~/ |( Y) p+ ^  C3 l5 V% M; v
• 
  
  7 {5 C) b. w2 n% U7 a   run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  ' c' S' j! k& \, l( M, l
• 
  # n- k8 u+ q* |8 P, B4 d% A
  6 y1 J; c; Y/ ]5 D% ], q1 b+ f   ready=ready->next;  
  
  , d7 Q$ a/ R  J9 |) n& n7 S
• 
  3 ?$ t3 N. ~. L7 U! l* l/ Z
     run->state='R';  
  . Y0 `1 A6 O7 x+ j# W5 l3 G8 s6 Z
  ( @6 A' @8 D  b. @
• 
  
  " o: O" F2 m4 n3 z- }}  
  ( G6 p, k2 X6 T' N
  
• 
  & s9 `3 ?9 R0 D- K- s/ B' a
  /*优先数调度算法*/  
  , Q+ |  }- ~1 n# c  [9 ~3 O
  
• 
  
  priority(char alg)  
  : M- ~* K" @  F, ^) A
  
• 
  
  {  
  
  3 Q- k8 h2 o4 F3 w, a
• 
  # p2 E- N+ |* _& b0 n+ o
  9 n  l; ]: Z4 @" N# c3 a   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  6 C, O! @- Y% E( i
  
• 
  
  ( f3 R$ A$ e; A1 Y5 M1 t   {  
  
  - d' e8 E5 e9 `( A4 p4 R5 C
• 
  
  1 B# r7 w2 _0 H- N( H: W& j      run->cputime=run->cputime+1;  
  1 X( N4 T. G* j2 S
  
• 
  8 ?6 a9 `4 E( D
  8 Z) {& b' S& G+ U) O0 \      run->needtime=run->needtime-1;  
  
  3 n0 h) U- E: c& D5 G. s$ ]
• 
  
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  : `; x- a" l4 b6 K) y6 Q% A
  
• 
  ! D. B! r9 o9 A! c! y; }# ^) w
  ! K7 h' _: t% U3 x/ `7 g8 p' T      PCB *p;
  
  
• 
  
        p=ready;
  5 ^2 F! }: y( I: V( O( h
  ) L. M+ w8 h# p2 C/ d, c* r9 F+ B) M
• 
  4 e: v( a( |9 m) B5 g* d5 H
  * T! A3 \/ H+ }2 k- ^$ [- C      while(p!=NULL)  
  
  / V) i, H4 G' N: O- r/ A. @# R
• 
  
        {  
  ; d. P' O. I. u
  9 ]7 s) X# M  ?: S1 s
• 
  
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  9 v. C  }7 D* P9 Y5 P! L
• 
  
  # D5 j5 ?4 q. i  V, |/ x2 |0 g% z+ f& X          p=p->next;  
  
  " _* j% h9 n3 U
• 
  0 P0 h4 }, f9 P9 I4 M% c
        }  
  - A% |0 {; ~* d+ m
  
• 
  ! r+ ]! a) p& ]8 U
  1 |4 Z3 r( p1 K* ^, @      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  6 U' b. r/ c/ R8 g  I
  
• 
  8 r1 J1 H& N1 d+ R1 D6 M3 j
  , F2 \0 h$ _3 M  ~      {  
  ; G5 i  Z: H1 i& Y+ C3 `9 k
  
• 
  
  % Q6 y; E& ]: M! T$ H" a) N         run->next=finish;  
  
    A4 O5 ]& G: Q
• 
  ) f0 k6 i) |3 ^% K; n
  ( u: w: Q1 ^2 `3 }  \1 c' ^$ {         finish=run;  
  
  ; m7 Y: {& i) d5 v& b; Y$ _9 @
• 
  ; F& v8 |4 j) i1 I3 R; E, {
           run->state='F';  /*置状态为完成态*/  
  
  ! v0 ?7 w% o0 v6 u* V
• 
  
           run=NULL;  /*运行队列头指针为空*/  
  ( ?4 G( ^+ L. p. R2 O( J2 x) k
  ) S# i+ N+ ^( o9 z
• 
  - z2 K% V; x3 C) K
  2 M5 C  `: H9 c' T. C# t. C         if(ready!=NULL) /*如就绪队列不空*/
  
  ( e$ V2 i$ X) m7 m; j% i
• 
  
           {  
  ) k8 C( \& J) C0 ]
  
• 
  
  6 P! K  ~( _- _            firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  8 Q9 m4 N3 v7 M7 g! h* U; ~9 [3 ~
• 
  
           }
  
  
• 
  
  $ R. Q" S! F' ]3 f$ P      }  
  3 R$ g: d' I3 A6 b( [
  
• 
  1 k: V) w' g: Y5 Z: H7 k# ~
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  ! v$ T9 C2 l1 x5 s# n0 C8 C
  " ~6 L/ s$ O1 ^9 P# a
• 
  
  0 Q0 q% `4 G/ v5 |     if((ready!=NULL)&&(run->prio<ready->prio))  
  % `" O6 w. }9 h, c, U+ Z$ s
  7 X$ ~8 o% e6 ]5 S! `7 n
• 
  
  1 |2 v$ h) ]/ g' V# j2 w* \     {  
  ( w, u2 j/ m$ i3 B, r
  $ G2 `; C1 i3 _* P" x7 y8 R7 O9 P
• 
  
          run->state='W';  
  
  ! M* q3 X; b- y5 W1 h) J; A
• 
  
          insert1(run);  
    D. E7 i7 X# `: {5 m
  
• 
    z- a# d3 Z! y6 K; m& H
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  2 n5 ^9 `4 O% i, `6 B* Y  C6 e" ]4 H
  ! X1 r( o' z) _     }  
  * {6 F5 K9 P% A) _$ q. v% M
  4 c8 i% D- A6 C7 b( J% }8 Y' I$ z. a
• 
  
  + L: S8 C; B# C5 F2 T# _3 c- M* @      prt(alg); /*输出进程PCB信息*/  
  
  
• 
  
     }  
  $ L9 K2 T2 q$ M. I+ a
  0 @" E/ ~; u2 h6 E, s$ ?
• 
  
  9 R+ I: G( k8 ?6 r, {}  
  
  & c2 \! i. S* A5 W3 }1 w- N
• 
  / t: a% M8 J% t
  - `4 I8 i- d8 Z$ e  u+ G/*主函数*/  
  
  
• 
  + J/ `2 Q+ u. G3 H7 `* h0 s6 t
  main()  
  ) i% @: E( ]4 g8 ~" g: F2 ?
  5 I1 r4 j5 K! M. ]0 N
• 
  
  {  
  
  
• 
  ; N- D( Z8 p# ~- \) ~8 p2 x; S
     char algo;  /*算法标记*/  
  
  
• 
  ) d4 B3 J, ~) K7 k# ?' j, Z
     printf("输入P确定算法：优先数算法\n");  
  
  - a6 o; t0 F) C9 Z4 l: F1 b
• 
  
  6 V8 o. Z/ ~- R  H0 _   scanf("%c",&algo); /*输入字符确定算法*/  
  6 i8 n) m  U7 l
  . x, f4 {% Y( U; E# e
• 
  
  , O8 v  y" h: }) q   printf("输入进程数：\n");  
  - V: K; i0 J3 t" w
  + w+ q. W$ l- u- J! e
• 
  
     scanf("%d",&N); /*输入进程数*/  
  
  ( V, u7 Y5 M+ `5 ]7 p. F1 f. E
• 
  6 ]. P2 q, H/ X6 F+ T4 u
  & i- Y' o( M- R9 A  v; m* H   if(algo=='P'||algo=='p')  
  
  * V$ y# Z# w6 K/ T+ X2 i  B
• 
  , ~+ ]1 |. t: {0 R9 t& d
     {  
  
  
• 
  
        create(algo); /*优先数法*/  
  5 A+ B( `" E$ q+ a3 b
  
• 
  
  - D, V6 {, A. `1 _# ]0 O4 R      priority(algo);  
  8 L* K  ], O6 C2 b! Q5 b
  
• 
  
  ' l, S( C, m: g3 P' l5 ^9 {3 O1 q* G   }
  
  
• 
  
  }
  
  
  , d/ s0 y$ l$ G1 E  _; ~; y

输出结果：
+ F3 K! D, O6 f" |6 k# K0 c

9 [6 t: H8 Q8 @7 ~" ?原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

8 c9 G. p( r3 d9 N+ R6 z
! k8 _* M1 l/ `