优先级调度算法

杨利霞

优先级调度算法
0 T! b8 \7 h7 `, a: b. z

算法介绍
' o. Z' v0 M: D优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
# p2 H( m, E, x- g9 l只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
& U$ L+ [1 X) M$ l" [7 j4 Q1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权

算法实现

抢占式动态优先权：

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

• 
  1 n+ m& n  E# }# ~3 E4 q
  #include <stdio.h>
  
  
• 
  
  ; L% U1 O  {+ y0 r7 l1 w#include <stdlib.h>  
  
  
• 
  
  ! N- k3 B' _4 y1 {#include <string.h>  
  
  
• 
  
  typedef struct node  
  ' s8 P0 l1 |1 g. o) h# C: l. H7 L
  
• 
  7 D( ^3 M+ K6 i9 }) E$ b/ z" l
  {  
  
  # h  J& \. N+ E* V2 d) Q
• 
  
  ) {( [2 h) W2 K* l   char name[10];  /*进程标识符*/  
  4 f8 m, x: |9 {& [
  ! b+ q8 ?5 A% j/ H. e" a
• 
  3 a& q8 J+ D3 n5 S
  9 S  o7 t/ E! ~  f. h   int prio;   /*进程优先数*/  
  ( a6 y: ]1 m8 l$ h) s+ J
  
• 
  
     int round;  /*进程时间轮转时间片*/  
  
  & f: @! P( z' c. d( w  }
• 
  
  ; u- K/ V, [. |9 e( Y- _4 S( x   int cputime; /*进程占用CPU时间*/  
  
  
• 
  % E. i0 p: o. Q. u7 ?3 r% p
     int needtime; /*进程到完成还要的时间*/  
  
  
• 
  3 c0 @6 E9 p4 V
     int count;  /*计数器*/  
  ! O& H4 h- A" o3 G: w2 P
  
• 
  6 G9 E7 }  Z  q% l6 q- |
     char state; /*进程的状态*/  
  
  
• 
  8 v% a2 a2 W! M1 z* q+ W2 f1 h
  6 c  [& G, X0 m/ [3 q& a! G   struct node *next; /*链指针*/  
  
  
• 
  2 ~# x$ Q5 n5 \6 D
  }PCB;  
  
  
• 
  
  , e4 [* o8 ^& fPCB *finish,*ready,*tail,*run; /*队列指针*/  
  # H7 J4 P8 Y1 t" ]/ ^- o& Y. G2 s
  
• 
  
  int N; /*进程数*/  
  ( B# A# R# x* L* M
  
• 
  6 I% {8 O" f0 r9 ]$ Y
  /*将就绪队列中的第一个进程投入运行*/  
  
  
• 
  
  firstin()  
  : [' g: N: p% D6 V7 m
  ' P# w( J' ^1 U2 H
• 
  5 G9 [7 f- c0 A7 u2 x/ d6 @
  . |, c' B4 L1 A) ]) D) E0 I{  
  & O, e- F, g  Z' O" T
  
• 
  $ P: f8 l  t( z8 e$ C
  ) m$ w$ R7 T/ }+ m/ i# C   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  0 m1 |: E# N* W& P9 B! ]- f/ o
  
• 
  
  * g$ Y7 H* r  z6 ?5 G) f   run->state='R';   /*进程状态变为运行态*/  
  
  
• 
  
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  # A8 G& ^9 U5 @: h# M" [) [
  * s7 k7 D1 m# w1 \# d% u7 A' [7 Q
• 
  
  4 J% e9 z5 J, Z8 I) W! F}  
  5 v7 ^" p% g, ]+ {: }; S0 d
  2 |, U, L9 B4 q1 X5 }5 A% P" G. z
• 
  
  /*标题输出函数*/  
  0 T+ C- m% O( o5 l- D6 K
  
• 
  
  & I7 [9 \8 K+ z% mvoid prt1(char a)  
  
  9 Q2 j" o( L6 C$ G* }4 Y6 R3 O, n/ ~. V
• 
  ) ~9 i7 T) ^8 T! _8 s
  {  
    s7 v8 v+ E; F  F- B' H1 Q
  , l3 t) x4 K. f3 o
• 
  * n& `8 w+ f4 o1 _
  5 v8 j7 D2 E& w3 u4 o   if(toupper(a)=='P') /*优先数法*/  
  " [' c* T+ j" ?, O, U' Y2 u6 i1 a
  , e) {2 h4 H# f$ Y* j: v
• 
  ' _5 Z2 b( E; |  R6 ?$ g
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  * M' h% l7 t4 `% I9 Y  i; l7 j
  + Q# C  g1 Z( g. R, f' X( y! j
• 
  ! k" d3 U  k! _& B( h0 U7 x* Q
  $ x' J) T* D# Y   else  
  5 q' ~/ E" z- T! H
  
• 
  + Z- F* O+ t9 s" \6 ~$ Y
  5 c! f- s( j6 J# D9 \3 w$ y! g      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  
• 
  
  3 m% m  |, a( f0 p" R& a6 C% A}  
  
  / ^, a3 @* W( t" t4 S0 p* B
• 
  
  /*进程PCB输出*/  
  ' _* ]2 H) ?) M$ V, d
  
• 
  9 K1 D9 g; u" H  P2 b8 k  f. r
  - h( ]4 M, m7 f- f1 K- X, `3 xvoid prt2(char a,PCB *q)  
  3 T! _) r& ]7 G
  9 q$ Y7 E/ W! J/ r' S5 Y
• 
  
  5 K& p% I9 z2 o0 K- `- K0 f{  
  
  9 J5 }$ z- f7 K( D' X, X1 j
• 
  
  : w% O7 L5 H6 n2 |/ S# T   if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  
  # Q+ U/ ~8 H6 Q      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  6 x2 x7 Y, K# a  Q& r) N5 e! ~7 B! R/ ~
  1 f( |3 ~7 E- C6 ~' f. _% t
• 
  ! L- d# u3 A0 G8 F/ G6 J+ {( B- i
         q->cputime,q->needtime,q->prio,q->state);  
  
  ' a0 l7 }6 y3 P9 X  A1 ]8 J
• 
  
     else/*轮转法的输出*/  
  
  9 H8 T  y8 p2 c$ c6 Q
• 
  9 W: ]; |4 M5 D* J- m
  * E+ l4 p7 W$ K1 T* E! I, h& l1 [      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  & n. D! {. z) d1 j0 l6 m6 r
  9 X* ^" W- G$ ~% W& A
• 
  & w2 L7 C* e: S; P
  2 f( H& L8 |  d1 g' t       q->cputime,q->needtime,q->count,q->round,q->state);  
  
  
• 
  
  # D" x7 W$ K5 k( E- f5 p}  
  
  
• 
  
  /*输出函数*/  
  
  + @" g1 N" `* w* \3 a
• 
  
  void prt(char algo)  
  
  ' e" P, A" }4 |5 Y
• 
  . N, F# p% j  P% i" A% j( K) l
  {  
  
  + q5 v  w6 `7 q2 {
• 
  ) `0 n* s; G% I. K* r
     PCB *p;  
  
  8 \2 p/ j* v# C7 P6 x$ X# k, y+ s
• 
  ; z0 P# ]  n; C3 I8 {. B! f
  ; w' w, q! `- ~   prt1(algo);  /*输出标题*/  
  
  
• 
  1 D3 C" [* U2 B9 U& f& L
  2 K8 q$ \' D% ]7 J) \6 o   if(run!=NULL) /*如果运行指针不空*/  
  " d$ S7 u) c! t
  
• 
  ; a3 a+ h7 A( R2 N( z, p
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  / S) R" d' U/ T, D# H4 c
  * \4 Z# h8 ]1 U
• 
  
     p=ready;  /*输出就绪队列PCB*/  
  2 \) V" _* v  X1 o) H
  
• 
  : `/ R1 _' B# P/ L! w+ o1 l  O
     while(p!=NULL)  
  8 w: h8 ~( N, v3 l2 \% L
  
• 
  0 E8 c1 J8 C/ d+ t- y/ G* n
  3 Z4 _( m) X+ A$ D   {  
  ) h0 b3 o" a; F. w
  2 Q" ^8 J! N0 B$ P
• 
  
  4 |$ N5 {1 f4 N# u) q- C0 s      prt2(algo,p);  
  
  3 T2 C' r/ X- d5 d0 N! _
• 
  
        p=p->next;  
  
  
• 
  * O; ~" c# @$ [7 l  x! y
     }  
  0 K6 s7 j$ X% |' {+ A) U
  
• 
  
  ' s$ g0 W9 }: N1 ~( r0 r   p=finish;  /*输出完成队列的PCB*/  
  : |3 ?; G0 E3 b  B* M
  
• 
  
  . B1 v1 z( M) ?   while(p!=NULL)  
  
  9 ~* N  }  B5 y$ S- a4 {
• 
  " J* h3 R# A9 l% o7 ]3 H
     {  
  
  
• 
  
  ) g! T/ o; I2 O      prt2(algo,p);  
  
  
• 
  
  * R( M& A0 s  M. v5 Z( w- D" q      p=p->next;  
  9 @! g; \6 g, x- U# ], y' h7 u, M
  3 ^0 f  o; l/ P9 T" R& z$ O# L3 G
• 
  
     }  
  % n$ a2 l" W  C* S  ?' F3 u% E3 F
  
• 
  * V* s; Z5 |* R* [1 w8 ?0 W
  2 t$ f0 C9 g8 }, ~" |0 G$ w/ ?   getchar();  /*压任意键继续*/  
  3 j+ U- Z* o5 F, l+ b6 a* L
  
• 
  
  }  
  4 B, N* P5 D3 d& `& C' C
  
• 
  9 p% Y9 ?! H7 S* K1 Q
  /*优先数的插入算法*/  
  
  . `1 l6 S4 g% P* O# |
• 
  
  insert1(PCB *q)  
  
  - _7 p( r" \; _/ j: K3 l+ l
• 
  
  # t/ O) I4 K# }; j- ^" ?{  
  . c7 j# L$ x% B7 A) K1 A
  
• 
  2 e2 U. u5 l: I7 q7 @( @
  # q9 X4 P( h0 J7 e% g   PCB *p1,*s,*r;  
  
  * t5 O+ E' Y$ |( @* @( _* Z
• 
  5 a8 A9 a- h" R2 r8 O! b! m7 V" [0 k
     int b;  
  
  4 ]8 v5 A  I; c) F: J! Q
• 
  
     s=q;  /*待插入的PCB指针*/  
  " P! R9 }- C( A  n: [
  4 x0 B# W. H6 i. L
• 
  
  5 A0 F2 T; p9 c, X! W   p1=ready; /*就绪队列头指针*/  
  
  
• 
  , z! s) v( m" E  F0 l+ P7 Q. p+ d! ~' y+ A
     r=p1; /*r做p1的前驱指针*/  
  
    [+ N; G& [+ U: J3 U
• 
    P2 q4 o9 W! M6 n* u. Z
  / S! G6 K" I  R. I! P4 N5 s4 L   b=1;  
  1 U3 f% Z& q5 n! A
  9 L7 Q* y$ v8 |4 e
• 
  . f( }- b) Q; @& o" N6 H. }. Q
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  - q2 W* y% Z5 _. H8 o4 c8 A
  ! ]. V: [! [7 o0 Z. g* I
• 
  
        if(p1->prio>=s->prio)  
  . Z' f4 Y8 z! j' ^9 R5 |
  
• 
  + T2 x. c6 E& u' X5 f( O1 O: {7 S
  ' d+ `3 @% e2 a/ x* I: _5 A      {  
  ' s- Z* i* V' z5 N
  
• 
  1 Q: e4 l& Y+ S5 r- y: o# _$ P
       r=p1;  
  , D0 Y; v. _1 \5 S6 B* _9 X7 x
    B& [) }. a" U, D  [- ~/ g1 ~
• 
  % b" T, @( Q: m9 S! o7 q
       p1=p1->next;  
  
  
• 
  ! Q% b% Z) T# J8 f
        }  
  % s# p; I2 S- t3 x+ C' U- C
  / c- C) V* Y! j0 q+ a
• 
  
        else  
  
  9 {! j1 q1 V9 t, L5 @# f7 V8 S
• 
  
  ' \- ?4 m% P, E5 D) L# u  Y     b=0;  
  ( T& C9 [. R% V4 }$ N6 B- f
  
• 
  ! T% w. h) g* B! F$ G9 O  L6 q- p
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  0 g0 r8 W& Q6 n, p* O. R: d. v
  4 a/ B% T* N* i   {  
  ( W8 j* S: E+ q1 c' h- S% A
  
• 
  6 N% z3 D* I4 l# s$ R8 q4 l
        r->next=s;  
  
  
• 
  ; a0 x. m) z# G% V; h
  9 m6 E1 u" h* i  K, ^+ `( W      s->next=p1;  
  , E. U; X' i: l4 g$ O
  
• 
  ' ~$ A; ]: t7 E0 _) q
  ! P8 _4 f) i5 A; h- A   }  
  - S0 L3 F3 s! ~& K. z$ C2 k
  + O3 [5 I, ]% V. d
• 
  ( j2 A$ R' n# o3 {
     else  
  5 e- g3 i. s( [% @+ X
    V2 A8 @$ }2 X  j# c
• 
  
  & u' i8 x3 p5 b$ ]/ l   {  
  
  
• 
  
  . R% G, y/ @# b( ^- K% z; X      s->next=p1;  /*否则插入在就绪队列的头*/  
  
  . }+ r: F6 M; h% O, Z4 N
• 
  
  + }0 d9 E' d8 C- m" q  ~) O      ready=s;  
  
  0 y" _2 F+ [+ ]- P* k
• 
  
     }  
  
  # q3 t& O0 C# R# A( S
• 
  
  ) F. r3 b0 \0 E( q; [0 y}  
  
  / H% M8 O/ m) W% t- w
• 
  7 S) ], N5 G/ I; N/ S! B) L
  /*优先数创建初始PCB信息*/  
  
  6 }; z: r: @, A/ f- q7 o1 v: Y
