优先级调度算法

杨利霞

6 Y- s0 J& u" T6 l; C( @8 \* W8 l优先级调度算法

算法介绍
' y( E( C3 i9 I+ g& N+ W. _优先调度算法的类型（用于作业调度）
0 N/ w+ b; v$ ~1 ^/ e1 N1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
3 w1 p3 d& m1 Y& P/ Z% F2）抢占式优先权调度算法
! O9 B- _& P6 d0 J只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
# W0 _5 Y# O  ]) K# f9 a, p1）静态优先权
6 W9 B% Y( v! \) N  f0 D( A9 |7 |静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权
( Q# P5 f# @  {2 O3 F! t

算法实现

抢占式动态优先权：

8 C5 _' O0 m  b+ K+ b0 Z( iPS：本人认为非抢占式静态优先权没有实际价值。

• 
  * E  _; _* R" m: y. h  r
  " [8 {! M" `& p$ J4 x8 W* T#include <stdio.h>
  
  & w0 i( [2 {9 C2 R
• 
  
  #include <stdlib.h>  
  0 L/ _* x) U! T9 C
  0 t: a. O7 z( a3 N
• 
  
  #include <string.h>  
  3 x& I0 V9 ^8 R$ F7 f& [
  
• 
  
  9 [% C4 z7 ^5 X# o) T& V! u% t5 Ytypedef struct node  
  7 c* ]- h" K4 |0 ~$ t% n
  5 ?1 o; q3 z1 b  ~5 c% r
• 
  , a+ q  f; T8 S
  {  
  " E5 L0 W4 u9 {
  8 f" _* Z; |6 ]1 Y- d
• 
  ! P5 Z4 H# R, U* U0 r/ R
     char name[10];  /*进程标识符*/  
  
  ) q3 r: E* }3 D( \8 A5 {
• 
  ) C% D, s; b. v! w, a3 k
     int prio;   /*进程优先数*/  
  
  1 V3 x: L! Y( N& s1 f. g+ ]( i
• 
  
  & C5 ~3 N% ?& g   int round;  /*进程时间轮转时间片*/  
  . g; K% Z6 U5 [; w; W4 V8 g
  2 N2 q: K+ ^' _/ {4 r7 _
• 
  1 [1 `9 s1 k- a- Y! {; a) F
     int cputime; /*进程占用CPU时间*/  
  1 q. M, X1 ]" q' k+ y$ l( X/ D& p4 a
  
• 
  2 u" C9 a+ L* F3 R2 X
  # E. S. {/ U4 n7 a" Q" x% F' m) J: p   int needtime; /*进程到完成还要的时间*/  
  
  4 i$ B3 s- n) v' c
• 
  3 D( W2 @. d, S6 g! L8 P+ y$ Q
  * v: A6 y+ U2 }" L   int count;  /*计数器*/  
  
  . n- Y2 X! D) z5 U
• 
  7 x$ ?2 ]  C6 P: k1 b# r
  " T/ k0 M+ M2 F& u7 I$ z   char state; /*进程的状态*/  
    O6 v* S) W9 \
  
• 
  
  / Y6 Q' w" P$ T; I   struct node *next; /*链指针*/  
  ; e. x: g6 u7 f. g& t
  1 j* L  O6 m; C! j( ?# E5 _
• 
  
  }PCB;  
  
  % g  b8 d- p; O/ J! e
