优先级调度算法

杨利霞

优先级调度算法
- c8 `! ]7 G& v: q- X8 u

算法介绍
优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
* }. F2 ?% K1 @+ _9 H- G* R系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
; U4 \) O0 ^* S2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
+ F4 S$ u$ a  x1 w1）静态优先权
. {2 h  E" \0 M1 Y( X0 g/ ]! J静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
4 {+ L; Q8 ?+ x8 g( ?) R

2）动态优先权

算法实现

抢占式动态优先权：

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

• 
  
  #include <stdio.h>
  
  ; E; d" h. |9 d& Z5 x3 @( r2 ?
• 
  ( b! S* f- K- u2 f" p: g$ D
  & }' h4 j3 d% r5 k# e#include <stdlib.h>  
  
  5 p* W" z2 S4 E
• 
  & q+ [  b6 N1 T) ?' }! w' j: a4 c
  , T9 k- o) r$ y4 X6 G8 l9 M#include <string.h>  
  / a0 p" N+ a8 Q; `* ~
  
• 
  
  % r# {8 z/ \' g/ P& T- atypedef struct node  
  # p+ a1 m0 U' T1 {
  ! K# a) Z& s6 X5 C, H
• 
  
  % |+ B: ^9 q+ L% b{  
  
  
• 
  
     char name[10];  /*进程标识符*/  
  
  
• 
    W  ?; a" m9 T( T/ R4 a
  1 I* g' g6 W2 I5 U4 s   int prio;   /*进程优先数*/  
  
  
• 
  
     int round;  /*进程时间轮转时间片*/  
  
  
• 
  5 ?: Y) J0 Y  Z; i; }, n
  % b9 {* |1 u  e# v' i# H: ^, `   int cputime; /*进程占用CPU时间*/  
  ' W! l- ^7 M- D) e5 X" i: v
  
• 
  
     int needtime; /*进程到完成还要的时间*/  
  
    V7 G, ^. B8 `4 v& ~
• 
  $ o# ]' ?) v2 M' N
     int count;  /*计数器*/  
  2 p; y% D/ N8 s4 T3 W) e' l
  
• 
  
     char state; /*进程的状态*/  
  4 [( V1 q6 [2 p! U
  . }& G9 `% s$ K# _2 c' D( O: N
• 
  
  8 g- Y- \  f& V' I1 E+ U   struct node *next; /*链指针*/  
  
  
• 
  
  }PCB;  
  8 q/ ^  k1 Z4 S* X) I. |
  
• 
  . F. Q6 q9 e/ P3 j# U
  9 w/ _/ x- E% z4 G! uPCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  