• 
  
  void create(char alg)  
  - O0 ]' _) _4 J& K
  
• 
  
  " K5 U; C5 F* i0 a3 [{  
  
  # @* j, ?8 H# G- [2 q9 \1 N
• 
  3 M# A0 c! d+ O. x1 a
  $ B- s: L0 v$ c( i  N9 `   PCB *p;  
  
  
• 
  : O1 d3 `7 f0 j% v) ~6 m
  3 {- o8 f- D% M7 i8 D0 q8 V   int i,time;  
  & H& o" e, [' c, d# r! T
  ; j. ^* _8 r* s
• 
  : {( l. q# x+ v/ U3 |/ r
     char na[10];  
  : e9 Z% n, @/ `" J+ j, L- ?' M' C
  1 M; h/ q: a, ^8 V5 p( T, u5 m
• 
  + Y3 G# B  _5 o4 U! Z) P1 C7 a4 R
  : N% `! D- ]+ Z. H9 v  D9 A% S$ I   ready=NULL; /*就绪队列头指针*/  
  
  
• 
  
     finish=NULL;  /*完成队列头指针*/  
  
  
• 
  1 m" q, l+ Y( ]+ w7 I; A6 v
  9 J' x' i0 i! ^$ g6 Z: ]5 C   run=NULL; /*运行队列指针*/  
  ; U3 r- s& ~) ^: g8 y) Y+ B
  
