优先级调度算法

杨利霞

6 V$ F% V5 Q3 v优先级调度算法

算法介绍
! i4 j' `, r. {7 b$ s优先调度算法的类型（用于作业调度）
$ E# A$ z* T4 e& x( q# }* ~! I1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
+ j8 Z: K( w! V6 i* H2）抢占式优先权调度算法
& ?# c  h% d$ C' c只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
; M' s( c0 l% g) \7 V7 M: p$ w9 r静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权
& l; o; |+ f4 P( C# T% \! U

算法实现

抢占式动态优先权：

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

• 
  ) S% i: J# d. {4 a7 k  t
  4 q* X2 m1 L3 ?# v$ b/ n; ]. r#include <stdio.h>
  # L* y0 {+ x8 b2 ?' h% d
  ; m7 R& F- U' `$ L1 x
• 
  
  #include <stdlib.h>  
  % O( i( u- l) _( m3 S, H0 [% R6 l, c
  7 L5 X# p1 P7 ?, r% F
• 
  2 h& {, k- r" U8 s3 E
  ' d5 v0 v- h" l- g#include <string.h>  
  ! U& `' P' P9 v+ F0 q! m$ d( }
  8 \3 b2 w; y" N  S
• 
  , @' b6 G5 ~3 Z+ ~5 t
  $ \# s: `3 N5 C: c2 E$ Wtypedef struct node  
  $ C: Y8 T6 Z* l% u& _8 c
  
• 
  
  4 V, N1 V% G# m% q{  
  
  " q5 ?$ I' U5 S
• 
  + H$ a8 l2 i+ e. m: a1 Z* _
     char name[10];  /*进程标识符*/  
  
  0 Z* P1 H( W, J0 l6 ?3 K
• 
  
  , T* h4 d$ Y3 i   int prio;   /*进程优先数*/  
  ' B/ S; D+ L, W% d, J5 G. Q. T
  
• 
  7 e+ `. W5 _1 y; Q9 i
  ) r% h5 f; S$ K. n   int round;  /*进程时间轮转时间片*/  
  
  
• 
  - I7 J, }8 L; z( N/ K
  - @9 K) p! A# L: Y" a. u) @, g+ y   int cputime; /*进程占用CPU时间*/  
  
  
• 
  : U& r# ^$ \3 j
  ( x/ W/ ~; v2 b0 q4 u, B" u0 d   int needtime; /*进程到完成还要的时间*/  
  
  
• 
  
     int count;  /*计数器*/  
    E8 R5 d& h6 i3 Y8 S- A
  
• 
  - w6 X6 b" ~7 E& V; V2 C; |
  : b8 b% S" P0 n9 B: \" U   char state; /*进程的状态*/  
  " \" @, H* p3 V$ \" C6 A
  
• 
  ( g+ H* J5 O( h1 I& U+ N/ N
  . S1 g8 w5 d! x) Y' D1 W   struct node *next; /*链指针*/  
  * w7 {- J' y+ x0 Z) V
  " m- ]0 X6 E0 t1 x8 ]& Q2 a  n
• 
  
  ) J6 h  z9 N2 l0 i- m" t/ Z& ]}PCB;  
  : b0 a4 m( R6 K$ ?: h% W# {
  / C! i) C$ a; c7 O4 O
• 
    {) Q+ ~) q, g8 O4 q% v3 K" T
  / _4 k3 q) i+ L  a  G' }% c8 F% RPCB *finish,*ready,*tail,*run; /*队列指针*/  
  % p2 l9 @" q. k- j$ ~3 q
  
• 
  
  3 g  |2 b9 a$ m, Oint N; /*进程数*/  
  
  9 W& y4 Q$ K3 V3 V
• 
  ! S+ x0 E. `) g9 l
  /*将就绪队列中的第一个进程投入运行*/  
  . t& w. v2 M1 m+ J# R5 p
  
• 
  
  firstin()  
  
  
• 
  
  8 R2 F! B5 j) y9 @{  
  . D% R0 E( M2 p3 R! t% K
  
• 
  
  1 ]" |' i+ x/ U! R1 [0 h3 H   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  - B0 X" j' T- s) f+ U- v
  
• 
  / k( ~1 H5 \' r& }
     run->state='R';   /*进程状态变为运行态*/  
  / u; d2 R$ B( J8 l8 H% \
  : |# p  K2 L4 h+ M& [: S8 p
• 
  
  " R* _& \; X1 J* c   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  8 k; c7 a) X, ^% e6 E
• 
  # S- S. H$ L# p! k8 e1 y; S1 x
  - q( j. T! @1 i$ u8 Q6 t* _}  
  ! ^2 c* F7 k* T$ ~% k
  $ ?: }1 x- }5 [3 y5 Q1 f7 F
• 
  4 Z6 ?3 K! V( ~3 h
    e6 }# J! X5 U# Y/ W/*标题输出函数*/  
  
  
• 
  
  void prt1(char a)  
  
  
• 
    ~/ O) C# N" ?0 E' s
  {  
  / D# E- C" _7 W, V. s
  
• 
  . e0 P1 z% u9 z$ a+ X
     if(toupper(a)=='P') /*优先数法*/  
  
  
• 
  
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  . Y/ j$ C6 a+ P" r! o
  
• 
  
  & g; ~2 O- }' d0 n1 A. ?  ]) l' @4 ^   else  
  7 [' C" o7 a1 Y3 Q  A) {$ K  i
  4 T* A0 r0 C2 M" @& _( I, p
• 
  ! ?4 J1 x- z; Z& v( e/ p7 d8 M8 a3 H
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  . k/ ?7 y' j. S
  5 `# T# ^2 {$ H
• 
  
  }  
  
  
• 
  
  /*进程PCB输出*/  
  
  
• 
  
  ' l$ s; b0 k* Q; hvoid prt2(char a,PCB *q)  
  
  ; Z# t: n/ m' Q, z" d. o
• 
  7 I, S! b, N0 o, N
    F) P+ o( j( `/ V# f! B- |/ O{  
  
  
• 
  
     if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  ) b" T; L" \( F
  
• 
  
         q->cputime,q->needtime,q->prio,q->state);  
  
  5 o0 }, f$ E* g$ i
• 
  4 B2 v1 t/ t; g& f) l+ m4 ]8 d0 ]
     else/*轮转法的输出*/  
  
  4 B- m2 Z+ T! @
• 
  
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  
  # A7 K4 X5 h. r       q->cputime,q->needtime,q->count,q->round,q->state);  
    c" l# c3 E6 I9 J8 U( \2 N
  
• 
  4 t( a# F$ r) }4 P
  + Q0 G( }8 Y9 N}  
  
  5 w7 O8 \! i% f; Q! [- F" D. ]# p
• 
  ) {. ~% s4 S. I; A/ s) X4 N# u4 @
  /*输出函数*/  
  ( l( O9 V  q' N: o2 A& G6 S* Y- N
  
• 
  5 Q+ r9 i- ]; N# r$ D
  void prt(char algo)  
  
    H: ^8 v' k- L/ G0 B' Q' F) ]: H
• 
  3 j+ j! i8 z/ }
  ) j# }& u4 M0 D{  
  
  
• 
  
     PCB *p;  
  
  " o1 h, i& t! Q6 z$ Y2 ]9 Q5 y
• 
  7 O$ t9 \, h% I- g% e* [
     prt1(algo);  /*输出标题*/  
  
  ! {' E* |% ^! s$ j6 I3 E
• 
  
  # j- V& X" q) g; C   if(run!=NULL) /*如果运行指针不空*/  
  & @0 a5 W6 x3 N, ]2 E4 `' N
  : X+ B0 l& q5 l
• 
  
    _! p4 R: |* S( q1 H* y7 H4 [8 H      prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  " U! J( l; j, U+ u# r; W# f0 m! V
• 
  
  6 o* Y& d' P& V( [   p=ready;  /*输出就绪队列PCB*/  
  
  - v6 b3 d+ I- L2 ], [  t7 a: p' A
• 
  
  : Y1 t1 y$ r2 i$ Z  R   while(p!=NULL)  
  2 v" ]1 C7 X8 o
  : F0 q" ^% M7 ?; E/ r* g
• 
  
     {  
  1 E% o- H- V& `- C' o1 Y
  
• 
  + g9 |5 _* F% |2 g4 Y( O7 f6 C" _
  % ~( F  t3 ~# M+ T      prt2(algo,p);  
  
  
• 
  6 L* l6 P9 d/ ^3 e- i3 r
        p=p->next;  
  
  
• 
  
     }  
  $ G3 `$ a# \3 ~9 [! s
  
• 
  
  * ?, ]7 z8 c. u: C* w$ ^! n   p=finish;  /*输出完成队列的PCB*/  
  
  # M0 s: u( \9 e& E7 \
• 
  
    N' y# Z; E% w0 \   while(p!=NULL)  
  , z" R7 W- f, \: H
  
• 
  6 d( j+ d$ t- d! U9 ~7 b- L
  / [! M" w2 w: V   {  
  
  
• 
  
  * s+ i8 c) w* E9 ^( W$ C5 U      prt2(algo,p);  
  ! A2 ]  J0 [& \% e' c
  * O$ ]0 A4 L4 i6 E6 T& W
• 
  ( a$ g( C! G/ w6 Z0 T" T1 E
  . p6 ^9 |; Q$ R" A+ d) d8 h* F5 \      p=p->next;  
  
  
• 
  2 A; {+ w, S: l, z
  , X; z# r& j, l. K: F1 [   }  
  
  
• 
  5 y" _  @8 m3 L; H4 Z$ m9 \
     getchar();  /*压任意键继续*/  
  
  
• 
  4 g& O; W6 C6 a4 ^' d  G1 a
  : i, m) z1 g+ b3 J$ z8 P8 [2 z}  
  , \/ ?* h+ g+ n! W& x) R% C
  
• 
  
  ' X' M8 g8 I1 Q" X/*优先数的插入算法*/  
  $ N! C4 r) D- X5 Z
  
• 
  
  insert1(PCB *q)  
  
  
• 
  
  {  
  , e( Y8 A: F2 L9 ~" t) _
  ' j& [/ s3 ?0 B6 H* O' D
• 
  0 b! S- n( y! U& X
  $ x! @2 s: O( k, n5 ?. z* k9 j" W   PCB *p1,*s,*r;  
  
  : V/ J9 }9 _/ ?- c+ `! V; y) K
• 
  1 j- K0 u. F7 m, ^2 C
  ' o1 Q3 L8 \/ T   int b;  
  4 Y7 J' `  c) t1 `- J& w% L: g
  
• 
  
  : B- k( f7 }* e% T3 }   s=q;  /*待插入的PCB指针*/  
  ) u/ N  l$ \. p/ |9 v
    M" g6 e, }3 f& }" h/ x