• 
  
  , y' E8 n2 ?* u2 g$ v% v7 Jint N; /*进程数*/  
  ( B0 C5 q  \- [
  4 Y7 @, N# _' }9 M& j; Z5 L! l
• 
  " K8 _' ~% Z& s8 q8 q
  / o0 d+ D9 [9 S0 A  ]% C% N" h/*将就绪队列中的第一个进程投入运行*/  
  - Y* t' @) B0 z( L' w1 {- ^
  / Y0 R  m" C. X7 l, O5 ~/ z
• 
  , F% Q( h- }1 s( |$ ?2 U
  firstin()  
  
  
• 
  
  {  
    G/ n- a) |" a# R& H
  " k+ k2 s- g  v2 E- d* \
• 
  
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  : M0 P$ T) v# J, E+ x( N
  
• 
  
  * k% f+ Z  E# Y% O, D5 J$ H   run->state='R';   /*进程状态变为运行态*/  
  * r/ J+ f) j0 |% O: t% c" _
  
• 
    g( a5 j# z$ h& u) [
  + I0 @1 n  a" ?. K5 s" f   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  
• 
    Q( q. _, I8 t& z+ g1 _5 g
  }  
  
  
• 
  - h7 \' p5 w- g1 c2 y" e
  2 @. ^$ M# S: I: U9 F4 r/*标题输出函数*/  
  , d7 b- [7 Z# Q  r
  
• 
  & Y8 k; B4 m3 t4 f2 |* K
  1 m- t* }. p4 h# j$ p( Nvoid prt1(char a)  
  
  
• 
  * @: q6 v6 y" w8 b4 Q0 w( o
  0 o& p! d- w9 L5 Q1 S% k$ t0 T{  
  
  
• 
  
     if(toupper(a)=='P') /*优先数法*/  
  4 O0 M2 Z; X: n( c0 [) p4 h; c. J
  
• 
  
  ) m, n! K  W9 ]9 N2 f0 P1 d      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  
     else  
  7 l3 b( U: e6 F% K7 S, N1 s* P) `
  . @2 `0 a' C4 e  F
• 
  6 [( t% Z! e/ G) L9 s
  ! _% Q! D9 X* O# w; n* H0 i$ A      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  
• 
  
  5 n8 X; }. m+ S}  
  . N3 z* z$ @6 ~$ s2 \( S+ g
  - Q* @3 b8 G& O5 x4 K* b9 j
• 
  ; g  B) r- r% A
  /*进程PCB输出*/  
  
  % j. R9 q5 ]: P4 s! |2 W; z: f4 p
• 
  
  ( I. c& _" J) G! z+ c  @3 i. Svoid prt2(char a,PCB *q)  
  
  / B0 h6 I( _* W. e' P
• 
  
  - `: i: U- H' P. J2 b. ^{  
  
  4 q* R+ g: b" ?* ^4 D
• 
  2 ~/ t& e0 T* m7 p
  6 j8 l7 T7 F( |2 {; O4 e& e! d   if(toupper(a)=='P')  /*优先数法的输出*/  
  * M9 b. u5 O; e; S
  
• 
  
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  ! D, r" _6 i, T8 R
  2 z7 l# Z7 O" t/ O# l8 f
• 
  7 x# j9 d- N# Y: i3 e% X1 A1 c* R
    x7 c$ o" y" k. S) L& |       q->cputime,q->needtime,q->prio,q->state);  
  1 g( T& _4 G" }  E, G& g
  
• 
  3 ]- ^) ]: |0 a
     else/*轮转法的输出*/  
  ( t. T6 x! V& H9 }  h
  
• 
  
  8 H" h3 w8 R7 C- z1 d- h5 g0 Q! j      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  1 N( A- `0 p' x% X
  
• 
  - t+ i( T! ]0 g  c& [
  * n. N, m+ R/ Q0 g* _       q->cputime,q->needtime,q->count,q->round,q->state);  
  # o0 t3 H) L* u0 a6 R3 ?( H0 E
  " I; e! `( K. ?( W
• 
  " z4 @  U5 c' P. S9 |
  }  
  + l: {% E) ^4 r) ~; U% q
  ; C" K" v8 Z1 `' ~5 D
• 
  
  # S0 l" D9 R# m# x- a. h9 d0 D/ J/*输出函数*/  
  $ |# p2 z! p8 J; [
  ( V" j6 k8 Q! j
• 
  2 M+ ]6 n+ F+ i) v6 C* t% q
  : C# u- z% v) F/ p% a( K. A% Jvoid prt(char algo)  
  * B' c4 a* y6 ~5 s, |
    w; O5 f. o# L5 |( Q
• 
  
  {  
  
  * ^1 X% Y3 d( O% z: j& K2 K
• 
  0 }1 g* V) Q! T& M. K
     PCB *p;  
  % L% L9 y) V% m6 V( N
  
• 
  
  9 ]: E  G$ b: W  c9 L   prt1(algo);  /*输出标题*/  
  ; v. N/ m: [/ R1 f6 I
  
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  
  
• 
  ) Y) J) g1 e2 i! ?) ~* k
  9 h  R1 j% X+ t6 Y$ q9 I. h! ?      prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  
• 
  
     p=ready;  /*输出就绪队列PCB*/  
  
  8 j  `1 b2 k4 x8 A
• 
  5 W% e. S5 X9 L" `, E7 j
  0 M3 M7 M8 a1 p. b  i) @   while(p!=NULL)  
    n9 e; g: t1 i( f7 Z3 F) G
  , i# ^5 T2 b2 J# I