• 
  8 m, U* L8 Y* h* `* X& `
  7 R3 g: V6 G2 y2 W; q2 z& z( H$ X   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  
• 
  
     for(i=1;i<=N;i++)  
  
  : ~& @% N+ F* k# t5 N
• 
  
  - F9 v0 R  `1 R2 J8 o+ c# v& F   {  
  7 V( f# B4 w7 T& f& P: Z. d+ j# q- b% S
  % O4 r- S8 q+ z8 ]3 S# D; I! {* D
• 
  : t- Z. P9 [- B/ h7 x
  0 _5 @$ f: @) |  K0 V3 x7 S' ~) \      p=(PCB *)malloc(sizeof(PCB));  
  : b, w3 J' G7 Y5 P  |: ^' w
  
• 
  
        scanf("%s",na);  
  ) s' x+ K3 X, k
  
• 
    q3 R9 U/ N: Y1 ]& J1 ^  S% `
        scanf("%d",&time);  
  7 T. P! ~' u% V7 Q' u$ g, y$ H: _
  - G1 }+ `$ p* i
• 
  4 I8 |6 j+ G  N$ `  }* E
  ' H& D" j: o' D- {; i! @      strcpy(p->name,na);  
  
  
• 
  
  7 T+ r3 E: b6 B  Z      p->cputime=0;  
  % t+ b4 d# B9 Z+ f9 z
  ' k) i2 l% [) s6 M
• 
  1 P) j6 W7 x' \" z
        p->needtime=time;  
  1 E* z* S8 l% W
  9 k8 J0 ]- J3 N! i& Z8 L- U5 K
