优先级调度算法

杨利霞

) A, {. }  u4 H: V) S  K优先级调度算法

算法介绍
优先调度算法的类型（用于作业调度）
; B9 U8 C: W2 H; d; c" H* c# {1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
8 w0 I. F1 R& M# ~只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
; V# ^4 u2 C& f3 K7 T

2）动态优先权
5 Z0 C. P0 {4 ]. w% k5 T& s

算法实现

抢占式动态优先权：

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

• 
  # H2 ~$ \$ ]# Q- l
  #include <stdio.h>
  ! l3 W! O6 B9 |* \& @: N% F( S2 q
  7 r" N+ M& y: M# @3 D
• 
  
  " ~* R, h, A. p+ b0 D3 |4 N' M#include <stdlib.h>  
  
  
• 
  
  $ Y# t2 M: U5 [#include <string.h>  
  . x, F% C  L! t5 m. u9 B5 S$ u! Q& X
  * b4 A! k: U$ X: E- e1 f: n3 |
• 
  
  typedef struct node  
  & }# L+ |$ G0 j2 k
  9 o7 P0 h" a: n/ h
• 
  
  {  
  2 Y& s( F! H# q/ O# i' h
  
• 
  3 S( {: ]6 K/ r' P2 l
  : y( @3 {1 m  a, B5 c   char name[10];  /*进程标识符*/  
  ' K* }& f9 P( B! Q# n# C
  " P( p5 A( ~0 t7 Q/ n
• 
  ( I* M% X( Q+ U- I
  8 o- p. Y# U& w1 p6 Y- {   int prio;   /*进程优先数*/  
  & |6 X" P# m7 ?0 a  ]* l
  3 P# I  U* G# x1 P2 z
• 
  
     int round;  /*进程时间轮转时间片*/  
  
    C$ d1 Z% J4 f/ }7 p
• 
  2 k* X' i: |, v2 B( D* r2 O& Q+ x
  6 q2 s; Z' d# H5 n   int cputime; /*进程占用CPU时间*/  
  
  
• 
  6 e) Z2 K) S) U3 K
  # }( R5 k( f8 E! y   int needtime; /*进程到完成还要的时间*/  
  
  ! p$ E' W$ x  t/ \. S( V
• 
  
     int count;  /*计数器*/  
  
  
• 
  
     char state; /*进程的状态*/  
  
  6 B# X8 Z! c4 G9 F' |8 {! E2 T
• 
  5 c* c3 z9 l/ M. E6 E  _
     struct node *next; /*链指针*/  
  , d7 J& }2 x: z  x# ]- p3 n
  ! w# S" `4 n; u
• 
  
  4 j* _9 m: d$ D+ j! B}PCB;  
  * f- a- ^- X, y; ~* R
  4 m5 y' z8 L# p3 P
• 
  
  7 s! K! B9 v" h! h7 {, H5 RPCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  : U4 ]8 s6 G; P& Y
• 
  
  % \7 n5 v* e5 ^7 K& J: F% Iint N; /*进程数*/  
  - e: p* x* O( d
  
• 
  ( @. {; b1 ?: s; \
  /*将就绪队列中的第一个进程投入运行*/  
  
  
• 
  3 ^" R6 n: F2 A9 C2 o* k: l  e- S
  % J2 G8 b3 m0 i& y" L, E* jfirstin()  
  
  
• 
  4 H; T- A9 J( H( [6 m5 t" |
  {  
  - k" x: O" L5 i# s" G9 W5 ~! g
  # X; A; c/ w$ R6 Z5 y* S
• 
  
  7 V: `. V5 p) y. @' k5 y   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  5 k. L" U) I) E/ g6 }7 t9 X8 s% \
• 
  & F% d' Z3 ^, B& j- z: m0 D: p
     run->state='R';   /*进程状态变为运行态*/  
  2 _: j6 e; q# f& e2 |7 I, x
  
• 
  / E6 t! J/ F* G. y( e
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  * l2 y/ o, C$ y$ C  y* S
  
• 
    t9 q0 W' e3 z' j, b+ W
  % w+ W7 R9 X0 W! M8 r4 n}  
  
  1 q, |" {& O7 G/ I/ B
• 
  
  ( W% B  s& B" l( m3 R9 T4 |  l* T9 S0 `/*标题输出函数*/  
  
  
• 
  
  : q+ J$ l  \& S8 f# M% G+ k5 s% C! Wvoid prt1(char a)  
  8 D: J  }' Q% @6 a/ X$ u
  8 J+ q2 v$ n) [3 j
• 
  5 z+ T6 s0 S2 w2 Y: |/ T6 }
  $ B8 _2 h' X' L$ ^: L{  
  8 R$ u( H$ I9 X3 _2 ~8 Z0 g4 W
  , q1 }7 l2 t" c3 ], ?" o6 j+ L: S9 o
• 
  2 _7 P/ K3 y1 F+ H4 L& ^
  0 D7 b1 l4 k; V" U9 `! \   if(toupper(a)=='P') /*优先数法*/  
  + ?6 M# y: i% M4 L7 s# V
  
• 
  
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
    k# h9 q+ M' H6 C( G
  0 D& T8 Z7 D( z* }
• 
  
     else  
  
  
• 
  5 k; w& B5 d0 C- P
  ; r1 L! J4 k6 S* M* q/ [$ {      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  : D* q0 W, ?2 q# t! }# C
• 
  : b" p, K. g. H, J' q3 w4 s* Z0 I
  }  
  
  0 M& @! Y% q* W! X! l
• 
  # G, t3 ^  C( Z$ h7 g* j1 H% @
  + w! F1 ~9 X! l6 O: ?% L  v/*进程PCB输出*/  
  8 J0 H! [7 W: l9 M: \
  
• 
  
  0 p3 \1 {. d! G4 s- \* svoid prt2(char a,PCB *q)  
  
  $ A5 e: d$ p- g5 \
• 
  
  3 q4 f6 D2 |1 ]{  
  % F4 H" S+ o1 F3 Z
  + r8 R3 V: p- G, d7 R1 M0 ~
• 
  0 C  r3 k; \8 H0 x$ @# c
  ( D* e. F. J' F0 P5 U4 A9 M   if(toupper(a)=='P')  /*优先数法的输出*/  
  ( U, c8 F8 I8 m
  3 V( C" w/ P2 C( s
• 
  
  4 m) K6 M* ]& N      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  
• 
  
         q->cputime,q->needtime,q->prio,q->state);  
  
  . ?' F4 ?1 e& {' d0 y
• 
  
     else/*轮转法的输出*/  
  
  
• 
  
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  , C& N6 D* u0 P3 \% E8 j
    ^/ P& J9 D8 U% {6 ^
• 
  
  - N, k2 E7 M; _       q->cputime,q->needtime,q->count,q->round,q->state);  
  % A, @! }5 P, K8 s! g& R
  
• 
    E+ I! E/ B# O8 {
  }  
  
  
• 
  ; n! U" |3 p5 }  O. N+ }
  ' s5 Y8 X: A1 e. R/*输出函数*/  
  
  
• 
  
    P6 ^# G; \- Q+ O. E( tvoid prt(char algo)  
  - ?( `, f& V4 J9 A
  
• 
  - Z1 n, R1 G! C! O! s
    t8 A' v2 y9 {0 n* @{  
  0 s& f1 ^# C; [5 V0 `
  8 w1 e: ?" a6 t
• 
  
  ; S( Z4 E" v5 s: x: |- t   PCB *p;  
  2 J: L( l7 [& _; [) l! B0 @( ^
  0 Z  E( Z% ]) W( i, w% l
• 
  
     prt1(algo);  /*输出标题*/  
  & F; X7 Q: [" d. E6 w5 X' O1 R
  
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  ' z) y8 h1 y% E
  
• 
  
  0 q5 R2 O4 E. q) i! E1 q      prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  ' E7 o5 z) Y5 P% Z$ H5 L3 B  t
• 
  
  7 @" F# y. a* _4 O8 O) D' z! w( d6 I   p=ready;  /*输出就绪队列PCB*/  
  
  , j" v) ?2 d4 w2 }2 `0 w" V
• 
    s* X# ^4 F/ I  H9 D  I# s
  . ?0 G6 W" n- ?0 e2 j* ?   while(p!=NULL)  
  
  1 t/ a. X4 u* t1 B
• 
  6 s' b" _' f. v, q1 u. \/ _5 G
  5 f  Y5 [$ L! y- M! R   {  
  
  6 W! E$ O1 I" ]; y: O, t: w  q
• 
  
        prt2(algo,p);  
  $ q' E2 a* Z2 k! [8 @
  : ^/ K4 {- s: m' p$ {
• 
  " N! m4 d  n$ B, Z  _& x" I5 e
  + ?8 o& A$ i% ^, o2 C      p=p->next;  
  
  3 _4 [$ Z! A2 k
• 
  
    r, z6 L+ u$ k/ S   }  
  
  
• 
  . L6 T5 D* W* k3 b
  : s: G2 h2 e" H( b: S   p=finish;  /*输出完成队列的PCB*/  
  
  
• 
  
     while(p!=NULL)  
  
  $ w. I2 Y9 U- w: O# a4 o) t3 y
• 
  
  2 B9 r7 l% y: H  J   {  
  
  : n- {& T2 c, a) @& O9 J
• 
  
  + ~4 Q3 {6 {0 f: ~7 s8 \# n  `1 O      prt2(algo,p);  
  4 ]9 E# `) x  B0 G* c! L5 `
  4 A4 p1 ]( z& B7 x
• 
  
        p=p->next;  
  0 t) j: O6 G' x: X3 G% W; O8 g
  
• 
  
     }  
  
  
• 
  
  9 a3 F# y+ L! T* \2 O* V, T   getchar();  /*压任意键继续*/  
  
  3 i; T# j/ @* h/ w* r
• 
  2 b  f8 C! y" |& w* x' ~
  }  
  
  0 d7 l/ Q8 S6 i3 S. s" _" @& R
• 
  
  /*优先数的插入算法*/  
  
  3 Z' E( g5 T4 m2 Z: z" a+ ^
• 
  
  2 t, R3 P; f1 N& i. }9 Jinsert1(PCB *q)  
  : B2 }( |0 `" q) M! t& y: D. E" i: P
  . d  T% w% q: Z$ F8 y, v
• 
  
  , G9 c8 C: z% d' C' L# u7 L3 j" C{  
  
  
• 
  
     PCB *p1,*s,*r;  
  
  4 c0 f" h8 Q. c; X% c  T  C
• 
  
  6 r/ y% ]  \' e1 v% O   int b;  
  
  
• 
  
  4 Y8 @. c5 V6 r   s=q;  /*待插入的PCB指针*/  
  / g4 l  f2 }9 A; N
  
• 
  
  ) j3 Q/ D. f, I5 @& {8 W" Z' W   p1=ready; /*就绪队列头指针*/  
  
  
• 
  2 v: g9 ?# Q! P- Z7 v
  % j% p+ P! B- [1 g& a   r=p1; /*r做p1的前驱指针*/  
  $ ?4 A4 O0 J  j0 q
  
• 
  
  5 m' I1 u1 D- Z* u0 c! ^   b=1;  
  
  & N# `& R9 n! T' {) w, ^3 N
• 
  4 t9 P" i" m  x5 Q5 P
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  
• 
  
  . ]7 i) `. L1 |/ f' }8 L      if(p1->prio>=s->prio)  
  9 i0 c7 ~" C: L; ~, n
  # \: l0 b. [6 ]- P) y5 E
• 
  ; B$ r# i( I) l, X- c* K3 D
  ; v4 |, p# }& y      {  
  0 r3 D& o9 M6 _' Z" h8 g  Y$ D
  ! m, \* _3 k$ S$ h% p
• 
  * X) X& ?# H* z# ^2 a
  + R6 P' d  m+ `0 L- v# e     r=p1;  
  
  . s; C- T7 M0 J& D
• 
  
       p1=p1->next;  
  
  
• 
  7 V# H2 g; f% B% ~6 [: ~
  * d* J( y% r5 Q8 W- c6 u$ Y; P      }  
  
  
• 
  $ f3 z  s3 D/ ?; I
  * B8 e7 _/ ^( q      else  
  $ V1 V2 Q" p+ d+ l; a1 o3 \
  
• 
  : y6 f8 c$ U7 g
  ; Y% G. o6 U4 W, H( L8 j     b=0;  
  
  
• 
  
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  / c4 |9 Z" `2 N! Z& y4 p
• 
  
     {  
  / Y: d4 `$ v) k
  0 O* N  l9 c) |- x0 @# }
• 
  
  * w! [5 V: t. {      r->next=s;  
  $ {% L& [$ F) ^5 [! z! S! \$ b
  0 H0 E( a! N4 p
• 
  
  1 ^2 h; z! q2 }3 y      s->next=p1;  
  
  1 `) F6 \& E" f8 ]; v! o& j6 u$ _& R8 D2 d6 h
• 
  , d9 \! {: `. H2 b  ]' S5 G1 [* v
     }  
  % @! o0 h- T, b4 S- l
  ) o7 H. p4 r. ?4 m3 j+ z% y- v
• 
  " l% R, g: N  z7 l! n2 E, B
     else  
  
  ) D" ^# p  J. c- H
• 
  ' Z3 s# X0 x( M8 v; X7 {* a4 h
  2 D4 n5 [2 c: O( I/ V   {  
  
  6 Q0 g  l1 g* z, k
• 
  $ h) C7 P' `' c6 M) b) A6 o* g; w( l
    W# }# D9 E) H% C, W0 ~6 _! t# q7 ^      s->next=p1;  /*否则插入在就绪队列的头*/  
  ! b8 l. e4 K& [! i
  ( ~. m6 g+ i4 P7 |
• 
  ; W6 s/ }+ m; F% _1 }0 ~3 V4 E
        ready=s;  
  2 H0 p7 d* Y4 W. V4 W  q- j
  * J+ K* b" [" q1 S3 G7 n
• 
  
  " M, B% X2 r# h! B   }  
  
  : B% I' Q0 [# V( _2 }/ t& }
• 
  2 w1 f  v( q% c$ @+ W
  ! V! V% O( `' X}  
  
  
• 
  8 Y; i- y6 E, L
  1 T" I7 U5 [% \8 n* ]. O/*优先数创建初始PCB信息*/  
  
  
• 
  
  % P8 o' F' H! p+ ^9 Rvoid create(char alg)  
  1 X' G+ l& w3 k  S8 P* n0 C
  
• 
  1 g2 _# x' S; f4 ?$ Q$ g" f" }  P4 Z2 [
  {  
  
  
• 
  / p; K6 X# U" v: t1 x
     PCB *p;  
  
  : Z0 b4 k/ ?' i- T1 k7 _. T
• 
  
  # l4 L# |1 ~% a$ s   int i,time;  
  7 c& b, R; T5 ?9 G
  
• 
  5 Y/ |0 ~  u# Z( R; l/ _: g
  7 X1 I$ ]1 y$ d8 m+ P1 L   char na[10];  
  6 s; \' J: }( d
  
• 
  
     ready=NULL; /*就绪队列头指针*/  
  3 C" b# o, b. ~
  " i5 r) f/ H9 T, c; e1 q
• 
  
     finish=NULL;  /*完成队列头指针*/  
  
  
• 
  # v$ F  |9 m  Z! }! {
     run=NULL; /*运行队列指针*/  
  
  
• 
    T2 H3 q- b$ Q+ v
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  " C4 b7 ]  f! x8 h1 X
• 
  
     for(i=1;i<=N;i++)  
  + S, g, U4 k  s6 \
  2 M7 z1 r5 B3 ?: ]8 S
• 
  7 V4 J. b7 Q/ M, L% J4 s
     {  
  . e- r% `. ]7 }: n0 k  V2 t( ^3 N# H' u* j
  " {0 |' N4 G' m1 n) A
• 
  
  - |/ r% ]5 u4 N, B+ E6 h1 ]      p=(PCB *)malloc(sizeof(PCB));  
  
  + g* Z9 h. [5 K& ]' T) [
• 
  
  # {: a8 ~2 F! Z! t: {      scanf("%s",na);  
  * S2 `1 T- W) `8 ^7 M
  4 J& s/ z1 V( T8 f% D. D& p! [
• 
  
        scanf("%d",&time);  
  5 v1 b+ a! w# [- v% c+ i
  
• 
  
        strcpy(p->name,na);  
  6 g- C% s1 f! `  K# G. e8 N5 k
  
• 
  
        p->cputime=0;  
  
  
• 
  0 H3 }0 i/ s) A$ k" x8 }8 _
  & ]2 H6 O9 w# d4 p      p->needtime=time;  
  ) }3 D$ `8 V; n! p
  
• 
  + e0 }# R. {, k; B3 J) U
  2 ]7 V. \* b1 ^" |/ }$ ?      p->state='w';  
  
  ; `( t- u& a( A
• 
  : T) i# i4 ~1 p" ~$ @
  ; `3 S0 y- x) G7 x/ ?; G      p->prio=50-time;  
  
  
• 
  
  1 v2 H7 [5 q  [# y      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  ! ~, N1 S4 n- G  `9 M6 @
  
• 
  . t' a$ g) t3 c: P
  : \' X& P# ~; O8 j     insert1(p);  
  
  * N+ e( Y) ?5 w5 L/ f' R9 |
• 
  - X( V- H+ ^. s* v% R: @2 x/ d
        else  
  
  , f: K4 r' t3 v# \
• 
  4 J9 D% x) {) x2 _' B
        {  
  
  
• 
  - N; i) R  L, {% j! v
       p->next=ready; /*创建就绪队列的第一个PCB*/  
  0 Q; W" N( A' C5 P
  
• 
  : K( D' M/ H* {) ]4 w
  + D4 g4 M; k; A) k: Z+ ?8 K0 _' L     ready=p;  
  
  
• 
  6 w' v$ z2 o* u: }) C) N5 a
        }  
  
  % h! x  R; K- q& q9 y) J
• 
  
  , F" i# ^6 d  ]3 X1 }) [8 _   }  
  2 M! A1 I: V- }5 _! m+ L
  
• 
  
  : J( ?) @; r/ H$ }' j   printf("          优先数算法输出信息:\n");  
  8 B; l* E3 L% `, \" g, ]
  
• 
  
  / L4 I0 V- A! H: t1 X   printf("************************************************\n");  
  ' f. e1 ~5 ]- Z2 S5 k& `) ^
  
• 
  
  # F' ?( f7 s, v6 \   prt(alg);  /*输出进程PCB信息*/  
  ! l. L3 e2 O- I, N' b0 `
  ' r7 O! |" @- ~& N; a
• 
  ' i0 H2 T, {% O; D. L+ l6 U+ {
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  5 a9 `( k; Q) N2 }; k4 ~0 G
  9 x( C6 V9 u% e
• 
  & W7 v  }; }- f: Y. q8 d& j+ t( T+ U
     ready=ready->next;  
  
  ' B. ~$ J8 K0 I1 X8 J7 g; O
• 
  " ?; t- y3 G. |' d& p
  3 u6 i9 H3 a  R   run->state='R';  
  
  
• 
  : f4 `- e; B. M$ f
  1 l* Q) J  G% F6 N% K) D: N}  
  7 U' g; M; G; r8 ]5 o1 q  j
  
• 
  
  /*优先数调度算法*/  
  
  ; {$ S  u3 t5 c; |- e+ V
• 
  
  3 q8 K: ]7 O. h0 ~% t  A4 V: opriority(char alg)  
  # x8 i7 P- T6 F1 y2 H8 j( K: B( O
  
• 
  
  {  
  
  
• 
  
  . O( c; ?, e7 o4 E9 Z   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  . v/ |7 T' t  f4 C
  8 r+ E' X$ c: `( E" w% e" X
• 
  7 [$ e8 B; n2 ~+ z  H
     {  
  
  ) I! K. X  K# |0 I
• 
  
  / U' b  a9 r; I      run->cputime=run->cputime+1;  
  
  
• 
  ( P. }7 F! A  W/ s  e) j5 y
  : R) J% e  T5 `" G' s9 ?' j5 W8 t      run->needtime=run->needtime-1;  
  
  1 O) c% Z: {  [. ?/ e3 U3 Q" n; W
• 
  - v+ ?& C; }! }4 _8 L
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  6 n: z# z) [' x& H) }
  ' h/ p" e9 _5 N  V
• 
  
  * W  L7 {" A5 n4 y. e) l) O! |      PCB *p;
  
  
• 
  ( O* a3 U$ m+ @! p
  5 |7 r2 x/ L( D6 O! U" s- G" _      p=ready;
  8 W+ f( Z* V7 Q
  ; I1 ^- h- P5 i3 |% ?2 ~
• 
  * u$ H  R8 \" J; m, Y( V
        while(p!=NULL)  
  - x$ j7 U: G4 t) W% k) w0 K& C
  
• 
  
  : i! o4 I, P7 h% J8 i      {  
  . L' J0 e8 Y) H" r5 _3 n
  / X( S) n2 C( K; a
• 
  0 h$ U0 F$ I9 D+ }
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  4 t9 U# [( w  u* X- e7 _
  
• 
  
  , o% X  o* Y8 m* d; |* F          p=p->next;  
  
  ! z& U9 K- a! e% y9 J3 D$ F
• 
  
  + r8 J* B5 {- R      }  
    k' w  ~5 L0 G. O; }
  
• 
  * y0 W1 B% @% u, x* a, Z& P
  7 Z- V1 V% I! {. w' p/ Y2 c      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  4 r  @% R4 H- b
  
• 
  
  . g5 `- |# ?% B. m, v      {  
  ! x* q, G$ ?% @
  
• 
  1 G! |0 R) K0 l  f
           run->next=finish;  
  - K5 q' m7 a; v2 a
  
• 
  " Y: N' D( t7 t" e( o
           finish=run;  
  6 _; h6 _7 N# b3 v8 t
  
• 
  8 }; [: k* z/ k* q/ c$ i
           run->state='F';  /*置状态为完成态*/  
  
  ) v, C: `& i- {( H5 S( M( p( A1 e
• 
  
  8 t: r9 u' ^* t9 y9 o& {         run=NULL;  /*运行队列头指针为空*/  
    {1 G1 J% z4 Z6 J- G
  6 T) D8 ~4 ?$ g% o  y( y
• 
  + ^; X- B7 X3 W
           if(ready!=NULL) /*如就绪队列不空*/
  # ]1 D7 f$ y8 T3 p% e& V
  9 I+ v5 W  |1 k3 C
• 
  
           {  
    x  ]4 ?. S7 \0 p+ L2 c& Q5 d
  $ ~+ @7 m) Y' p$ ]
• 
  
  2 [  T" ~$ d2 s" R2 h            firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  
• 
  - f7 @# P1 B7 M$ [+ O5 c
           }
  
  
• 
  
  + i3 l0 e: I; K% X% ~4 D      }  
  
  
• 
  
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  $ {; |) J, k5 ?" E4 f
• 
  
       if((ready!=NULL)&&(run->prio<ready->prio))  
  
  # H9 h# z( N: L7 F* Z
• 
  
  - s1 N6 c# V+ C# B$ g     {  
  % B) G  \# |8 S% l7 U& h! T
  
• 
  
  ( v- ~/ ?! j; u7 ~8 {% F. U$ t3 C        run->state='W';  
  % |5 R* p- j$ f5 ~9 t
  & P  Q9 N2 P! ]  L# G3 `8 G2 ?7 L$ v1 i
• 
  
          insert1(run);  
  9 g" ^2 Z' t) I5 t' I
  " Y- F4 Y4 p+ O; [
• 
  / o7 O4 W3 T7 x+ y1 n' g- N
  . }/ c; D$ x: z. E9 s% z0 O        firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  + F" ^0 R9 E3 B  }. s7 m7 l
• 
  $ W! j4 p1 g, V* ?! `" O9 \9 E
       }  
  " b( L. t5 q# v, @& O# n& N8 U
  " B6 ?. ]0 m' s8 m; L7 n9 Q' ?
• 
  1 b; A( B/ o: u# w* [
  5 ]# k; F( G) }8 L! D$ j6 [: U: S      prt(alg); /*输出进程PCB信息*/  
  
  ( B/ [% y1 T4 x* N  I' ~: S# v3 O
• 
  
  7 d7 r- i' b% x$ w7 F1 D7 ?" V   }  
  
  
• 
  & H# h) q3 t, W. g6 f2 r
  0 M- V% i, o  {2 z}  
  $ n8 c1 @7 K9 Y) ~3 v$ Q
  
• 
  7 o; f' q3 {0 @% V# F* F* u7 }$ |
  * R# f, T! @) t5 V4 r$ m: _; R: r/*主函数*/  
  / Y* ]" }+ S% O. M& [
  5 Z# i( j- d5 |5 ?" C- O' ^) e) R
• 
  & H1 U& L* k, w5 ?$ \, B
  # `, m5 Y. V7 @+ Z/ s; ymain()  
  
  
• 
  5 c2 Y7 w7 \6 U# H1 S
  , g, c1 B5 T3 D4 q6 W{  
  0 v3 \. U( g* \
  
• 
  8 ^4 m# A, E; d7 g( [) _* k1 n
     char algo;  /*算法标记*/  
  
  * \" |  W6 c5 S1 x
• 
  2 R. d8 @# L, `0 k" U0 J
     printf("输入P确定算法：优先数算法\n");  
  
  
• 
  
     scanf("%c",&algo); /*输入字符确定算法*/  
  - o4 k+ y/ y' h1 n1 b5 X
  % D  \# Y) \) r, ^$ K( U
• 
  0 A: W) `* X: A# y; r9 w/ J3 D
     printf("输入进程数：\n");  
  
  
• 
  
  . h) p$ e. j8 }$ f8 e   scanf("%d",&N); /*输入进程数*/  
  
  & G6 g( Z, Z5 P+ }6 h- W' I
• 
  6 L/ H. n' }4 H% F9 x, D
     if(algo=='P'||algo=='p')  
  
  
• 
  / H  L- f" e+ H
     {  
  
  
• 
  
        create(algo); /*优先数法*/  
  2 y* s6 n/ u! _3 Q* Y; n4 k) V
  
• 
  
  5 C# X( L3 o& w" f  C# |" c      priority(algo);  
  % ]$ _/ r9 j0 _
  9 c; [! D6 y7 X, V: h
• 
  
     }
  
  
• 
  
  - L/ t( E9 q! y: ]5 f0 X4 P$ I}
  
  
  

1 b/ t9 O/ l3 {$ a, `输出结果：

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

8 Q  ?2 {  I9 O) N% K2 y