• 
  
  9 \. R, c- w8 N0 f  h6 r   {  
  
  % t9 l4 R: [* A, E
• 
  
        prt2(algo,p);  
  0 H9 M1 f- w4 L. n! Q
  2 F1 C+ T# O% A* W  s4 O- B! a- e
• 
  6 v, L2 v! e6 g& F
  6 l7 d& K1 D6 X8 N      p=p->next;  
  " y, V1 s: U2 r7 O! X  ~5 B/ |
  
• 
  - G$ k# X7 Z9 X& c2 \* u- V
  ; j" N9 Y( G+ @/ t! F- b   }  
  / ^8 x7 t2 b% x+ W1 k7 N: r
  
• 
  " Q2 {8 \0 `; N( D" j, ]2 T0 X
  * q8 O& e$ V4 K# G7 x& m* g   p=finish;  /*输出完成队列的PCB*/  
  
  
• 
  
  & L" B) A3 ]3 e  y+ o% e- B# [; r. z   while(p!=NULL)  
  7 m+ f! Y% G' X& w4 a( q
  
• 
  # o; D% c; ?) N2 Q
  + w5 N6 y& |1 D% k& O; m1 S& Z   {  
  ( _: V4 R: O: v1 q0 C6 C
  
• 
  , T1 r0 |7 p' b
  2 T" ^: X/ Q. Y( a6 Z0 P, K$ l      prt2(algo,p);  
  
  ; w2 F3 f# O5 S8 m! x' V
• 
  
        p=p->next;  
  3 b, Y1 P' \: d9 {0 K; k
  * D) l% S0 o5 [7 N0 X
• 
    Z4 Z  _4 i. q% l
  & F! i( i3 |7 g) u$ r( q7 B" V7 ^" h$ S   }  
  
  3 l; n$ |2 m  H, e$ n
• 
  
  # t' p+ ^+ m; {  ~- I   getchar();  /*压任意键继续*/  
  
  
• 
  ! K3 m3 R" |$ Y+ g8 G" E! F/ Q
  }  
  ' v  Y& _$ t6 j/ f8 v7 E# W
  
• 
  
  /*优先数的插入算法*/  
  
  
• 
  ; i/ N% n4 u0 d& H1 l! w8 H, K
  0 M2 w* j( m% U: Binsert1(PCB *q)  
  6 C/ [) {: h% E) |; d- ?
  ) e/ j/ y2 o0 A$ j9 F( Q) d) {& j' k
• 
  
  {  
  % J- V) p+ }7 R9 x
  
• 
  2 Z1 f/ I& h+ \
     PCB *p1,*s,*r;  
  
  0 A/ E( M7 p4 Z; U# x7 B+ |
• 
  ( t' l( K7 R: [* r
     int b;  
  # o* _5 ~; Q- J' D* r% ~+ r
  8 i; F+ Y9 K9 A6 z4 N
• 
  : S6 F) _5 o! I* y$ B, q
  $ R8 h9 n6 |$ b6 ^   s=q;  /*待插入的PCB指针*/  
  / Q' b7 Y: q$ e% n% ~
  4 o+ ~% D1 J" j0 h5 n
• 
  
  : h5 u4 p0 Y% }* |! ]& m   p1=ready; /*就绪队列头指针*/  
  . L& Y$ m/ I$ X% H; K/ Q9 _
  : K6 P6 `  \- i7 r3 {9 {) k
• 
  % Y6 a+ K) |  ~9 q4 F
  ' Z7 [' b9 I1 ~. V   r=p1; /*r做p1的前驱指针*/  
  4 m7 F; B9 [3 i& h
  
• 
  
     b=1;  
  
  4 d' Y! v8 E% }, o: L. L
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  , k2 E# @. |8 `# V2 N+ m
• 
  ) |* u  P5 s5 _% b, R* D7 V
        if(p1->prio>=s->prio)  
  
  