• 
  
        p->state='w';  
  6 `3 [9 g5 d5 l' z* D
  
• 
  
        p->prio=50-time;  
  ) {$ `: d' n* D, ~
  
• 
  + m* x4 r5 v( B- E
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  ) W4 s# j; D  X( l  P: ?% M
• 
  " }, B- ~8 D: ~- o
       insert1(p);  
  % V' l( e( X9 A8 t& G
  
• 
  
  " W' L+ V( B6 X5 W      else  
  
  1 V; H% a, ]( b3 U7 _& n6 @
• 
  
        {  
  0 F) g* X+ e: E" n% K3 w% X" ?) ?
  
• 
  
  / H* l; P- D  T+ A3 L     p->next=ready; /*创建就绪队列的第一个PCB*/  
  ( f9 V1 {# Y' l
  
• 
  2 P% r& _# U& R7 Q; z
       ready=p;  
  
  # }! v& M2 Q: }$ E3 l
• 
  ' p3 e" N# i+ M  {
  2 ?7 Z: J: ~4 }1 e5 o( a      }  
  
  . v. }3 w4 d" \7 i1 }5 `1 M/ Y
• 
  
     }  
    m# O' |/ O1 V8 z  h: n
  
• 
  7 p- V- }" d% v3 z+ x
     printf("          优先数算法输出信息:\n");  
  * J  d. `! e9 b& Q2 t" G; v
  
• 
  
     printf("************************************************\n");  
  / ?) f1 q: x2 n5 u  B/ \! C, a) R
  
• 
  
     prt(alg);  /*输出进程PCB信息*/  
  2 w0 ]- }) j7 v2 T7 F3 H
  
• 
  
  8 g- S# W4 O/ q& i$ o) \2 i0 I8 ?   run=ready; /*将就绪队列的第一个进程投入运行*/  
    Q$ v9 \' c5 k/ S& F7 Q1 b+ d1 E
  
• 
  
     ready=ready->next;  
  
  * @: b  J. d& d6 T3 x
• 
  8 O" n: c: y+ E) W
     run->state='R';  
  : K4 m  j1 V  u
  + o1 ?* N/ j  m8 m2 o( {  E8 [
• 
  
  % o: D1 r+ U( l* k$ H}  
  2 \" \# ^  k$ ^3 p2 r6 ^+ {
  
• 
  5 K8 h; l- ]% z/ I9 T2 v
  : Q0 P, M4 k# g; h; @# G/*优先数调度算法*/  
  7 h0 Z! j7 o! O( }) E% e; K9 R" \9 s
  7 I. o) j/ V+ ~: o
• 
  & M3 y! X8 G0 g# {) ~
  1 q- T: E3 B/ W9 ~priority(char alg)  
  . v' Z/ S: P& e- w! _( I$ I+ \3 X( Q
  ! d1 x+ w; L8 s: H2 ]8 I* o" b
• 
  $ _! I! ^" g( [7 V% U, a$ c
  {  
  
  % ^  _+ H$ u, @% A+ O0 |
• 
  # o4 f) O1 [4 l' _+ P6 n
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  
• 
  3 K# E# s0 H- X/ i1 A
     {  
  & {8 }, B: y2 \# f2 E5 E  W, D
  ' n3 c/ S5 _7 U& u* m! T
• 
  
  0 t1 {* [9 c1 V# M$ ~7 m      run->cputime=run->cputime+1;  
  - |- C5 T4 G/ f. w0 q+ t' }
  
• 
  * I$ g, g- L) X! A
        run->needtime=run->needtime-1;  
  5 @8 H# E4 T$ _9 y! H9 i. F
  " l8 R+ p" n( o  |
• 
  
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  
• 
  
  : q. O# F4 g' }5 r" }      PCB *p;
  . {) w5 S8 P0 s
  5 B5 g+ K3 N6 N/ {
• 
  
  ; A2 g4 o$ @0 r4 u8 N- e0 i4 N- j      p=ready;
  + P' t& Q; d# _& Y
    P9 U4 `! C4 Y! [1 ]2 M9 w1 {$ X8 y1 i
• 
  
    J2 R7 B& j2 S4 ]      while(p!=NULL)  
  $ c7 }1 m4 T+ L+ w- Q5 _
  