• 
  
     p1=ready; /*就绪队列头指针*/  
  $ ]" [, g+ C- N' y, X
  3 x% G# p0 e. |& C
• 
  4 W" N# G* u# }7 x5 z9 s2 r
  0 }% R( ?; S5 X( h. V! [   r=p1; /*r做p1的前驱指针*/  
  
  
• 
  
     b=1;  
  # s0 L' {* B; J, S
    x9 S. y4 p0 R1 N& R1 Z, V) {! n
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  8 o& q4 Y! D! G+ {/ s) q  q1 ?
  0 r* |+ J9 t' {9 H9 R5 z  N. E( O
• 
  ' ~( c: U  ?2 D' L1 O4 n- A
  / T' _  S( M; [' |" b0 D8 Q$ y      if(p1->prio>=s->prio)  
  
  1 ?9 Q$ K2 d, {
• 
  4 i. j; R- s1 O- u! _# b2 ?
  6 ?8 R/ u1 M( r+ Y% q% f      {  
  
  0 Z/ I0 n$ ~4 u: i1 ]
• 
  
  4 Z/ W& L( }' s( l     r=p1;  
  
  $ D( d. p+ ?& |) O; A
• 
  ( i2 K2 m+ j5 j9 z
       p1=p1->next;  
  ! H! S7 a' U, b. G- r' q; v
  - B: U; \8 I; M
• 
  % {# R' O% z8 l1 ]/ V; x5 u% w2 S+ e
        }  
  * t* y6 h/ D8 v" t
  
• 
  
  ! E; m+ l0 A' b      else  
  5 o# l* C% N; ?3 {; X' T4 P
  9 T! H# I" f4 Y; z
• 
  : _5 v0 Z0 g) l# `1 Y2 ~$ {
       b=0;  
  
  ' i5 P) j( E4 T" k$ q: C
• 
  7 w+ r" r7 \% F+ B' h
  & |) N& S( I& X: n8 ]   if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  ) N/ z# u7 K. \* {! q
  5 g1 u+ @, d7 V   {  
  " e2 K; ]/ Y9 A; o( R# \; z
  
• 
  
        r->next=s;  
  
  
• 
  
  3 y) v3 }, \- s8 h0 v3 O; e      s->next=p1;  
  
  
• 
  : {9 U. G/ F. K' ^
  5 ~, _* Y1 ?" Y% L   }  
  ; r$ J/ S! D- a: }
  9 Q( h+ j1 {8 N! A4 [
• 
  - ^8 n: z4 |5 S$ N) q6 B
  / }) j4 w; H- I   else  
  
  ! x# Y- }1 y  v# L3 a+ j; @) [
• 
  
     {  
  
  # T" W# A6 P+ S6 ^; ?
• 
  
        s->next=p1;  /*否则插入在就绪队列的头*/  
  
  
• 
  + e) o- ^" _) D. O
  5 X+ X# Y3 q6 t, d2 W$ c- v/ g      ready=s;  
  
  . d1 ^' |8 }4 P( _5 n
• 
  
  6 w0 }3 b* j5 r* u5 G" [7 Z% o; K   }  
  
  
• 
  ! d, [- q6 ]) A; T
  }  
  
  