• 
  
  " K: L, Y: O2 h$ W      {  
  
  " F5 A! t- s5 I* J
• 
  
       r=p1;  
  
  
• 
  
       p1=p1->next;  
  ( Y/ D# B: o6 _! X; B9 Y  W
  ; |7 O; i  a# I7 A' R
• 
  
  1 H- e/ j& g6 K! E" D' ]) P      }  
  
  
• 
  
  ( n4 `/ J% b: }3 Y      else  
  
  % G& A! s* G# \& {, q2 l
• 
  6 X/ l6 D8 L! _; ?
       b=0;  
  + q9 s3 u% ?: f7 s( W) \: E
  
• 
  8 H" X2 ^' [- e* r$ F1 M: u- O
    e$ L6 j& J, ]" V( @: ?1 i6 s! e, B" \   if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  . c& s: d$ r+ R' G" l6 p/ M
• 
  
  7 c' Z) }; T+ l5 u2 N   {  
  
  
• 
  
        r->next=s;  
  7 f" P+ V* s; @- h
  / [- b4 _) g, m3 ^# G. p" D
• 
  - N& ]5 }- ?1 ~
  4 d$ v: q2 A5 ^! N      s->next=p1;  
  ! d9 T) U# }2 F0 Y1 E! p
  * l! G# K& R8 P/ a$ I
• 
  9 L  X- V9 B( t# ~  _
  : L3 H6 U0 g1 q0 ^0 |7 U   }  
  / T2 U+ e7 W5 M' d
  - @8 q! F7 Y9 c9 A* y- w0 b
• 
  
     else  
  ! }2 |  Z; q% |/ Y4 l
  
• 
  
     {  
  - k6 r" ~! K3 f* C! Q- h$ u
  4 ]0 r% D+ N3 w  j/ w' Z
• 
  
  ! G, n5 O, R' F) q      s->next=p1;  /*否则插入在就绪队列的头*/  
  
  
• 
  
        ready=s;  
  
  
• 
  
     }  
  
  
• 
  ) U( o1 f8 O; k/ F7 x
  }  
    g$ I# V' C$ ?8 l5 C0 N3 m& J
  3 G2 e2 b5 j; ~) V' D7 g# V4 K, m* m
• 
  : N" |* Q/ H$ i% V! z# y
  /*优先数创建初始PCB信息*/  
  " p1 `$ ?) K3 D% {
  2 C1 [( U# C. S: E* T' O& m# Q% D/ A
• 
  
  * J; n3 H4 m6 e) b8 G6 _( Fvoid create(char alg)  
  
  
• 
  
  {  
  1 w8 ]% W# f& g5 @+ a
  
• 
  
     PCB *p;  
  & S  ]7 z3 m) M9 d
  2 D+ f" C# s' a8 e9 g% G
• 
  8 z+ U) R8 V* U5 u1 S4 X. L9 g
    H+ X" d3 x! e- R! d' v9 c" ^+ l0 o   int i,time;  
  : ?, O7 R! k3 K
  
• 
  
     char na[10];  
  ' B7 i- s$ k. n6 G2 g, f# E, I: H
    r. Q5 p" D8 g# D# ?, M
• 
  
  : H' J' ?$ S) V- M2 U   ready=NULL; /*就绪队列头指针*/  
  
  
• 
  5 A6 E. P) |' N# P" a( `- m4 J
  3 f) @4 W+ _0 u2 y9 j   finish=NULL;  /*完成队列头指针*/  
  
  
• 
  : E/ I1 t0 v) w& l& I. s$ Y
  + [' P& c- Q9 p* a6 r4 @   run=NULL; /*运行队列指针*/  
  . x2 S7 I3 h6 ]3 Z
  
