优先级调度算法

杨利霞

7 b+ c' ^, ^6 x- i( P优先级调度算法
; K& O& ?! o2 f$ O

算法介绍
优先调度算法的类型（用于作业调度）
1 B' }- s, g0 o3 b/ i1）非抢占式优先权调度算法
% [5 b; p' G" |: ~系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
. P" A7 B. T5 j  g. ?

2）动态优先权
5 [% o2 o$ I" M' l

算法实现

抢占式动态优先权：

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

• 
  
  * y/ }. N# r9 a1 e8 p) `3 @#include <stdio.h>
  
  . B' A" J9 G& O6 D; r
• 
  ' f4 \  @/ e5 a/ B
  #include <stdlib.h>  
  
  
• 
  
  #include <string.h>  
  
  # y( i6 q# H3 T  R
• 
  $ A5 Q, r+ V, ]1 ~" e& x8 Q
  3 ~. F4 S4 j, V! \6 ?4 ^typedef struct node  
  7 w6 b; @9 ]& ~9 l3 p$ f
  
• 
  / F$ [4 N% N" V
  6 Z6 ?0 M& d" Z' I{  
  ! W$ c2 x* X$ f6 p' ^; \3 U
  ' z5 d  J, f0 K4 b+ j
• 
  5 j8 `- s% r9 N* Z3 I4 |
     char name[10];  /*进程标识符*/  
  
  ) ]: E8 h4 j; J8 B: y# \
• 
  2 _; l0 B: w- c! N! g. s
     int prio;   /*进程优先数*/  
  & f; D3 q, a$ {9 M
  
• 
  8 d1 W; g! G3 a9 C- V
     int round;  /*进程时间轮转时间片*/  
  " d. k0 R, J6 O! Z% }- n* F) v
  
• 
  
     int cputime; /*进程占用CPU时间*/  
  9 u3 }$ Z  ^' M5 v9 f/ Y. [1 Z/ ^
  
• 
  " c7 c/ U7 \3 x9 {3 {& O
  # U7 u$ T( n, H2 E$ D! D- X1 {. R   int needtime; /*进程到完成还要的时间*/  
  + o) f6 n0 B3 S* G2 `7 _% M6 Z( \
  1 f# c; {$ W% E8 j, S! r
• 
  # x- h5 T  O6 f9 X
     int count;  /*计数器*/  
  + I" _8 [4 ]8 F8 n
  
• 
  & N4 S; [- ]# h$ n' E
  ) I' Y, w( i( @6 }' p& B! \" z1 K* Z; R   char state; /*进程的状态*/  
  
  . c; @( z7 F# t+ d8 B
• 
  1 u3 n: p1 }: k( q1 t( C5 |
     struct node *next; /*链指针*/  
  
  5 p: F: g1 j* C
• 
  8 j3 R% p& l$ {* _
  0 F: A/ b1 H+ x# M0 A8 `" f* L# E}PCB;  
  
  4 N) d8 U, y; y6 w4 A2 |
• 
  
  9 m0 C- Q; R) QPCB *finish,*ready,*tail,*run; /*队列指针*/  
  ) U5 v0 M* c, {# @* n4 x
  
• 
  ) R0 \2 b! k( A+ n
  int N; /*进程数*/  
  6 Q6 {( ?) Q0 i; U: v0 M3 Q
  
• 
    p5 i+ c- i8 D* X% U
  /*将就绪队列中的第一个进程投入运行*/  
  
  
• 
  9 |8 q4 t; P' j4 }7 @
  " u4 y2 ~' `* C" n* I+ H2 Hfirstin()  
    w0 l! Q' m; [7 {
  
• 
  . @( [# b" q+ i: a% j! j; h
  {  
  
  ' c1 g4 D0 j# e/ ?5 g6 O
• 
  
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  & C7 N6 Z- S$ E" D, p7 b1 u
  % J' `3 b' T( A5 }0 Y0 }) j8 |' w, i
• 
  - W% W' ?3 ?) d, E" a
  " D, o/ s% C4 g: A; H   run->state='R';   /*进程状态变为运行态*/  
  
  
• 
  
  5 s7 i- p8 s! z$ F' B   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  4 c$ B! f: a* m! Z" P
  
• 
  
  }  
  
  7 \/ E; Z: |; ~4 Y) A. ~/ w
• 
  7 ~, W+ p, F! d/ h, X
  9 G: y2 I# u' L/ V) P/*标题输出函数*/  
  
  ' j$ [! N, M3 z
• 
  5 |8 y; M1 z' p, h
  void prt1(char a)  
    q, i! g9 d3 \7 C# O# p' `4 w
  2 ^6 \! q; h% u4 G/ C3 i
• 
  ; k% }8 j) r: P/ ~( c) I+ K
  {  
  ' A2 j, k; W1 m" d5 _
  
• 
  8 A0 |1 C( L% z. z" k5 \
     if(toupper(a)=='P') /*优先数法*/  
  & e/ `$ z& W0 m
  
• 
  
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  : {, q$ _$ I+ Q4 m; h
• 
  
  ; k8 @: _! V1 o( u8 K; d2 I   else  
  / |* Z9 ?9 E: M0 C0 n* G
  
• 
  
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  
• 
  ) N6 }. T! |6 \6 m% A
  : E: e, D$ v3 y5 k0 v% d/ s}  
  ' }$ C' f  a0 Y9 E) P7 ?
  1 v- r# g; Q0 I& R% J/ }
• 
  9 i# C( m$ U" c; ?: _: a
  " Y% u  X7 r, \$ {( ?; k* E, S% c1 [- P/*进程PCB输出*/  
  
  , {, h( o3 `3 w8 w
• 
  * N! E' \3 c& |
  3 ]0 j& k# o& E$ t" @6 k9 f0 ]void prt2(char a,PCB *q)  
  
  ( e" a7 W& f! r. B- L: ~
• 
  4 m& r9 D& F' U0 }. k: i
  {  
  ' S, s2 N$ y7 m$ |0 P
  ; x3 t9 A3 b. L
• 
  * O1 a5 d) m, g6 W9 |
     if(toupper(a)=='P')  /*优先数法的输出*/  
  * M( c! c( p: |/ p7 m
  
• 
  . \0 l3 t+ G# Y1 L* y, V2 }, g7 V
  / u7 P$ n  v3 J4 I% U      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  ( f2 M9 m) P2 v, B' _
  3 V! K* A* G" i3 E
• 
  
         q->cputime,q->needtime,q->prio,q->state);  
  
  0 I7 d+ a# K0 ?0 n
• 
  
     else/*轮转法的输出*/  
  + `  H; i- m( ]. N. d. j( V
  $ u$ ~1 w: D* ]% Z2 l( X+ S! D: g; I
• 
  
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  6 h3 h( R- S, Y8 a( l, c1 y
• 
  
         q->cputime,q->needtime,q->count,q->round,q->state);  
  
  " e  h7 h$ U, ^! k5 [, e4 T( M
• 
  & D; S- O/ E+ R) E. ^; T' N' G9 r& Q
  1 O+ D* u3 b: D2 C+ A}  
  ; P* }- b0 G- [* m$ {
  
• 
  
  / m& O! h( E9 Q5 ^, ?: S: m/*输出函数*/  
  
  % g0 K) E+ ~# T2 D
• 
  
  7 B) j. Y0 d- p+ y0 n& e  O. vvoid prt(char algo)  
  
  4 J  r* E1 m- J! x
• 
  
  ; J6 H% e5 t+ r: S{  
  # V7 ?6 J! E( P$ ?& u
  6 p9 P6 V+ ^9 m) s  x1 }4 Z4 V
• 
  
  0 {- ^& U7 ^9 d4 E4 @3 G   PCB *p;  
  
  " r+ E) n3 o) J, X
• 
  
     prt1(algo);  /*输出标题*/  
  
  ; r7 F* k' a% Z( [7 w$ f
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  
  3 P$ P% L/ Q5 p0 c/ F
• 
  9 G0 F  m/ d) T/ S2 D7 r
  1 d- [2 q7 G- f- B; h      prt2(algo,run); /*输出当前正在运行的PCB*/  
  ( B  L) ]+ R/ T9 N  E( v! P6 i  n
  ) F% R/ B7 D' k  V3 \
• 
  # S8 L/ o+ ]7 S; @& D
  ) F2 P: L& U! `- _6 q   p=ready;  /*输出就绪队列PCB*/  
  
  
• 
  
     while(p!=NULL)  
  
  9 W* n! V7 w2 z% u8 y
• 
  
     {  
  # s  `3 i6 p& a  o
  7 d" Q, ~6 ?1 H6 R+ S$ e" P
• 
  
        prt2(algo,p);  
  : V8 g% D1 I' ~& l- ?
  
• 
  
    k5 @' t; V2 L" x3 c6 }      p=p->next;  
  
  0 |2 c4 b$ B4 C+ }! [1 t
• 
  
  4 J- _2 N# ?1 R$ G$ s* Q! H* [   }  
  ' \; r/ }0 u9 R& W! S* f
  9 D, Q: ]. j8 k0 L' i
• 
  , g% v- G. Q. ?6 c
  6 i" h! ?" [, V+ K   p=finish;  /*输出完成队列的PCB*/  
  " r- E% |* P$ Q& j# W
  
• 
  2 u; N' u  D; h! D$ H
     while(p!=NULL)  
  7 P8 }: V- L" y2 V1 s$ B4 V" T/ X
  * W0 E- L/ q  l9 G3 X, h! s
• 
  
  9 [. v* i  H5 l* [- @  u$ J   {  
  
  
• 
  ; x/ z( C: e9 K8 S( _
  1 L% x; j4 J4 o, |' B' N) a- o- y      prt2(algo,p);  
  # b6 v' {$ r% B  T( e$ K5 V0 f
  ! ^! Q2 l. Y. O. M  E; e
• 
  ; W( ?6 m3 d; o$ e# q& ^/ L
        p=p->next;  
  
  * t5 }( t' l' m3 m1 V
• 
  
     }  
  
  
• 
  
  4 m0 B& U2 C  v! n$ i# P   getchar();  /*压任意键继续*/  
  , Z) V/ Q6 c  t# z* k) H: U% b! l
  % e5 h% I7 i0 E3 [6 V1 \5 z
• 
  
  4 i) R6 Y: V# F* c; \  x2 _- }. |6 n}  
  
  9 U0 Q' v, s( h  V! V! j+ n- z
• 
  ' O- a1 G8 m) P8 H: ]' t
  /*优先数的插入算法*/  
  0 h6 O$ `( N. o
  - {+ ~) A& D! |- {6 Z0 `( z
• 
  ' ?: \$ e. k# F
  1 {- A6 e% F# {! r# einsert1(PCB *q)  
  
  & f( @2 m1 v6 i7 f
• 
  ! I- n# I# n4 j: G* n$ n% {
  ' b6 S9 f1 Y! C- o{  
  7 [' U3 ~8 l/ l8 i" T+ K
  
• 
  - m4 S. S' r, J; V0 l2 r. R
     PCB *p1,*s,*r;  
  
  
• 
  ! F, x1 \6 V2 C' ^  D
  , ?# }1 N. I% C1 O   int b;  
  
  6 s) `( z2 J; {: _
• 
  * D/ o, A+ y; P& }, o9 Z
  " B9 w! Q+ z/ s* x; \   s=q;  /*待插入的PCB指针*/  
  7 Q/ T: N+ V: T- K8 W
  + [$ F3 q$ n# k) f
• 
  
     p1=ready; /*就绪队列头指针*/  
  
  
• 
  ( @7 S; }4 ~4 h$ F, ~4 Y. ?
     r=p1; /*r做p1的前驱指针*/  
  
  
• 
  : W1 k! ]2 v( @. A
  ; P* p/ s1 l. f( f   b=1;  
  . v! @4 r3 G" n! p; b
  
• 
  9 A2 j  ^$ h5 ^6 n1 r$ a
  . f, e4 ~  z( z9 b% H/ G4 t5 j( e& L   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  * l8 m" Z2 K# `
  
• 
  
  9 P1 ]" ^+ ~: ]# x" O6 _: ~      if(p1->prio>=s->prio)  
  
  7 B1 T. }! ], f% U/ s8 ~
• 
  " J2 w8 v+ D, W$ q4 Q
        {  
  / k! g0 R$ u+ n
  
• 
  ! Z) Y2 z4 X  B1 }4 l/ W2 D
       r=p1;  
  6 @& o- `6 g. C1 B4 Z- S. [
  
• 
  ! n( {# H2 z1 p
       p1=p1->next;  
  
  
• 
  ( b/ g  M' g8 a6 ~0 u8 Q- R
        }  
  5 j! w0 `$ a$ I5 F" t( V
  
• 
  
        else  
  % p% e; ~6 R7 {! G$ a/ X% A* @
  
• 
  & P/ v3 _/ ^+ ?- d# Z  W; s  S
  " q1 R; q; C; V* V5 ?- _     b=0;  
  & @2 X) s: F; `' P1 S$ h
  
• 
  , z3 |* h: y4 x8 Y( M9 d% _
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  , a. _( q9 `9 t( X  c0 z& v
  
• 
  
     {  
  8 T  P& }2 V. ]9 R4 Y
  
• 
    u! N9 l; m7 p) o, j( n
  . J1 d5 w  T+ E( S  a  H6 N      r->next=s;  
  
  
• 
  5 b$ Y2 i" c4 I. N
  * {- x( @4 M- B1 m! \      s->next=p1;  
  ( ^$ {: o2 E* I0 e9 D5 p
  & n" `2 S. N2 I4 K
• 
  
     }  
  
  # U/ I6 j; V0 v$ X
• 
  + w) n1 [* d2 ?! c
     else  
  
  ' t9 J  S$ `( e2 \' C* I
• 
  
  ( I/ z. y; }) ^0 ~   {  
  4 l3 j" d! x: v+ Q1 g+ M& Y
  
• 
  
        s->next=p1;  /*否则插入在就绪队列的头*/  
  
  $ s/ D1 k  w% f6 z5 v# {! V
• 
  
        ready=s;  
  
  
• 
  
     }  
  
  
• 
  
  7 t1 |# F: m1 E# i2 n; s% R# p; D' q}  
  , f( d0 b/ P2 g1 L4 l
  8 M% t2 i  F' ?  P# k/ N# l
• 
  % N8 K! D. h- A$ L$ F2 d2 B5 c
  /*优先数创建初始PCB信息*/  
  # G9 j# b* _) f
  % U) A6 I! _+ t9 Y6 a# ]1 W
• 
  0 I/ i' q: l; e1 ?- T
  void create(char alg)  
  9 C( f# e3 V# f; c+ b9 K
  " C( h3 r7 ^  D
• 
  
  {  
  
  / M# A) U2 H6 v  [* e# `
• 
  
  ) a+ ]( ]- b" s   PCB *p;  
  ! q- |9 m. K; b9 R! ?4 F/ r# A, |2 V) @0 C
    @6 M1 B7 I' a1 {" Q9 Z% h
• 
  0 S# D- d9 C7 [! V- @, N+ O# S* X3 [
     int i,time;  
  
  2 l/ z, A6 {" ?) I
• 
  / Y6 g: P( G1 Z" _
     char na[10];  
  : B2 S" C$ _; [$ `5 s/ G" h+ n
  
• 
  
     ready=NULL; /*就绪队列头指针*/  
    r; x7 u+ L" q: J
  3 [4 A2 G& G" m# b
• 
  
     finish=NULL;  /*完成队列头指针*/  
  * C# x9 Q+ ]# j* Y9 I& e( ?% x
  7 X% W+ b+ V0 d  c
• 
  ( W2 l, ~& w+ }* {" ~5 j# z
  ) q" T. {: E6 K8 {   run=NULL; /*运行队列指针*/  
  3 i7 q# l/ M$ U" M$ n& ^4 f
  2 k' f, W+ X8 Q# I2 x; c$ P5 m
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  - S* ~; c0 t  h, P  K. e) N* j" q4 A" Z
  $ X0 t- S  o  b3 T6 r: m/ B. s9 H7 o
• 
  
     for(i=1;i<=N;i++)  
  
  ( k2 Z4 S0 B4 W* @5 t) _
• 
  
  # k; h! g/ j+ U   {  
  ! @. X6 \4 Q5 J" z( k
  
• 
  
  & O( u& E" O! B- y& |      p=(PCB *)malloc(sizeof(PCB));  
    @$ @1 m8 m' Q. t
  
• 
  * ~3 T4 B5 K7 h+ t
        scanf("%s",na);  
  
  2 }- N$ @  B2 g% C( g. D- P: W$ `
• 
  
  ( t7 u/ Q+ @5 S      scanf("%d",&time);  
  " t' J2 e' p. H9 _* e
  
• 
  9 ^9 ~& I, d$ |8 X
  ( b) S: p  x4 M8 e! V" T2 w      strcpy(p->name,na);  
  ! R5 A) d1 X( w& o. T. q
  1 X+ y! _+ H/ T% R5 J( {
• 
  
  ( a1 v- N5 x$ D  d      p->cputime=0;  
  
  
• 
  
        p->needtime=time;  
  4 l4 u: Z8 d, M/ n
  * c, {4 }) u% p# ^1 G/ E
• 
  
  ( L3 R8 J+ f2 |/ Q. m      p->state='w';  
  % W+ ]; d# ~" F6 O& g  h
  
• 
  
        p->prio=50-time;  
  
  " q3 O6 _' Q4 _8 V
• 
  
  8 ^1 J/ t+ u/ O2 u      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  6 h9 c/ P! _5 H0 l& K5 _% K
  6 T5 ]) l/ F# B& |" f, r
• 
  
       insert1(p);  
  ( j9 \& N( T! e0 @7 [. }; Z
  3 z4 ^2 j2 P, Z; Q( R( G8 w
• 
  
  0 B0 l9 c; N9 R6 b& D      else  
  
  9 K) |, K! h- K* I  [
• 
  ; J- [8 ]/ b9 p* R% R3 S+ K. U" s: g
  ' ~4 a8 Y% H' ?; R2 N5 ~; N) i      {  
  6 N# \( \, D9 \& o  D5 X
  * x6 d; t( _( {  k
• 
  ( {, K7 s3 ^3 P) I
  . G6 E8 e# {& X) t     p->next=ready; /*创建就绪队列的第一个PCB*/  
  , N' M) ^1 ]$ b6 r5 s% ?
  
• 
  ! b7 \3 t7 q2 o+ \* n$ w4 o" |% q( `
       ready=p;  
  5 N4 p* j. x. ?. a& D5 `
  
• 
  
        }  
  2 d6 A) A- _2 V) n+ u  W9 J' @
  
• 
  0 I! I2 ~5 N: d8 J& o8 Z( p
  ' {& u( z2 {9 `8 ]   }  
  4 a3 k: v/ ]: a+ r9 R- y  I7 H
  
• 
  
     printf("          优先数算法输出信息:\n");  
  + @+ F! A! ?. i1 m6 G. q( \/ C' f
  
• 
  
     printf("************************************************\n");  
  
  
• 
  2 `0 k& W: k! i! t. ^
     prt(alg);  /*输出进程PCB信息*/  
  & |% M& [/ g: \" {8 Q7 b
  
• 
  + A1 L# n6 Z' p& E" Q1 l
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  
  8 I- c& S& m" T+ ]% N   ready=ready->next;  
  5 K4 ]5 A6 P# q4 i4 s* V& y- M
  
• 
  
     run->state='R';  
  
  ! ~2 G8 r7 J! v4 v: R! }4 H4 n
• 
  
  }  
  
  8 w5 p! A# M5 s5 ]) }
• 
  + f2 O3 T5 W: e+ Q9 ~3 Z
  6 J! p# B2 ?) X% s5 y/*优先数调度算法*/  
  
  
• 
  
  ) O, j  _5 ]" ~9 F2 u2 lpriority(char alg)  
  
  " s& J2 }# Z1 H  w* ]2 Z
• 
  
  {  
  ! R  c4 e& H/ a2 ?8 L
  
• 
  
  * z; a2 ~- j9 d5 k( Y& q. V   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
    s7 |4 y" `: k5 \, `. u
• 
  1 I" a: s+ I- R% a' J: _
  + U7 N' P2 b) q# ?9 `   {  
  3 @2 g! l1 g) j  i
  
• 
  
  2 I" v4 q! o7 W' b      run->cputime=run->cputime+1;  
  ' u0 _& q, x2 {; i3 f5 Q$ O
  
• 
  + H; X7 A  e  V0 Y6 S
        run->needtime=run->needtime-1;  
  
  1 M7 L% H9 y# B8 d
• 
  . e: I+ w, m( v2 w
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  $ w1 O/ E5 p0 P2 v& b5 V& f3 _
  9 h: T. E- y# S* w2 ^4 L' }
• 
  0 P% E$ X" Z  i7 R. P
  3 X% k0 l8 n9 {" ]" r% {* _      PCB *p;
  2 ~; j/ U; [# L5 D$ r
  , j3 p% y* j% ~+ w& [% V' C4 ?
• 
  
  7 }/ F$ }/ X/ N1 Z# c      p=ready;
  ! j9 t+ U; L' `: r
  
• 
  
  $ |) Q7 b1 w* T3 f1 m" U      while(p!=NULL)  
  
  
• 
  $ y/ L/ l6 S' T! t+ a/ j
  " c; a; r, y$ m9 Z      {  
  - ?; I- \# Z- [; P. S$ O7 ?
  0 t# O$ `% g+ ], p) z  K/ P
• 
  
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  
• 
  
            p=p->next;  
  
  ; k5 M, {' I: O2 h9 Y3 P/ x
• 
  
        }  
  
  4 _# m4 i0 [2 Y' p: C: o
• 
  9 V0 ^- V" f: f/ G" r
  # q, h5 a( I  H# I1 p; {7 _      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  2 d. S! x$ G# h2 G- c1 r
  + ^3 ^5 Z, e1 t+ O7 \& ~
• 
  
        {  
  1 T; w" {6 G6 D
  
• 
  & B! t2 J, s9 ]( c$ g
  1 T! Q1 F7 ^- Y2 K7 t: A; n         run->next=finish;  
  2 R# \. r. ?. V2 U
  
• 
  ! H( N4 A/ q# r/ L  W
  4 [" W& p7 M, j* `% K& v: y6 b9 x0 t         finish=run;  
  
  1 e6 Y( s1 w. @
• 
  / a) O5 {, M* Y4 h6 U+ O# T$ b+ D) ?
           run->state='F';  /*置状态为完成态*/  
  % z6 N+ w% l0 |, i4 U
  3 o$ m) Y! _$ A9 S, d+ |
• 
  
  : c; c3 H. q  w3 q         run=NULL;  /*运行队列头指针为空*/  
  ; A3 i9 z* s- @0 O& X/ Z
  
• 
  
  . c2 b; r  I3 h( w8 U! l         if(ready!=NULL) /*如就绪队列不空*/
  1 |9 z7 e4 I5 j5 u
  9 Z  r* ^. ]6 a% A3 S/ R3 J
• 
  
    z" E% |' y2 K7 e! m3 Q         {  
  2 _" p! }5 H" M) a
  ; F  C9 C' o% e( I, W
• 
  : [* k3 j' _; ^$ ?6 F; v8 A/ `0 K
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  
• 
  
  6 v( I* [) A8 T9 d" l* x' V         }
  9 S/ J) ?7 E1 [- ?: A. [" N0 w
  
• 
  
  ' y8 T% X0 g+ o$ e$ b" t      }  
  
  # T: k8 H: Q0 I; m5 Z
• 
  
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  ; M  {1 h) X1 I% K3 b
  ' x  R( _4 ^4 ]8 ]$ Y. z' x     if((ready!=NULL)&&(run->prio<ready->prio))  
  0 Z2 D8 _( o1 g' [( z, M7 B
  4 T5 I) J! s* z. b7 Z
• 
  0 l1 b. k5 \& F% V% H- t6 o
  : P2 p* Y/ z" @0 f2 O     {  
  1 ?  p+ K$ Y# N; ~2 t7 E- c0 k
  % d: L0 y0 D& B+ V( D- [
• 
  0 V$ V% r( _0 p, d
          run->state='W';  
  
  ' o4 _: f3 J! d) b; t; ~
• 
  % n! |" w& x' p1 p, g' _
          insert1(run);  
  
  
• 
  
  ( L& z! m4 s. r4 I- a        firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  7 U: X) g, P" x9 m
  2 l- S+ d4 n/ q- e4 D     }  
  9 R8 ~2 d5 T3 g" N) F& ?5 L
  ( D( ]# D: D0 I6 u0 Q# `
• 
  
  / a  z/ l$ Z0 ?1 N  L      prt(alg); /*输出进程PCB信息*/  
    \, H( ~8 q" l) Z( V  w# @
  7 y  x4 v5 c* A  X
• 
  
  + h2 ^# Q7 B  j' [, [   }  
  
  - T* t- L% y8 Z8 R. ~2 `) f4 S8 _
• 
  . |9 V7 y7 U2 N, O. C
  - o7 o6 e! b8 w( L( x) u+ `0 O4 N}  
  
  
• 
  
  /*主函数*/  
  
  7 o8 ?, s* R' g& @0 z
• 
  
  main()  
  3 U# k' Z( Q; F
  0 m% ~, G0 j6 L6 c3 f% Y0 g9 N- q( i
• 
  1 j% W. S' Q5 |9 M2 J7 G5 ^' i
  ) S2 r) ^/ n3 r{  
  
  
• 
  
  4 m& X. k& k; R- {   char algo;  /*算法标记*/  
  . G% W/ ~) X5 @$ @: s2 W  v
  
• 
  , p0 n5 q- c5 c
  + b; p  e- ^! x( N5 G   printf("输入P确定算法：优先数算法\n");  
  
  . q' q8 v% [0 m1 j
• 
  # _- k: U3 A& \+ ]; k
  $ Y5 x) H4 P. {# Y   scanf("%c",&algo); /*输入字符确定算法*/  
  
  
• 
  # h3 M2 j8 J( H. \' B! k
  ) X  k' l; I; ~   printf("输入进程数：\n");  
  & g0 t+ J, Y0 \/ L( V1 z$ Q) {
  
• 
  & M) m: e; `/ |8 \
     scanf("%d",&N); /*输入进程数*/  
  5 j7 }  c' F3 U+ P$ T
  2 K1 a! U/ R% Y$ }/ G! ?8 R) ~- O
• 
  ( ]4 q* P& `# U2 i# i
  ; e/ L9 m4 E3 P7 h) Y7 `7 ?- Q   if(algo=='P'||algo=='p')  
  ' o; g  w- X/ O/ y/ {& i8 o1 V
  
• 
  8 u1 C' n( ]% v
  : f8 A" b; l, k% e; `   {  
  
  7 d9 K/ S% q7 i& B( \0 Y2 o# g  L# e
• 
  
        create(algo); /*优先数法*/  
  : |* i# Z$ b0 x: t. h  c
  
• 
  
  $ a# e: y# O: p2 P/ ?      priority(algo);  
  # G8 F( N- \( X7 {8 a0 x: o
  
• 
  
     }
  
  
• 
  
  . D; l& Z& s& h; Y) l}
  ! D) F; t1 _& x4 `
  / O( T1 j. T" n4 R! j! T& ?2 W
  & G7 V# t( ^- o: K9 h

$ w+ a2 J. M9 O( H% @# H输出结果：
% i2 q9 \% B+ f$ v3 p

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