• 
  , W; C: s4 ~0 F& _% [
  1 t' X# V/ @& t- Q" iPCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  ' Z4 u% h. b* ~
• 
  6 w* z* [' U. m
  * X  J' v7 w- vint N; /*进程数*/  
  
  
• 
  6 ]: L# O% u) k
  /*将就绪队列中的第一个进程投入运行*/  
  
  4 a, H( @! e% X8 S0 f
• 
  
  firstin()  
  
  1 C% o8 S: Y1 t+ }7 M/ ~  ^
• 
  * q0 \2 R- _6 c
  : y+ d& a! h- r* [$ m{  
  
  6 n# \$ {' f5 ]/ [  J* v7 n
• 
  ) E4 ]' v0 |9 @6 l
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  - @9 [* _( r  d$ o5 F% U4 W
• 
  * x2 ]! p9 G5 K( k
  ) b* z2 w# B! K6 g+ j   run->state='R';   /*进程状态变为运行态*/  
  
  
• 
  
  3 _5 Q# F9 g* W: H: q; [   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  , u$ g; ?9 O% ~4 U% V
  
• 
  * ~6 F$ `7 V; |, t( g- r
  * F- i$ N$ b  u9 m# R: I5 W}  
  
  
• 
  
    K- W- j7 j5 J7 i3 b4 t. Q/*标题输出函数*/  
  + ]9 d( b& F; D6 d9 U1 Q6 V
  % W$ a" a4 h% g. @) R+ u
• 
    @4 J! D- |7 g% U
  void prt1(char a)  
  5 s4 {0 p3 [5 E" Q5 Y: {+ y/ w; S
  7 f. J/ z! ?, k  x( A
• 
  
  {  
  
  # V) q/ n9 |1 h
• 
  3 c( e$ m- Q* N
     if(toupper(a)=='P') /*优先数法*/  
  
  1 v, z6 l! e" s  u2 y, a( q
• 
  
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  4 o$ t! A2 |) K2 {  [
  ( c1 k2 P3 h0 E+ n
• 
  
     else  
    S' \6 q- [4 n' F
  2 o7 X/ w2 e# d% X8 ]
• 
  
  2 B2 u* |! c8 [$ }' `  b% b0 \      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  # P$ v% Y# O9 L1 A
• 
  
  6 e" }% q% b" |. I4 v# x, u8 V}  
  + Y- ~2 {) p# t5 C
  
• 
  
  $ r7 F  e& I  X" q! ]2 Y/*进程PCB输出*/  
  
  
• 
  
  5 @3 i3 A' I) _3 x0 Gvoid prt2(char a,PCB *q)  
  - e& g8 s9 J9 q1 X$ D/ W
  
• 
  
  {  
  . O8 v9 S- R/ ^3 I
  
• 
  
     if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  + K4 o6 y7 N) M3 j( s4 I& b
  ) }& i  o. t- h& k
• 
  4 l5 g) R5 N% ^
         q->cputime,q->needtime,q->prio,q->state);  
  : z6 ?3 q8 G3 j+ d7 }3 k; P
  5 J7 O) Y2 w, R9 N# [' M
• 
  , ]+ ~; S& e7 I1 m1 l
  / F3 J5 I  f2 p) {% j4 n8 ^& S   else/*轮转法的输出*/  
  * R* |" V8 Z$ _9 y
  
• 
  ; H' t( C0 F. c& c* j+ X) W
  5 I1 Z/ X- K9 T, n      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  & [$ L; I8 f' C  M
  0 F7 [* ]. g- W0 }/ B5 M, l4 X
• 
  - a4 F# D; a  x. ?! p( ~
  5 O* V/ F0 g$ r. x2 X       q->cputime,q->needtime,q->count,q->round,q->state);  
  8 s! z  G! W3 r/ _( c0 L* v
  5 L4 T) a1 Z; G1 e$ Q) m
• 
  $ x7 N; |! W# K0 T5 S
  }  
  
  6 J) J! E0 ^2 W8 p  F4 u1 k
• 
    a% a) w# J3 J+ `! t
  /*输出函数*/  
  
  