• 
  6 w9 [0 h  C% T" M  K- P
  4 S4 n: R1 B" C( c7 }1 F' _   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  
• 
  4 k% t- k9 q* V5 W7 U) y
  8 ^1 P2 ~# D9 P' K( t1 E0 X& Y   for(i=1;i<=N;i++)  
  ( c! H. a' {0 h  P1 x7 w" W) j
  7 d0 d( W/ a  d1 o
• 
  
  5 `* n( A& _4 O+ E: q1 i2 P* c   {  
  
  
• 
  
  0 d9 R/ ?' x: r2 T6 {) i  z      p=(PCB *)malloc(sizeof(PCB));  
  
  
• 
  
  / P4 B& q) |3 X$ p      scanf("%s",na);  
  
  
• 
  7 r% g4 }3 `- D: K" W6 @
        scanf("%d",&time);  
  7 }4 b/ V) p# h9 V% f& W
  
• 
  3 t. `1 l' l  c" J
        strcpy(p->name,na);  
  
  
• 
  1 Q" G4 Z/ X6 ], `% c
  . l* u! x4 Q: C8 e7 s7 V2 [      p->cputime=0;  
  
  % y& w& U: O4 \! R
• 
  9 E3 H" }1 _* t2 C! l1 z6 A# {. {) A
        p->needtime=time;  
  
  
• 
  . m  C0 ?% B4 ^  Z( M' Y$ k8 U0 ~
        p->state='w';  
  ) B+ K/ [4 j' S! ]9 S! h; x  k# g
  6 X8 B. Z: q1 x/ L' ^2 v- D. _: e
• 
  
  ! S: g5 J0 S% e1 f1 ^- E1 B6 S1 D      p->prio=50-time;  
  # {3 t# C3 w6 X. Y
  ( f; X- E! E( ]. f3 z& m
• 
  
  . y6 G4 `9 P  s) Z      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  
• 
  - f  W  b" c: f  A6 [" a
       insert1(p);  
  
  
• 
  + `4 f- n; ]: v6 G5 l8 Z( N
  6 q) q2 n" F0 s9 e      else  
  
  
• 
  
  3 z5 f8 X( l* Y# X# L      {  
  # q% }4 f* ~2 ^4 n' f# v
  7 j" }. N' E4 I: m+ y( X
• 
  
  % y* J4 t8 L4 F     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  
• 
  
       ready=p;  
  ) T4 Y3 _. Q4 N8 C0 j: @. r
  
• 
  
  + A+ e4 P" }' o5 u      }  
  
  ) n: S# r. ~+ s9 R# i1 Q
• 
  $ R; W' t6 T. ?. V  o# N
  . T  }4 ^- E3 h; r; p  y- i   }  
  
  * ]7 `1 l1 {( q2 l
• 
  8 m  T' L% }$ T# l" }; ]% T1 z
  ) H! X2 V( }3 U+ p$ y   printf("          优先数算法输出信息:\n");  
  . \3 V5 I8 o( V' J5 ]: M8 t# @
  
• 
  
  / z  B! ^4 \4 z. O8 K1 u   printf("************************************************\n");  
  / m8 c+ U9 D7 I
  
• 
  
  ; V  @" I, u6 h( s/ s- E! Z   prt(alg);  /*输出进程PCB信息*/  
  
  
• 
  
    j3 A. s9 y5 c8 U. ^: G$ j; ?( V; q   run=ready; /*将就绪队列的第一个进程投入运行*/  
  * k0 L9 D! |  x" t  H4 g) E, O( p
  : B; N0 {, t* h0 r6 ^% x" k3 p3 G( V
• 
  
     ready=ready->next;  
  
  ! z& K0 V2 h" Y. G, W+ g
• 
  6 ]6 B8 U0 e' e" ~4 c6 J
     run->state='R';  
  
  ; L' @# }# Q7 _; A
• 
  
  }  
  $ H# V! e9 u- X; F; C
  
• 
  
  /*优先数调度算法*/  
  
  
• 
  
  ! e* @) _4 k5 ^) J9 k1 y4 n6 rpriority(char alg)  
  
  " Y0 _( \! O2 Q7 }5 `