• 
  
        {  
  % ^5 U; m8 ?; c* \7 \) _+ o
  . a" Y8 `0 T6 R% g7 {8 j1 m+ X+ |% X
• 
  * _9 O1 O% w5 F7 O* W% Z1 [
  8 J& D& J& A% j3 X9 k  v- N          p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  ! K* K6 y* @# v: Z$ e
  
• 
  
            p=p->next;  
  : g: y* G8 S# M% {& |' g3 t
  
• 
  + `6 @% s& n& k8 V1 O3 N
  " a* [0 n: f3 f      }  
  , g9 z. F) e3 f: W, ^" \
  
• 
  ; ^! O3 g6 K2 c# u
  # A# e# h) ~5 [! v; W( t4 f      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  
• 
  
        {  
  
  
• 
  
  ; j( r3 c8 \: }% D         run->next=finish;  
  % x6 A( }6 `* v7 Z/ R( X
  
• 
  
  ( F4 l+ L0 u& ?$ U1 Y         finish=run;  
  
  
• 
  
           run->state='F';  /*置状态为完成态*/  
  
  
• 
  
  # F! B0 a7 f' B; g4 O         run=NULL;  /*运行队列头指针为空*/  
  
  
• 
  
  ( X# D& o0 N) _" q: A8 ^" w         if(ready!=NULL) /*如就绪队列不空*/
  + S! L! p& G& r: k1 C6 D
    t( j8 O: g/ Y, ^0 q) t7 A4 Y; }
• 
  
           {  
  # p" @5 `7 L6 Y
  * Q, z8 L, s1 G# t6 |7 s
• 
  
  8 z0 C! v" z$ k8 g0 a0 ^/ W            firstin(); /*将就绪对列的第一个进程投入运行*/  
  1 R* u! w3 E% ~+ c( m9 _3 l  k; _& ]
  
• 
  
  ! R' D4 t: D5 D$ x8 N; \" J         }
  5 R5 E  w' e1 V" N' p
  " H* q6 G, \; r$ ]! k" ~% T
• 
  
  2 o6 ]5 w! X5 _0 N      }  
  , B! z# D0 K2 u7 T" K5 d$ K
  
• 
  0 N) V& |3 y: _4 o4 ?3 r" Y
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  - v0 V: i' P# T" f9 W1 y
• 
  
       if((ready!=NULL)&&(run->prio<ready->prio))  
  ( \  R& D1 u, k+ z: }7 S7 v& X& @
  # ]5 I: R1 S7 T" l
• 
  
  $ s+ {% E7 o/ `' O- a! x& i: o* E     {  
  
  
• 
  
          run->state='W';  
  " R% P$ o# M- {6 i& N& y
  
• 
  
          insert1(run);  
  : Y' T- W4 p$ H+ }8 q  T
  8 ^& Y$ j- H+ n2 q
• 
  
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  4 E4 F  v! _7 Y
  0 k3 v" u" t. m* V9 c1 U! t4 g6 L
• 
  + }! `4 B( s% a  i5 v
  # s" c/ ~% R1 f' t" Z- ?, H     }  
  
  
• 
  
  1 M" T1 ~  c: o. v, C      prt(alg); /*输出进程PCB信息*/  
  
  2 j$ f! W6 g; C, V7 g) z
• 
  - J0 }2 k1 C; F6 `
     }  
    Q  U' n* P1 O. O
  5 h0 w% |7 N* p) g% x8 b
• 
  8 |. K$ r5 H+ i' |
  ( o/ P8 K  n3 y; G5 Y) j}  
  
  ; L: p1 J/ G0 F: A5 I2 D4 U
• 
  
  % p9 G# y+ d' w  h" W5 `! V; @, j/*主函数*/  
    B- a! M3 a, m
  
• 
  ; Z7 ]. o2 S1 y% W4 c, C6 A
  4 k9 x1 }' F: f9 x/ ~main()  
  
  ' `( p8 k$ T" H/ I# m