• 
  
  ( z$ z2 q! b1 g! P0 k- zvoid prt(char algo)  
  
  
• 
  
  {  
  
  $ x" O$ G6 C! K
• 
  
  / P* S1 a$ O2 I8 l7 b   PCB *p;  
  ' \" P7 b  K$ A$ M4 N" H, Q
  
• 
  ; M* _6 V3 c# N: E% f6 n
  0 K2 q4 ~& Y; V8 g* n  U( X   prt1(algo);  /*输出标题*/  
  3 B( q1 b& {1 ]
  3 g" t5 I' U) [  |* ]1 V
• 
  . t0 X9 q- L4 J7 {! c
     if(run!=NULL) /*如果运行指针不空*/  
  
  
• 
  
  : m! j- f+ Q. ^- M; }6 u) t      prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  4 V* [# n8 \$ x2 I. \
• 
  / H  i& f7 G0 [4 l; L+ _* n
  5 a8 B, }9 ]) l" L   p=ready;  /*输出就绪队列PCB*/  
  % j! n$ T- j' p2 l
  1 v/ q. |* ]7 y
• 
  
  8 G- A& V; U. H; n+ S   while(p!=NULL)  
  - m0 }$ U6 E+ R/ m( J3 _9 A1 F
  % p; K# u( R7 o4 d- v
• 
  
     {  
  
    @& I: U1 ]/ l& B' s
• 
  
        prt2(algo,p);  
  3 v& l) ?0 r. e  u% ]2 G
  
• 
  
  % C9 ^9 E" N; ~9 C5 j      p=p->next;  
  
    \3 t9 [* O  Q( n, z9 Z
• 
  7 c) f5 ?( P1 q, Y9 o
     }  
  : _/ l8 e: {: v3 Y! M
  
• 
  
  8 J* {% `( t% W6 L/ G   p=finish;  /*输出完成队列的PCB*/  
  
  ( j' Z+ p( b" x3 _+ h, X
• 
  
     while(p!=NULL)  
  7 V! \& W4 t% S4 Y
  ( K. w8 |3 B# w' z
• 
  : }" k: |6 j& M/ f2 k5 h
  1 c6 U2 e- b& L$ \7 v9 c( X3 D& F   {  
  
  7 o! }: O+ b  n, w
• 
  
  & e; G' {' j4 D: W5 t% J      prt2(algo,p);  
  
  
• 
  ! m- A! ]% K0 Y0 J: W; l
  + M3 B  o3 c% G" j9 R, n+ e( M      p=p->next;  
  
  
• 
  
  + U4 M' O+ q$ F+ v  i# G2 Y   }  
  
  
• 
  
  : t) s- Y7 z& A% P. m' v   getchar();  /*压任意键继续*/  
  
  % A. T" P6 E7 E# o9 \
• 
  
  : R0 `4 f$ B# z7 |" b6 Z' v- c/ A) R}  
  3 V  l! i$ E  d# ^+ _- ~2 {
  8 x0 r. U2 i& Z2 Z/ ?$ ~
• 
  7 D9 @7 b/ B5 c
  /*优先数的插入算法*/  
  
  
• 
  
  * U. b9 }. t, M- p# @+ q7 c  Iinsert1(PCB *q)  
  
  ; r) ^7 L) O- k9 ~" e9 F: \9 _
• 
  8 @' \6 t) n9 @# _# C+ B4 W
  {  
  ! N3 N1 z; x1 |! n
  
• 
  2 b: @* s3 @! K' N
     PCB *p1,*s,*r;  
  4 z. C3 i7 }, k$ z. _& o% @7 F) [
  
• 
  
  * m& K0 q% G) a   int b;  
  
  
• 
  
     s=q;  /*待插入的PCB指针*/  
  + g9 v, _. c  _# c
  
• 
  8 I3 b4 G9 T! t" x# x
     p1=ready; /*就绪队列头指针*/  
  
  . a) G- w' {7 }2 S
• 
  % Y3 K! R7 }# f! n! f
     r=p1; /*r做p1的前驱指针*/  
  
  
• 
  
  $ U# j2 ]- T9 N! v: r' v: \% |   b=1;  
  
  / a: k$ T; [! Q" _7 G& q3 u
• 
  4 ~" ^2 ]4 K- Y
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  ! ^* ^) w3 m# \1 j8 f9 E
• 
  
        if(p1->prio>=s->prio)  
  
  0 H, O( Q/ G( s1 x1 G) D
• 
  ) S* r" R5 Q/ m6 V' ~( T8 [1 n
  2 }) b" N& U1 R0 o# u& ~9 I5 z      {  
  8 n3 n/ k9 ~  o& \% F
  . K3 i& y5 t* V5 C/ N