• 
  0 _( T/ [! S3 C
  {  
    t9 R0 h1 x2 _. T) y9 |
  
• 
  
  ) Z# M1 @& z$ |5 F. u$ Q/ F   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  - _' x" ~8 ?1 ^& z/ O
• 
  
  8 M* e, u4 i, O4 l  Q5 z$ U0 r% I7 u  d   {  
  9 U2 I& v1 H# i; S4 H
  . C' l7 c1 }! U
• 
  
  ' l; r3 T+ v/ ?( {9 H1 t" R      run->cputime=run->cputime+1;  
  
  & y+ F+ P2 ]+ `
• 
  8 d6 E/ _4 q+ Z, Q9 v/ O
  ! }( f" r9 L+ O( N% S2 O5 l      run->needtime=run->needtime-1;  
  # ?% y6 n2 O, l5 q" ~& w# P
  0 O+ _( a/ V0 E6 }9 q( a! P
• 
  
  / R2 w0 l% }) q' ]: L6 @) m& D      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  7 w( U1 x0 g! L8 f' r* C8 ~4 a
• 
  
        PCB *p;
  
  8 M' s& O- o* X/ t
• 
  
        p=ready;
  0 ~& \9 |6 M/ z
  
• 
  % j2 e- C1 N/ a( x0 G; J" r* F
  . s6 h) ^. a% Q; E+ t1 [" E6 V# r      while(p!=NULL)  
  " T$ P9 z" M1 ]# E$ M
  
• 
  
  1 V+ Y. \4 `7 }8 `& F      {  
    r1 i& C" S& {5 \* M
  
• 
  8 D0 e& V) [" _3 [& O7 Y' {3 S9 z
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  0 |6 J/ A. p1 w' m: r  [& P7 f% i
  
• 
  
            p=p->next;  
  
  
• 
  
  2 d# N0 t7 F* q3 a! ?' K      }  
  $ ~' n( Z  b- `  r: y
  ! E7 {0 [( u. @
• 
  
  . t" n/ i) U. L1 z8 w# I. l      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  . O( u8 a3 H1 C" J2 e  E
  
• 
  7 V9 Z8 Q1 c+ ?7 P0 @
    x' z3 M5 v( }" N5 B  H      {  
  
  
• 
  9 j1 D" ]. F% L) x% l2 k9 h
           run->next=finish;  
  
  
• 
  
    {1 V- c0 F2 n5 H+ M9 q% A         finish=run;  
  " r0 `9 ]0 {: e1 g8 O$ ?
  
• 
  
           run->state='F';  /*置状态为完成态*/  
  
  4 _) K  j2 m0 I+ W9 I
• 
  
           run=NULL;  /*运行队列头指针为空*/  
  
  
• 
  6 [3 I5 u* d3 h2 `7 j
  , \- L) c7 v& g         if(ready!=NULL) /*如就绪队列不空*/
    G$ a$ d2 ^0 s/ H" g0 A5 V
  
• 
  % Z1 `3 y% v2 y2 R' A: S
  $ |9 Q/ X+ q7 @* ^  c! g# {         {  
  
  
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  
• 
  * u% m% ^: S% q7 J8 w
           }
  : w3 ^/ g' C+ l
  
• 
  ' x$ P9 I, [9 j7 g/ n
  ; R1 `+ w3 g$ I# E8 v$ D0 ]      }  
  + e) h  {; p! y& z
  
• 
  % S4 X  _3 l/ t- O
  2 N2 p: K4 i+ P- {/ w7 x( {8 N      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  ) {8 |, P  M' g# J; L  S/ n& ?' {# r7 d
  
• 
  % ?2 @7 v" Q- s7 g, x3 E) a, _
       if((ready!=NULL)&&(run->prio<ready->prio))  
    U9 z/ _/ W0 P. w
  : j9 e  Q' v& p1 w" i5 o
• 
  6 R! s8 o3 C; J5 Z2 ]
       {  
  
  ( |5 R4 e9 ^2 [6 R/ E4 B
• 
  
  ) e. D, i/ \% N, M$ L# r        run->state='W';  
  / U3 D7 u# M% b
  
• 
  
  + y) v, U3 d5 k/ ]0 a( Q$ {$ R6 W        insert1(run);  
  
  
• 
  / {4 S9 O- c0 a, \0 [+ o
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  5 b7 i8 L3 q/ G8 O  M# [5 h8 t. q
  
• 
  5 [/ q; O, _7 X$ f
  - U% }' @% V2 d( c; |" d7 Q. Q     }  
  " [. z3 Z  V' w) \
  
• 
  2 }, C, |) T/ s7 a( `
  8 V3 \% n) l$ a7 A5 X      prt(alg); /*输出进程PCB信息*/  
  + G6 T$ n: R2 @* U. [  V) \& E& D
  , R6 f0 w: w9 K- t8 m3 l6 j0 b0 j
• 
  ) P: R' o" ~" x( ~6 a5 h
  8 F% e7 N! C" [' z1 [0 Y   }  
  7 G1 q4 O( G* ~( \2 O& j' Y: v
  
• 
  
  }  
  
  
• 
  ) \& g" {* E% M9 O
  /*主函数*/  
  
  
• 
  : J2 q# a1 ?( m4 Q' e0 K7 I2 |
  main()  
  : @  W: n; }( ]) G2 L
  ) V" X! ^/ v7 A* H+ P  U& `4 f