• 
  
  {  
  9 V; Q9 F' I9 g
    ^/ z  ~$ F- e, @% X
• 
  / |( C& m, l# ^1 W+ L5 U
     char algo;  /*算法标记*/  
  - [2 E7 R7 O+ u0 c3 A
  3 R  N$ t. E4 [& t
• 
  " A* @3 y. F- J
  ( p3 u) }) [5 Y0 R  U% X   printf("输入P确定算法：优先数算法\n");  
  
  
• 
  & C" ~8 a3 S. `
     scanf("%c",&algo); /*输入字符确定算法*/  
  8 G& V, J5 }1 a
  6 u  N# g8 W6 O. a8 `7 V
• 
  6 |: e  S0 `0 C# {! P; l7 G3 _
     printf("输入进程数：\n");  
  
  
• 
  7 x) X1 V8 O9 b) i) z0 s' M$ }* Z  `  W
    X% I3 z0 U0 `, m7 m   scanf("%d",&N); /*输入进程数*/  
  
  
• 
  
     if(algo=='P'||algo=='p')  
  / i2 |0 K4 [' M
  - D; e8 Z7 a, X2 y& _% ^$ f
• 
  ( V7 t) M: B- V
     {  
  
  
• 
  
        create(algo); /*优先数法*/  
  
  & o' B5 Y  t7 f) `" g& q
• 
  
        priority(algo);  
  
  
• 
  ; y3 u% N; m0 ~2 w; A% f
     }
  4 x4 w8 I2 c0 l2 {! `* A' F
  0 v. e2 V8 ?9 q- l% [0 j
• 
  
  % v5 ^' C2 \6 r4 R) c" G! }}
  
  " _& K8 X* N+ z+ Z/ V' Q
  " ~9 G# _6 G$ J) n  b

) u' z( q, B8 G输出结果：

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

! M; m/ {5 F, r* s/ Q8 e