• 
  . @8 `& Q: B0 |, |
  ( Y# v3 K" T3 M8 u3 N) R( ?2 I     r=p1;  
  ' A; E  T7 }$ o! Q. n, X8 v& i
  
• 
  
       p1=p1->next;  
  
  ; v9 N6 t, @! g
• 
  6 g( _* L2 u5 X3 @
  + m% I- `; \9 p      }  
  * C# n. ^' b! T, \: g
  ; f% @% |0 \7 l7 c2 U$ Q2 S
• 
  
        else  
  
  1 i+ u4 j1 v" A
• 
  1 r3 q  o: G7 s( B2 `
  8 Q- _% u# H% s: x) u7 _0 j! `( G     b=0;  
  
  1 [) ?5 o- v/ u
• 
  9 D: O) m; P8 Y2 h) u0 Y; G4 s
  5 i) v, m  X) T7 U& `0 o   if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  2 k6 U# M) A$ q
  
• 
  , X% `7 e0 P0 G% q+ i" U
     {  
  0 b5 _% w- B; d
  
• 
  
        r->next=s;  
  : y7 S: Q0 Y9 @
  & Z6 A+ x( [1 ~9 c
• 
  
        s->next=p1;  
  2 {' M( y: n0 j4 u9 K+ Z2 r
  # C9 R' A4 T( h$ b- b0 q0 `5 f
• 
  . r* m* `/ y+ G
  : |! C6 f# O8 z   }  
  
  
• 
  6 H! l+ {/ X3 {7 Y
     else  
  
  % [0 J: N+ {0 Z2 C; ?% I
• 
  , U7 u: w' S- J% [3 D7 k7 P
  * G5 z. V* _( W& T* S! {; e2 ~   {  
  # P1 f2 Y2 U$ o4 @/ Y
    G2 a; r4 g: q
• 
  : K% S' d7 o% }- S3 g
  ; H2 y# W  v2 v5 q2 v; c      s->next=p1;  /*否则插入在就绪队列的头*/  
  ; B3 G' F( ^( u8 i" H+ B" c* C. w
  / Y8 A: K6 e, P
• 
  
  ( b$ u, y' U% s4 \      ready=s;  
  ) T/ {% t, n7 k- B4 v! x8 _2 c; g
  % U& F! J6 F, j1 c, q8 J3 r; O
• 
  - N/ {3 i' @1 s) ~" G5 c: S
     }  
  ' `/ ~- V$ n  {  ?/ D- T
  
• 
  
  ! g$ f# U7 [0 c# O0 [2 E}  
  
  
• 
  2 Y$ a& F& M; \$ X* H; g
  " e: z4 I' ~- t$ [3 Q/*优先数创建初始PCB信息*/  
  " G2 U7 @; J- _: I, |* P
  0 E3 e. Q& ~8 T& R! l
• 
  - j5 k& e8 E$ L0 w
  void create(char alg)  
  " n( P( p: R) M+ Y
  ! W, K6 J) Y4 A
• 
  ! h# w# ?. I0 V7 _
  3 l" y3 t. A/ x! U{  
  " X- L+ U# D# ?2 g
  9 X2 C. n- H4 x" u3 V9 |' }
• 
  
  3 [6 [0 Y9 A6 h  A9 P   PCB *p;  
  
  
• 
  7 v+ ?$ n6 _/ m% O
     int i,time;  
  * a0 N* i3 \" B3 Q
  
• 
  : R. A4 W$ I# i$ W$ u
     char na[10];  
  
  
• 
  ; y5 }+ G/ W& ]. P! q& P; G/ o
     ready=NULL; /*就绪队列头指针*/  
  7 S/ T3 a+ V; Y0 ?. k0 a
  
• 
  * ?  \% t8 [, P, k, a: v' i
     finish=NULL;  /*完成队列头指针*/  
  ! s7 a. S$ J" q% `* C
  4 O# s* Y: T+ h% P0 \
• 
  ' [# Q2 G6 \. x+ P
     run=NULL; /*运行队列指针*/  
  
  
• 
  
  ! P4 W  s# ]: C# ]4 _- C: t   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  : T2 U! w- d4 e+ r9 }% R3 M
• 
  % K' p% Y1 n7 d& _
     for(i=1;i<=N;i++)  
  
  
• 
  ( c: N% f) ^0 V/ n: Y9 {
  9 g# g7 s* s* F' [   {  
  0 ?/ x/ q2 w& O  X/ ?
  
• 
  5 v5 l4 Z3 y5 c2 w/ _- M( X
        p=(PCB *)malloc(sizeof(PCB));  
  
  
• 
  
  $ N7 d9 l$ R- k: G# c      scanf("%s",na);  
  1 e: Z* \: A. w4 \" Y
  - a9 S6 W" y5 R- {, [) _; W
• 
  : [1 ^7 ]/ w9 q8 R
        scanf("%d",&time);  
  ; A$ p3 k4 w: N: n0 T% w% h8 r4 F
  8 p% P8 P( D0 }7 N* u
• 
  
        strcpy(p->name,na);  
  
  
• 
  
        p->cputime=0;  
  # b) p8 J- }* N$ s: ^
    X) V: g# [# J. O# O/ c
• 
  
  5 ^4 h% Y$ H4 P8 d$ ?      p->needtime=time;  
  
  
• 
  ! U* w+ F8 p( K* U$ o# P- I1 m
        p->state='w';  
  % W/ d/ U8 b" ]) F/ L  j
  
• 
  4 \0 \; |6 v: O  {& b' \
  * s! d. ~, a6 h      p->prio=50-time;  
  3 u: a: x$ ?. O
  7 L  I6 v% {) h3 P5 z# F
• 
  - Y/ [2 v9 L/ E7 j+ {9 c' D7 U
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  3 |+ a5 ?  t6 \" m
  
• 
  2 }* p) ~6 P' a% _$ p& Q
  ( y: L) t6 s' v     insert1(p);  
  
  , d& @8 D5 p( a5 E! K1 K2 Z
• 
  
        else  
    _0 T% I% D7 G# H; U
  
• 
  
  # ^4 J" _" F) _) H# _0 u: ?: _; y      {  
  ' Q/ ?8 p4 b5 p  \0 O
  
• 
  2 G# F* R+ A  r) N: N# y, K1 n
  * C5 U9 I/ x  I( a     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  # n0 {, p) t9 m. R8 I0 k
• 
  ) V6 `1 [! h, J
       ready=p;  
  
  9 ?! |, K$ ~: t+ O7 J* h1 A# N: _
• 
  
        }  
  + {7 r8 ^! q; v: {# e& F  x
  
• 
  
     }  
  
  
• 
  * Z/ c6 H9 v5 B& T6 t. d, d
     printf("          优先数算法输出信息:\n");  
  2 H& @" Q3 |% @1 X, ~% {
  
• 
  
  $ R) m1 q4 ?% j' d/ j, |: g9 ^   printf("************************************************\n");  
  
  * o+ r% V1 g: _/ ^* o- |3 d
• 
  7 ]) k6 r7 _( l# R: a! o' U
    W6 S+ w. @% s- |   prt(alg);  /*输出进程PCB信息*/  
  
  
• 
  
  % J0 X- t+ c; r1 I4 {   run=ready; /*将就绪队列的第一个进程投入运行*/  
  $ P  H0 d1 }3 a1 w2 z9 O
  , l$ d3 i6 G9 ^2 h$ q
• 
  
  / h) w# l/ V' h* ^+ }   ready=ready->next;  
  
  . \- A  V7 \! v: m, M5 c; @
• 
  8 w1 L) \/ d( a5 {3 ]7 _2 H3 [1 s
  9 {/ c! |3 I" Q& o  o2 Q   run->state='R';  
  
  
• 
  
  }  
  
  
• 
  
  ' B* h- y7 S, @: f: E( ?/ G/*优先数调度算法*/  
  : i* A2 x3 d0 E2 @3 f4 j
  
• 
    S( M2 X+ J1 r2 O* K
  9 Y5 C( ~- Q( U6 Apriority(char alg)  
  
  # e9 H' F2 X, ?* ], J# F/ E
• 
  0 i5 Z! b7 s9 v8 G7 z# B
  ! R( B# W, Y" d3 [7 t{  
  
    q" Q0 |& U. `4 Q
• 
  
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  
• 
  
     {  
  
  2 B* [+ f! [( C6 I8 v7 s8 }
• 
  . E+ K9 h( V6 W" R0 ~+ c
        run->cputime=run->cputime+1;  
  ) H3 l$ z! n$ r0 T
  
• 
  6 }0 \* m9 T4 ~/ G
  : r, I: |1 q7 p7 X, V5 r      run->needtime=run->needtime-1;  
  
  
• 
  
  " L$ i  R$ r6 g5 p; U      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  
• 
  ! H4 w  _: q0 s6 ^7 V
  : p9 ~5 X; D/ d  s8 v, T0 F      PCB *p;
  
  ; t( E2 G8 s5 M$ i* E  X
• 
  
  7 e  K% r: ~5 E( {9 e' Z3 h      p=ready;
  6 R6 @# n  N7 _
  
• 
  
        while(p!=NULL)  
  1 Q' }0 Z$ O) N
  
• 
  & O5 M- F% D  \* t0 G
        {  
  
  # W5 i; K4 h% `& J6 P# f
• 
  6 @+ K0 c' z  j
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  % I  A9 g2 Y) ]( G& T' X
• 
  
            p=p->next;  
  9 ~5 ~) L: e: ]2 H! |: h
  
• 
  1 l( a5 R6 ?! j/ a
        }  
  
  
• 
  4 m( g" y3 H& ~9 ?  f2 M/ E
  , g. |$ a- f! K! i      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  . h" _) d, F, p! z; m
  ! m% j$ Q6 }* m  H8 ?6 F
• 
  ; D" t: c: B& A8 N  N4 G# r& p
  4 O6 ^) {- p& f8 y0 P      {  
  
    t1 a& x0 ]* m5 c: S
• 
  4 L# F  u  ?) s# m0 q
           run->next=finish;  
  
  
• 
  # A/ z* O& i- T7 Y1 ~; r7 [: k3 G
  8 _/ R% l/ _+ m) ^/ g  l# ?         finish=run;  
  
  
• 
  
           run->state='F';  /*置状态为完成态*/  
  & E9 @0 F8 |) N5 o4 x% a; _
  " p; w3 }* h! |! @
• 
  
           run=NULL;  /*运行队列头指针为空*/  
  % ^9 \8 ]( d) Y0 H
    U1 A9 o' O2 K; G
• 
  
           if(ready!=NULL) /*如就绪队列不空*/
  
  
• 
  
           {  
  $ m* X7 \2 Q% S; b1 M8 y
  2 `% E9 e" S2 U: R
• 
  ' }7 ~* z5 k' O. [' g
  " M7 s) C, N" Q: M            firstin(); /*将就绪对列的第一个进程投入运行*/  
  ; s/ |, Z) U  ?
  $ u) Q4 G) n: a; n$ ^1 }
• 
  
           }
  4 b5 \- t& v2 U' Y7 b
  ' z  Y5 i( |0 A: B
• 
  + {& f5 A2 ]* i# i+ l) h3 {1 Q
        }  
  
  7 s: ^, I2 Z: J8 p; a6 f
• 
  
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  + Y* I$ K5 O8 L) @( \
  3 U% ?4 w& A4 X2 ?: T- M5 `% J
• 
  
       if((ready!=NULL)&&(run->prio<ready->prio))  
  
  - M  L* ?9 b& Y( L! M: v1 d: a8 H
• 
  
       {  
  
  
• 
  ! o7 q" j; k) b, K  j( Z0 F
  1 k7 v& n7 ^" n; [        run->state='W';  
  9 N/ i, P$ o0 z: s9 Y7 ]6 h* P
  
• 
  9 h& \) p& [6 H: D3 [
          insert1(run);  
  8 ~) ?& |/ ^2 g( T. g* C" Z4 `
  ! p& k2 f0 {, V. u0 ~: z
• 
  * @, i# ~" V: g& M7 Y
  + U+ O* u( Y& c" w1 I' n# q7 H9 s        firstin(); /*将就绪队列的第一个进程投入运行*/  
  ' z: E4 J8 K5 _$ S
  : o- A8 t7 R5 Q$ R
• 
  ( z. J, @$ |& D0 |/ _% `. P
  . @% ]! i7 U" t4 K" l! G8 |     }  
  
  6 ^! a: V4 Y6 c, |! C% L
• 
  
        prt(alg); /*输出进程PCB信息*/  
  
  
• 
  % d0 \3 R8 E7 l2 z$ @& @
     }  
  5 w# F# h  o7 [
  
• 
  
  }  
  1 s- C5 w: c* }$ h; j( v6 j! G! t: D
  ' t/ v* I+ W3 t7 H3 M2 H, K) G
• 
  5 k" O3 ]6 d' o% W& E4 |$ @
  3 G; Q0 Y& J- x, m  w. Q9 S9 }  D/*主函数*/  
  2 Q( R5 M/ o* ]7 `3 t
  & w5 `, s" t3 U
• 
  - m9 R3 G3 D2 k. Y9 e; x8 j  Y
  main()  
    b5 u! ^/ h6 i1 y7 q0 i7 K: ~' }6 K, T
  
• 
  , r* V) a+ Q6 V+ X
  3 z  c3 w7 W8 D{  
  
  0 ~$ q/ n! b! P" {& k
• 
  8 ]% e- g: B6 J
  . z  t" x8 G. D& r& l  b7 _   char algo;  /*算法标记*/  
  
  - L! _7 S0 y5 o
• 
  1 r8 ^, z+ t5 k6 R( `; {! R* P
     printf("输入P确定算法：优先数算法\n");  
  
  , Q1 P4 u8 h: J: u+ u  ~5 i
• 
  
  & U! C& r% H- }: C   scanf("%c",&algo); /*输入字符确定算法*/  
  
  
• 
  
  , S6 N! @" L; ^# v0 r) s) s   printf("输入进程数：\n");  
  ' r) ~( _8 }+ i  J0 P- D8 N
  ( ^/ C% W3 \/ u' D  X9 ~  Z
• 
  
     scanf("%d",&N); /*输入进程数*/  
  
  ( C( K/ K+ k3 E3 X7 [( D
• 
  
     if(algo=='P'||algo=='p')  
  
  ( B) x8 l4 o5 v0 c4 w
• 
  
     {  
  ! J! j! Y3 N! f5 J; Z
  
• 
  
  & `# x2 l9 e; ~2 h, R      create(algo); /*优先数法*/  
  0 B  R; [" s( b# d5 @
  : @$ f# u  m" r4 q5 Q: Y* c
• 
  $ O- D7 G" P8 j# z3 T! b
  5 P; ]$ }3 p7 H/ B3 c& c6 s" x3 X      priority(algo);  
  4 c3 ]( J' K' L! _* r
  . v' R3 E0 u; `
• 
  
     }
  
  3 x, \4 \4 a% V0 m9 j( q
• 
  
  $ Y/ i" q0 k' ~% C1 b3 Z/ i}
  / Y3 z* m. ^% m- P( n
  - ?) s' d  z* I6 a
  9 T% o$ [( Z5 y8 G

8 R2 }, ]9 ]$ g  D; |输出结果：

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

4 f; @1 x0 i# b  Q; Q& N