• 
  
  $ S7 t+ ?9 Z* b; u: G* ~1 E{  
  7 x# L; d' W6 ^! J! X
  2 J  b5 x6 j! V# c
• 
  
  8 p3 v3 G6 Y/ H! P/ \( \   char algo;  /*算法标记*/  
  8 Y6 Z0 I: R; c' k6 W7 t
  
• 
  ' ]/ f& m" q# _: m7 A: c3 V4 {
  9 Q* r( S7 \9 \% S5 t   printf("输入P确定算法：优先数算法\n");  
  
  
• 
  
  6 _+ c2 D5 m: B% N   scanf("%c",&algo); /*输入字符确定算法*/  
  * c: C5 v0 S# R- H. m' @
  
• 
    P8 [5 |- f& V8 b, a
  : ]+ [9 _  ]3 Z" c8 O& l5 A; c   printf("输入进程数：\n");  
  # u. k% f- M( @
  $ z; F# B7 W& z) a
• 
  
  & S+ b: r% y6 s1 h) q' \/ J( o   scanf("%d",&N); /*输入进程数*/  
  % E; P4 _( I5 k; F1 k! D
  
• 
  
  8 q& ?& |- O& s& n  q) R0 Z   if(algo=='P'||algo=='p')  
  
  ( |' O& l+ x8 o. a$ j
• 
  
  5 Z! U$ I: y4 ^3 i8 p1 {1 ~% f7 b   {  
  
  4 F/ o9 X% L; j9 Z4 e
• 
  
  9 n% V$ o; K. j, g! @      create(algo); /*优先数法*/  
  $ M0 f/ ^8 y! s# ?# ?
  1 @/ A. L" `; G" t( A- ~* X
• 
  
  * k' a( L5 U# i6 j3 F      priority(algo);  
  " Z5 B3 g, B9 j( z- J
  % N8 a: h* {) w  K% }
• 
  
  5 a3 ?& {% K9 c( c   }
  6 @/ W% e. W1 J1 R3 @
  
• 
  
  2 v+ E% h- T: A4 Y# t6 w}
  * ~" ?4 c% W3 {: a
  
  1 b7 B# [& k" o

输出结果：
* |9 ?3 b9 X2 c( f0 P8 h

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