• 
  
  - v3 e7 t" M# ?* s/*优先数创建初始PCB信息*/  
  
  3 }* B# @9 D3 A* H# o* |
• 
  
  void create(char alg)  
  1 \3 C& ~' Z# f+ i
  7 V1 C& x1 ?5 u. L
• 
  0 T2 i* t! H4 G1 P- V% S/ ~: W
  & g! c5 j6 G- T* g) T{  
  ! s* H" M9 K% a$ L  j# X
  6 i' r; y/ w, w8 |+ t2 Z1 i0 }
• 
  
  8 g& \; j8 [2 u% V7 O+ c* M   PCB *p;  
  
  
• 
  3 L6 K$ G2 y" e. U$ J/ q
  # E  m; |5 x+ f  n1 l# p* D8 V$ s   int i,time;  
  
  
• 
  0 L4 I. ^+ R, p( ?
     char na[10];  
  
  , W! w* _: l& N! h: c/ d
• 
  . |, j% J3 l3 ^1 b7 f
  3 c( Z8 ~6 w& X8 D# d   ready=NULL; /*就绪队列头指针*/  
  ' }7 T  O# @3 I; @7 g3 i$ B% c, U
  
• 
  8 `% |3 c: E- }! z" S! C) M* S
     finish=NULL;  /*完成队列头指针*/  
  
  $ E/ j9 j. ~0 ^+ j
• 
  , _! z* j! p2 ^' v9 x$ `, _
  + z4 z; d6 r( a3 K9 b3 ?4 m6 P   run=NULL; /*运行队列指针*/  
  , _& K& j! T1 H+ |" ^. {# Z4 f% z
  
• 
  . t0 S. |# j! u6 p# ^- u9 c& ~
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  . C% o9 M! T! U* u2 d5 }
• 
  
  9 ?* c1 V0 H$ u3 e5 i   for(i=1;i<=N;i++)  
  
  
• 
  " `3 f! X9 V  H- }! x
     {  
  1 m" A. X5 q# s8 I1 d
  5 K( N* ^8 Z" X9 ?( ~  Z
• 
  ( ^9 A% B" r2 g' P4 l+ i
        p=(PCB *)malloc(sizeof(PCB));  
  4 t+ Y6 f% `% `$ N. d
  9 f" b: o( [  m' \2 r
• 
  
  ; n+ c- {2 W- ^( s3 G1 s( D      scanf("%s",na);  
  9 Q6 G; T* r% w6 m
    O0 |0 S% T( U3 ~
• 
  
  9 M& ?% G* ~) ?/ r      scanf("%d",&time);  
  
  ) W7 H9 H9 m( L2 a
• 
  
  + z6 ?# b/ C) o0 Z: s1 ?/ D) j) ]5 @( e      strcpy(p->name,na);  
  
  
• 
  
  ; U9 p6 b- F9 l0 X4 p      p->cputime=0;  
  
  1 ]. s8 }$ n- n, |8 W
• 
  
        p->needtime=time;  
  
  3 }% q  [1 o) ^( A
• 
  
        p->state='w';  
  
  
• 
  
  " F0 o4 K$ M# f8 T      p->prio=50-time;  
  0 Y/ I2 y1 a( g. V' {! `
  
• 
  $ q; O: O$ l0 \) p. u- f
  ) h& k" E8 ?% W  D) z1 h      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  
• 
  
       insert1(p);  
  
  
• 
  * r+ W7 @2 k1 t' L" A3 r
  " a; [& R' J- p: r/ Z      else  
  
    J4 u, M; q/ _8 O' x
• 
  
        {  
  % ~) h% e& j  h( f" |2 O
  
• 
  
  - a& R1 N' C& a# i4 Q4 g! w     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  
• 
  1 G' F* h( C, B! S7 i5 }7 H# }
       ready=p;  
    h: _/ I* X  a5 w3 y3 z
  
• 
  5 f: i$ A9 j2 `$ y( s
  : r0 A5 U' t+ a- {" \      }  
  & T2 }! c! o- o( i
  # Z& ?9 ^4 |7 S
• 
  8 ?7 g+ I0 v) j7 s
  ) s& S6 q8 z( c& Y- u   }  
  
  2 J3 t0 X) |9 w, G1 w3 Z
• 
  
     printf("          优先数算法输出信息:\n");  
  
  / H0 h8 z$ I# Q5 S
• 
  
  * ]8 I% Q: \. l6 r   printf("************************************************\n");  
  5 `; y; @1 |3 W1 J( F& K0 R( w
  ! A6 E8 _% W) V4 N
• 
  ; y* Z/ E. _$ a- G( M0 `9 f0 N
  ! N1 [: |& T9 F1 z  Z   prt(alg);  /*输出进程PCB信息*/  
  1 j( E- E8 p+ G& {( N
  4 Y- A" r0 L1 G/ [& d" B
• 
  & j4 v- M/ U0 J) c# x
  9 u" [/ C" S( i& D5 U: p  O   run=ready; /*将就绪队列的第一个进程投入运行*/  
  ' p' }& E4 H; j
  # x5 T6 `! H" w5 {3 p
• 
  
     ready=ready->next;  
  
  
• 
  3 ]9 Y; j/ H$ ~4 _  d- U  K4 r
  , O+ F$ Z  K4 E3 M   run->state='R';  
  ' X& O9 Q/ R! v" ~9 S5 h
  " ~9 e) \( ~1 ?
• 
  
  2 k9 c) U% K! l0 ]* Z}  
  
  8 ]. K6 ?* K: W  x9 r. T
• 
  
    X% K% M3 Y$ H, L/*优先数调度算法*/  
  3 c5 c$ A, L7 v  `, H7 d
  / H0 h3 B7 d/ Y
• 
  
  2 c: h: {. w" F' h1 _priority(char alg)  
  
  + D1 ~1 b* u' x! H7 ]- ~. A
• 
  $ r$ u( }- ~9 S9 X
  {  
  0 L8 ^! a  [! z; E: U
  
• 
  
  3 y5 b7 J% [6 z1 V0 _   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
    v' m5 i" b& g, G8 E
• 
  
    L" w# o9 i; g   {  
  
  
• 
  ) J! G" f" J2 v* ~' w( H* N+ D, y
        run->cputime=run->cputime+1;  
  
  : H$ C% D  y* j- z
• 
  * g2 a- p( N, |* @- G) Z. _
        run->needtime=run->needtime-1;  
  2 O# _) J6 X- t: Y  i) _5 v- d
  ; ?& O( ]0 B6 y; e$ f0 B0 f1 }1 b
• 
  4 ~: x) u9 l$ J, w: c0 n
  6 X. B9 z% G5 U' S+ u      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  * T* ]7 A$ @2 Q! }7 O3 b+ x& p0 U
  
• 
  
        PCB *p;
  2 h' b3 ]  p1 Z& B
  
• 
  , o/ @" d9 p& P% F3 a6 V3 j
        p=ready;
  
  
• 
  1 q# n- ~# N# X8 v6 Y* ^6 S
  ' s7 @2 I7 B: B- e# |      while(p!=NULL)  
  
  
• 
  
  4 n  ?' G) m: y; Y% z. A3 o' o      {  
    Q0 m! [! H" ~9 A% E
  3 u# w* Y8 L% o- v$ O
• 
  3 s& W1 G3 o. m) i
  # g2 s  U  Q' U! {4 W% O: D! X# j* ]          p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  4 }6 V. E' C$ [' D% Z9 K
• 
  ; g6 t! k; P5 W1 c
  , ]# l8 }0 n$ f. l) `          p=p->next;  
  
  
• 
  % z9 ^% C/ [6 M8 c% w6 F/ S
        }  
  ) o6 }1 F+ H! {0 D* I: s
  . V8 @( H( s9 A$ L* H; M
• 
  
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  ! C6 I0 |7 L# j) q: i5 ?& a
  ' @+ X' p: g% R4 N5 T
• 
  
        {  
  2 E$ ^' ]+ B2 y1 |( i" a4 R
  & G; l8 |5 A; f
• 
  0 ]( P9 ~9 A. h
           run->next=finish;  
  $ k* R9 [6 ?5 J. o3 G# W
  & b* O8 L6 y9 {: X: n- V
• 
  
  5 t. U% z* i$ ~8 I- \         finish=run;  
  
  . j0 q+ H$ \1 M" i
• 
  
           run->state='F';  /*置状态为完成态*/  
  
  . M8 F4 q4 A6 j; k9 g9 d8 }
• 
  % w, U2 P: X+ ^* m$ F( ~
  2 v5 ^) Q0 R& L( N         run=NULL;  /*运行队列头指针为空*/  
  1 f; j, l3 ]- K7 G) h( {1 o
  
• 
  
  : Y/ J) o' k5 \* J- t6 F4 G         if(ready!=NULL) /*如就绪队列不空*/
  
    E9 I+ A* F# a' w. d4 y
• 
  
  % x3 `; E* B6 v6 k6 Z         {  
  6 R4 n6 V6 W0 ]% {) a
  
• 
  6 w- J, Y( k* @- G5 m
  9 Q( D) ]7 Z6 f. m4 ^" _$ K            firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  
• 
  ; c. K0 F6 Y$ n
           }
  3 Z# D1 _  Y; |) z( \8 ^
  1 H# G6 [3 U; I) @
• 
  
  # m5 k( t5 T. N      }  
  
  , G- K/ r' t; J3 G0 x2 H3 h
• 
  
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  % c: I4 N8 e: u- s8 \
  2 `" _/ I) w1 b8 g! ^/ H
• 
  
       if((ready!=NULL)&&(run->prio<ready->prio))  
  
  
• 
  + ~' x: r% M- d6 z' G' C) h
  - f6 t, s7 ^; L  [$ c8 _     {  
  4 N4 R6 B/ a' s5 }& b
  
• 
  4 Y% i6 t0 D2 p. ~9 S4 ~. ?  Z! y
          run->state='W';  
  & h  S. s# l# n: q, f  f9 F8 i3 e
  5 c, }* w% I5 r. n
• 
  
  0 y8 G5 E/ g! c8 S: h        insert1(run);  
  
  ! M4 u- v1 V9 M% p
• 
  - X/ f  I* |9 W. i% d9 F
  2 O% {- L  x! W  O        firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  4 @- f; x5 `0 g4 r# V2 r2 v# ]
• 
  
  3 z4 E5 v7 R) ~0 G. W% S% M     }  
  5 |* o3 L3 `: r7 i4 a
  
• 
  
  3 a- m# v8 [( o  @8 G      prt(alg); /*输出进程PCB信息*/  
  9 h) L3 m. `6 \' d
  ! J1 \8 Q1 g$ M9 L, C/ X' r/ U0 s
• 
  
  , b, K' [/ q, x9 M; l5 M. W% A   }  
  6 x+ g$ d* V" Z# \; {' n+ k4 d
  
• 
  
  5 b* a3 o- ^+ M2 s}  
  
  3 u4 f7 U. \$ Z( K
• 
  - I  O; e; Y, v4 v0 R( S
  0 @* h$ t6 {* I( H7 f/*主函数*/  
  
  % l; \. l( y; W) X8 D" D) z
• 
  
  ; @5 I+ Q" f. u  Rmain()  
  / G' q. g" Y0 i' \8 S4 j/ ?
  % N2 X1 O2 v3 ?5 D# R0 R
• 
  9 I! z4 }4 ~7 T/ P3 N
  8 F0 r$ j  n  \% i% C5 m" Y{  
  ( [* }, D: \6 O  n; G% }
  # k  l4 R* }7 e3 g
• 
  ! e- r% x- y* W- h  R0 ]7 U" r
     char algo;  /*算法标记*/  
  
  ) @/ e7 r1 Y( w1 ?  |% {: d5 Y3 e
• 
  
  9 Y2 d# J, w& ^   printf("输入P确定算法：优先数算法\n");  
  
  
• 
    [7 J' @- U8 G4 }: N0 r) D6 Y
     scanf("%c",&algo); /*输入字符确定算法*/  
  3 I7 K5 }( O0 _, g- Z; p3 l9 M+ Z- H6 T
  
• 
  6 O  o7 s8 t$ \3 S/ D$ @
  / L- _' T0 o5 V7 t9 }2 [1 N   printf("输入进程数：\n");  
  
  4 P$ }! X9 ~  Z9 N
• 
  
     scanf("%d",&N); /*输入进程数*/  
  
  
• 
  & e7 ^* v" f2 b" U4 _* V
  6 n# a: j, [! o( D  c% G' k   if(algo=='P'||algo=='p')  
  
  
• 
  + {6 m9 Z! O$ a, ], `6 M& W
  ; ]0 u8 T8 `) G+ y5 ^7 |4 I7 A   {  
  
  
• 
  
  1 ]9 [4 t8 P0 b  D0 H) u: b      create(algo); /*优先数法*/  
  - ^1 Q% E6 j8 }3 e+ Y
  
• 
  
        priority(algo);  
  # M2 M4 b; l% G( |! i+ A0 T4 L+ _' \* K
  7 \9 k& V- _8 ?: t# L2 r$ U' g! n
• 
  $ a! o( g: s# D7 I) c1 Z5 m' |4 L0 V
  " a9 T$ K( j$ V4 w# C. H) r   }
  1 p. ~% z6 ?8 W8 o5 }2 w( H7 `" I
  , S+ X0 b, l2 `4 j8 ~
• 
  
  }
  2 p& Z! p7 w$ T
    W; r! D- x2 {& F) D( W
  " ^+ ~/ x+ V/ Z0 e. r

输出结果：
. c' V& O) F5 c! J3 Q. w4 y

( Z9 o6 ]% q+ |原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

" }  x+ J" J; `5 G+ e