优先级调度算法

杨利霞

6 j  j5 e. ^  ^. k* U4 i优先级调度算法
8 e0 F4 w. W1 q5 O: k* v

算法介绍
" f/ J8 p& N% C1 {) m优先调度算法的类型（用于作业调度）
* t# G/ n- p) P* c- H7 t1）非抢占式优先权调度算法
. q' E; T' r0 _8 p# J" Z: l系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
! b) P& S% x2 A! ^9 N2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权
2 K, a, \, X9 a3 i( i

算法实现

抢占式动态优先权：

( Z9 Q: L) |& u* g! d2 w1 ?PS：本人认为非抢占式静态优先权没有实际价值。

• 
  
  #include <stdio.h>
  9 B6 `7 P# U2 q. ^, i4 \3 B
  
• 
  5 h$ J- f2 M' b' U$ q1 w, U1 [
  #include <stdlib.h>  
  
  & h+ Y9 K& `1 z2 R1 u6 |% U4 @, _
• 
  
  7 u; G% j/ [$ {' t7 b#include <string.h>  
  6 T# ~( O& b# s4 Q: n: d
  % q2 h  H- e/ Y( I& s, k; }
• 
  + Z- R, s* \% ]- h9 L2 |
  5 n3 s3 o* g: A& Qtypedef struct node  
  
  
• 
  
  {  
  ( s, L& N- c$ F) I
  
• 
  9 l; B: a7 I0 H
  : \, }) c' S# T; I# R$ \   char name[10];  /*进程标识符*/  
  
  
• 
  
     int prio;   /*进程优先数*/  
  
  
• 
  
  8 f  h, {3 H# L: e6 \   int round;  /*进程时间轮转时间片*/  
  ( ^1 p9 M. j# w4 S0 l
  
• 
  
     int cputime; /*进程占用CPU时间*/  
  
  
• 
  
     int needtime; /*进程到完成还要的时间*/  
    F1 @0 K( R7 w; M5 P& T; j
  
• 
  : y3 ]% V% ~2 B' E
  3 C# F, W3 i: l   int count;  /*计数器*/  
  
  $ r# B& r7 {+ p: q
• 
  
  , ]  P0 |9 j  d  x, b% I   char state; /*进程的状态*/  
  8 R9 p0 @3 |) n
  $ p, K. j0 H# ]" W3 ]/ X
• 
  6 O5 ^* a. }# S1 Z
  7 V# P- G6 c; ]1 I# C   struct node *next; /*链指针*/  
  5 h, t% V0 G! s- k# B
  
• 
  
  : m; }4 w8 [: Q: Y; ~}PCB;  
  1 D! h& P' t1 H4 ^2 y6 F/ m3 V! X" ^
  7 G/ A5 ^7 k' X5 L, N
• 
  ) y, K( k. U, K( [
  5 d( ~1 n: Z$ {% B+ U$ V. vPCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  
• 
  
  ! C* z% ~0 |, k# F. ^# B# b- ?int N; /*进程数*/  
  
  6 `0 f- Z( N9 n! F# a: M( y
• 
  
  /*将就绪队列中的第一个进程投入运行*/  
  
  ) Z, V* \* Z# l9 z7 W
• 
  9 o: x9 o% a: f$ x# U
  firstin()  
  
  
• 
  5 _; H* X( `9 v+ C. Z
  8 u' E' q( g! r6 e/ g: b" X{  
  
  # U1 S( Z, a/ F5 F4 o, _# [
• 
  / A1 g9 a& V& j( {- L
  ! F' D! K' k7 b1 I2 l  _+ K! }: z   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  ! T. n2 O0 j' L
  
• 
  0 t* F9 ~9 L! D' S5 M0 G
  - h& g9 U( o- V# _8 ?+ G$ V, S3 O1 H   run->state='R';   /*进程状态变为运行态*/  
  9 u5 N* \* V! L! T3 `- b8 V& A8 u
  
• 
  
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  - K7 M1 c1 m; ^
  
• 
  
  0 x) W5 z* s/ O, u+ B9 x5 n}  
  & G2 f, h. g1 [1 {) D7 t: H
  6 ?2 v4 `6 j' a
• 
  + F2 E% B$ q9 p. M* [
  1 j6 |2 K  b( h/*标题输出函数*/  
  
  ! H' @3 v+ h- y+ B
• 
  ! F5 t7 K9 e1 k. G2 n
  6 ^! v/ U' Y8 V; Xvoid prt1(char a)  
  & s, p( l+ Q6 A
  
• 
  
  {  
  ( C0 {  R) X3 ?
  6 X& W& x( c8 W+ ]' P
• 
  
     if(toupper(a)=='P') /*优先数法*/  
  
  1 s- O% s9 d- S6 I1 t% w: s2 M
• 
  & _2 g5 }+ e0 B, r% L4 v$ D- |
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  ' i' L( h/ B( m2 L. ~) T$ n
     else  
  : Y- w: u3 B- J. @
  . V* r& ^1 O% J# c2 |3 o! u* e
• 
  % W2 h/ Z3 D2 E! U9 i  z% o
  $ M; v' D, w# @( Y      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  ; z- O9 k( D! J6 Z! N
• 
  8 c- Z) t( A/ z
  }  
  
  
• 
  0 q) ~7 S7 e( `
  $ g# b2 L. {; {) U, B/*进程PCB输出*/  
  / E2 K: U% o$ o% s! T4 P. @+ ~
  
• 
  2 o6 P/ T4 ~0 {; D4 g
    `" G$ q7 M. X% xvoid prt2(char a,PCB *q)  
  . {8 V- u! ^% Z. i& j) d
  
• 
  , g: l; o# g: V* J/ r  J9 Y
  {  
  1 p7 ]- K5 R$ i6 F( L1 V
  
• 
  
     if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  9 M  q  [; y. L
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  1 I, h5 ^: g- w; c# F* u
  ) i7 ~6 t* ^, m: ?* R; D
• 
  0 m/ R5 C+ B0 g1 V+ d7 T9 f: u2 R
    }9 K3 n! Z9 p, e5 u- A       q->cputime,q->needtime,q->prio,q->state);  
  
  
• 
  
     else/*轮转法的输出*/  
  0 p  M4 f0 y, b4 D0 F
  
• 
  
  8 A1 c6 k7 j, X; G" j8 \+ Y      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  
         q->cputime,q->needtime,q->count,q->round,q->state);  
  
  " i* W. i$ }; p3 K
• 
  
  }  
  * Q" Z  |( P( a2 R" Z$ v% h: M
  
• 
    m, |+ X1 B) _
    L" h: D" s9 p3 b+ P5 T- X/*输出函数*/  
  
  
• 
  6 M; }! p: x9 X" Z
  " P/ H; l: F  @8 m  d! G5 C" w7 avoid prt(char algo)  
  4 r% V" x$ I+ q5 u9 U
  - c( y: ]. F( p
• 
  / U8 f1 W* x3 o5 K* v
  {  
  
  9 j( J. z2 M$ X$ z
• 
  , E( a+ b2 _: ~0 \( p1 L
  : |9 f( c; K4 q# Y0 h! Y1 {% o  Q   PCB *p;  
  
  . i! [* C. s5 ]) y4 X* o* M9 S
• 
  - `& e- s( U6 B, L6 L/ W& U
     prt1(algo);  /*输出标题*/  
  
  
• 
  & E; m% z/ {) s# t4 y7 u
     if(run!=NULL) /*如果运行指针不空*/  
  
  1 c3 C, u; J7 o) ^& k2 q
• 
  ; t- R5 }' ~( k6 e2 p/ S& h
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  ' ?1 p$ N& @+ C5 w5 T- X: z: j" L: H
  
• 
  * l, |, M; x; J8 h. P+ {
     p=ready;  /*输出就绪队列PCB*/  
  
  $ e6 z  F; K( c& J1 N) x; W) r) A6 U
• 
  # F+ T; V# F+ ^$ [
     while(p!=NULL)  
  ; a5 D& r) t. @2 h% O
  % g8 Z5 l1 V: r
• 
  
     {  
  ! `3 q" S) e; l  P
  
• 
  ; |! m/ Y$ n' ?% c
  9 y7 Y/ T9 G4 B+ ?  q0 t      prt2(algo,p);  
  
  
• 
  
  3 t. ^/ W) X! H1 Y6 U      p=p->next;  
  
  1 f3 P  {$ y0 m7 s
• 
  ( G2 a5 e# @% s: i/ M( z" g
  7 S( D- ]; O% C' i1 `0 d+ n* Z. h% y' V   }  
  
  
• 
  # ^6 n7 R, o6 K. Q1 q' @
     p=finish;  /*输出完成队列的PCB*/  
    b/ L8 G2 [; B9 h  w- z
  % a7 |& q4 c7 E" j( ]- K0 K, }
• 
  / N( O. C3 }0 W- R+ \1 A
     while(p!=NULL)  
  
  6 }( T7 [4 K" `; f7 X2 _
• 
  
     {  
  ! p- W8 Z, q" a
  
• 
  ' a$ ^' ?! H) p2 F' N  h
        prt2(algo,p);  
  " R8 f5 J/ W! u) c# X0 l: {" c) F
  
• 
  , x, ~+ o8 ^, Z
        p=p->next;  
  8 L* f3 K9 r" K( X) t3 j  V
  ( A7 _6 k8 H9 t) z3 y7 p  |
• 
  
  " @5 u9 ]* R5 \/ g/ I! A   }  
  8 a! R6 u8 E" `  N
  
• 
  
     getchar();  /*压任意键继续*/  
  7 g2 O/ S( B4 z/ Z6 E
  
• 
  
  , o$ K7 o; h! F( N8 x4 A. t, S/ P}  
  % |# J, P% i. Y  B, T" @
  
• 
  6 r1 d8 p$ e, O) A: X) ^' g$ a
  / s) z: X4 _9 y: |- S& ]- j8 ?/*优先数的插入算法*/  
  
  # |) J+ p$ D% v3 n2 f# L" j% R
• 
  
  insert1(PCB *q)  
  
  
• 
  6 G! g! j' H( _3 C# B* ?
  {  
  0 c( k# ~" y$ x; w
  & j7 r( v' }& y2 F, ]) A
• 
  6 p' h: ^$ _! x$ P, O
     PCB *p1,*s,*r;  
  
  
• 
  
     int b;  
  0 k4 A9 d& _# q) j, F
  
• 
  
     s=q;  /*待插入的PCB指针*/  
  # o: s' n0 I  |% l' s
  1 I- d$ [& ?8 K: I# a; {
• 
  ! ]" t) l, Z3 \  t
     p1=ready; /*就绪队列头指针*/  
  
  
• 
  
  / ^1 D1 d5 K. v7 R3 X# ^! h0 U: Q   r=p1; /*r做p1的前驱指针*/  
  ! E: m6 c# g8 Y4 p1 o
  
• 
  
     b=1;  
  
  
• 
  / T* H! d( w) a' S3 g, j: W
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  ! ^% s% g+ C. G  V& S# k: N" w
  
• 
  7 B3 L1 N; J8 t. l/ ^
        if(p1->prio>=s->prio)  
  
  
• 
    f" u# G! j3 K1 I) v
  # n. R" t! i0 o. Z: t# F% c      {  
  3 }- \& Z& d! T  p7 h
  " W+ k) Q% O' x0 M! q
• 
  
       r=p1;  
  
  
• 
  
       p1=p1->next;  
  
  
• 
  
        }  
  
  9 j  v: p3 H, K4 t+ I4 |" ?
• 
  0 m5 K) M3 M, t' Q  y
        else  
  
  5 x0 e# u7 S9 Y8 N5 }7 A# {/ }
• 
  6 Q3 l' J* @* g. O: B* F( J
  & Z: F9 D3 r, M4 ~; ?  G1 n4 s     b=0;  
  
  , M; M# F' f# A$ n% h0 X
• 
  
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  , a4 W9 G& {2 A( ~) U% M
  # _1 k$ c! P! S# g
• 
  7 X, r" ~6 n$ V2 k1 C1 m) M
     {  
  
  1 M" ?5 m5 ]7 Y- f9 ]. B8 `
• 
  8 L' U' {, s6 n5 N9 G; @& l
  6 Q! N1 q3 i3 g$ \) S8 |" `% D      r->next=s;  
  
  
• 
  2 P: m: D: w6 o! l+ ^
  / E2 p. c$ H: i$ m      s->next=p1;  
  9 q3 U6 m6 g0 Q
  " o3 O+ ]4 R" |( f, U* T% l
• 
  ! F5 z* J) m/ a3 B" D1 t
  0 B: }0 }/ z( a0 y   }  
  
  
• 
  
     else  
  " R. F: ?" m( A( M. ~& H
  ' W/ w% q) F; e5 y" g; B" \! s* Q
• 
  
  : r2 q* d+ {7 t0 ]& Y3 p+ k   {  
  ; y* ~) E4 W: [
  
• 
  
  / Q$ D+ m5 x" C4 Y4 Q      s->next=p1;  /*否则插入在就绪队列的头*/  
  " n  N1 x4 D; Y
  
• 
  
        ready=s;  
  
  
• 
  
     }  
  ; E1 f  W, _/ W5 |# K
  
• 
  
  - B* A- T( W7 {}  
    J. m0 O9 t1 \( a
  
• 
  8 a" z2 W! V/ H1 `
  , T. T# W: @4 W/*优先数创建初始PCB信息*/  
  4 t7 _! k4 |: R* K$ @
  
• 
  
  void create(char alg)  
  + j6 l! ~2 S! k2 s! f% T
  % ?7 ]8 u4 K, B& e: z
• 
  
  {  
  / @7 n5 @, Z, M; p
  4 U1 P9 E7 J/ w! W& H
• 
  ) \% S0 W/ }4 t# B( I1 v) p  q
     PCB *p;  
  
  7 h( W/ n' c7 x/ \( R2 f
• 
  - ?7 ?# H. l! a" k
  5 v+ _# a, v( M7 S) p* C$ R   int i,time;  
  . E0 k) s& J, @  F- ]& k
  
• 
  
  ; l8 W# g1 E) n   char na[10];  
  
  5 p$ {5 d1 ?" |& x
• 
  
     ready=NULL; /*就绪队列头指针*/  
  " J" K0 R. j3 `
  
• 
  0 c: U7 s9 y- R7 R) T6 w
     finish=NULL;  /*完成队列头指针*/  
  9 g5 T! n+ H) L9 G- V
  7 s, v- u5 G5 s: i
• 
  
  , q0 m4 ]- O1 H9 k0 Y' W2 w   run=NULL; /*运行队列指针*/  
  $ A/ X1 }0 D7 n/ C7 O8 b7 b$ n
  % y% Q! b; v, |
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  7 ?* M5 F  X7 s5 ^
  % @% C9 K/ g5 R! d) P
• 
  
  9 v8 E/ C* i# {6 ~! v% v   for(i=1;i<=N;i++)  
  
  ! e8 I) e+ }( r, R& z2 |
• 
  
     {  
  1 B4 b( u6 d$ D
  : j3 B6 Q. J% c) c5 n" ^
• 
  & p8 c9 @( b; S4 e  b. l/ k
  ) i) B  X! s2 R* x3 J      p=(PCB *)malloc(sizeof(PCB));  
  ) b$ s; \7 M* L% ?  g
  
• 
  4 _2 n9 }- r% y9 g
        scanf("%s",na);  
  
  9 x  W9 o3 w8 i' ~' N! ?- S
• 
  
  ' D+ A$ }# R9 r! `4 Z      scanf("%d",&time);  
  ! t4 G, W  m+ w. a
  8 y7 N1 p# J; s& [4 n
• 
  
        strcpy(p->name,na);  
  : I2 Z4 g4 W7 l. U- `7 ^9 P
  5 W' t) m# y; @, O1 d
• 
  
  ( B+ _/ R. N; u$ M3 n      p->cputime=0;  
  . W# R; D" w: F6 A3 E+ E' j: q4 X2 A* K
  
• 
  * ]0 E1 S5 Z7 B- z$ m
  : p% Y1 D9 g2 y6 V& V      p->needtime=time;  
  ; H# b% q3 [/ j* A5 C: ]/ k; T3 b
  0 d* y8 V( R+ j" V
• 
  
        p->state='w';  
  + K/ ^- c  j( Y# G
  5 G0 V9 \* _- G% I
• 
  
        p->prio=50-time;  
  
    l2 `2 J  D2 O# Z: R6 l. x
• 
  " O9 A" x* E9 D* l9 k
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  
• 
  
       insert1(p);  
  $ _' U5 x  n! X0 s
  4 F! B; ~! s) x/ s+ H& {( p, _
• 
  0 K) ~8 K4 X  Q/ F# O
  7 ?( B9 n( _7 q7 |7 P& l4 U; F      else  
  
  ( p& m6 {$ k( \
• 
  
  ) b2 S$ V) I3 n$ B3 l      {  
  
  7 V' o- I- {" Y- r& M* [4 p
• 
  
  & C1 g% w$ u3 {     p->next=ready; /*创建就绪队列的第一个PCB*/  
  * i& ?8 d, e1 P. z7 K! ]+ U" h8 R
  
• 
  
  5 z0 {; }" W9 \: e9 J0 W     ready=p;  
  
  
• 
  
        }  
  
  3 M4 V: a# b- `9 L8 h
• 
  : d% P) `! M3 z9 l
     }  
  4 e* ]8 W: e! G
  
• 
  1 i( v# \! `+ ^4 v& k8 e! z
     printf("          优先数算法输出信息:\n");  
  # l( i5 Q1 K! S" Y
  4 c2 b1 F4 v$ d
• 
  0 L+ i- g4 P6 P$ F
  - M( j8 Z8 E! Z- o   printf("************************************************\n");  
  , _" n/ J' y: V  i+ n/ `
  
• 
  ' y  g% u+ V0 u3 a: W
     prt(alg);  /*输出进程PCB信息*/  
  3 ~' g  R/ x/ N9 b5 P  n& d2 O5 z' Y
  : B5 I+ w5 ?7 X* }! Q7 ~7 h1 X
• 
  0 ^4 y9 O( V. w' D: ]0 u
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  , K6 Z1 |6 n5 d, o) }' D  r8 _
• 
  2 w/ g! ^; t% k2 U# u
  3 N$ B6 Y2 d+ x, U# o, ?  O/ D   ready=ready->next;  
  
  . W+ L* G  J' A! t- I9 I: E
• 
  9 O) q  a2 x2 S0 T# d# A7 K
     run->state='R';  
  
  
• 
  3 T/ Q8 n, L0 d0 y' f) x
  }  
  
  
• 
  & c- w& e; I8 E4 H3 z
  /*优先数调度算法*/  
  5 j5 e3 z5 Y' Q. w* {& L
  / I6 e4 l8 h% @
• 
  
  priority(char alg)  
  + H0 J" ?; [7 l8 p" t8 N* w. r, q
  
• 
  & k5 y8 |6 D, J! @( G; D7 {! x
    R) J1 m: u  f+ m8 v0 i{  
  3 Z$ ], ?7 L( M' I! n3 ?2 [$ N$ k
  & C& d8 M( ?7 t2 i4 H
• 
  % _  }0 ]- N% L/ ^  q) g8 }6 `
  % T) u5 h3 c. o( ~   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  
• 
  $ l- Q; \/ W. d! J9 J
     {  
  - O. h" d6 ^. K2 @6 m/ Z0 w
  5 C; K. e5 l5 Q9 W9 X# o; W" K
• 
  
        run->cputime=run->cputime+1;  
  
  , z( O8 |. J3 T2 h- l3 B* \
• 
  
  ; a- R: x9 y1 h. n) P0 ^; j7 S$ ~      run->needtime=run->needtime-1;  
  
  
• 
  
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  5 J' P: v! J! s+ d2 T' i; n
  
• 
  
  2 T3 \7 G+ e# r6 X( P      PCB *p;
  
  
• 
  , m1 j! {/ c8 J3 X; y3 Q
        p=ready;
  2 V- \4 L$ x3 m* b: m4 Y) \$ \, ], N2 B
  
• 
  
  ; k0 L9 f5 Q6 @      while(p!=NULL)  
  
  
• 
  
  - H. d& F. m7 Z" W4 p8 A& Y9 I$ m      {  
  # s; _- j) \/ y6 q
  
• 
  
  * q) L4 @4 b6 M' ^  j          p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  : B5 f2 @, ~/ x( }
  
• 
  
            p=p->next;  
  # R( H+ z' Z; A3 r5 G
  
• 
  
  ( M8 t" D( \" q" q5 o1 V, K0 a      }  
  
  & I5 W8 H+ @, W/ m1 _
• 
  8 x) X6 d3 ?1 m
  " P4 f1 g4 Z$ J      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  , T) l! ?! p- ?; S1 H
  & q0 D& O0 F* G& u: E3 k
• 
  
  * e0 y" V7 K  F. r0 ~- J8 f      {  
  
  
• 
  
           run->next=finish;  
  9 w; C; R  b/ j- h4 p# r
  
• 
  ) i' C9 F0 D/ A5 b/ q1 Y# y
           finish=run;  
  ) t: g1 l' a) \' ~* H
  : ~0 R1 S. X8 r* O
• 
  
  7 c; D9 B5 o5 `/ x" _& y3 E         run->state='F';  /*置状态为完成态*/  
  7 |2 n3 {3 D- X* K7 ]! Y
    S+ `# n& @9 N7 `: P% z. T
• 
  
  4 P3 l5 Y" M( E8 R         run=NULL;  /*运行队列头指针为空*/  
  
  
• 
  ( @/ x6 h: Y; [' R; l% a
  ) ?/ A- L8 c, P( \& D" e( J& W# [         if(ready!=NULL) /*如就绪队列不空*/
  
  
• 
  
  8 Y5 {- ]; ?) z2 ?, G         {  
    g0 o! a+ [+ f/ b- l, d
  / [0 N- q9 L+ `; ^
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  3 D- S8 v' K. f3 y3 ]8 y. c( n
  ( I- h& B+ K0 R
• 
  
  7 s7 T$ a. ]2 c- ^( Y# h5 m: L0 N         }
  6 ~, [$ h2 g  x+ ]# |3 D1 `
  $ v. ?4 U* s0 C) B' c* k3 m+ a/ |
• 
  
  5 z7 X& T$ e- i5 k8 J& f      }  
  
  9 a' L$ Z* w9 _& ]2 M4 g
• 
  0 j6 F% a! X  s& d- E' Q2 v
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  
       if((ready!=NULL)&&(run->prio<ready->prio))  
  5 N5 N- g' Z: ~" t2 g
  
• 
  
       {  
  
  + }+ o1 @0 ^) h: u8 @: r
• 
  # Q5 Q; _5 u8 W
          run->state='W';  
  0 |3 L9 M1 u) p6 t- l- r6 P
  % e) P: H! e" i
• 
  
          insert1(run);  
  
  * R0 T/ u4 s& M
• 
  5 W1 S+ L; w8 p/ U# x5 `
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  * d% F6 I; Q# l, M; a% u% {
• 
  
       }  
  % J, b* E: C7 a
  
• 
  
        prt(alg); /*输出进程PCB信息*/  
    Z' K8 {) z. f: v6 ~1 N; s$ P
  
• 
  
  1 I9 |% J6 j% A   }  
  
    a) Y, r- I& d# g
• 
  
  }  
  
  
• 
  
  8 Q& s+ `: Z' M! a+ N/*主函数*/  
  2 x) T/ S. {3 z% z2 X) p) O
  6 U8 \' e1 I5 m. E/ e( w
• 
  , Y% N! _  ]8 W
  # b* |1 J. R2 C9 k; ?. jmain()  
  7 C1 _- A" s8 K$ O
  
• 
  * r0 L7 S  D7 f5 g, T" C! z
  {  
  : w9 z$ @! n9 T) v
  
• 
  
  ) k, `0 f2 @3 W# |   char algo;  /*算法标记*/  
  0 m5 a) ^4 J+ q- w
  
• 
  
  0 b7 Q$ Y' D6 e* \2 t* K  m   printf("输入P确定算法：优先数算法\n");  
  
  1 X/ i/ b/ [: e( R( ~. Z$ \5 U
• 
  3 C! {3 s5 i1 y
     scanf("%c",&algo); /*输入字符确定算法*/  
  
  
• 
  ( x0 w  k, U+ _# I- }( s
     printf("输入进程数：\n");  
  7 r/ B0 p8 n2 l$ ]8 ^% G+ d
  * B# S& M) w, s+ X4 n+ G" V% Z$ B
• 
  
  ' D) X" k7 u+ U6 |1 s) S' |* k& l   scanf("%d",&N); /*输入进程数*/  
  5 \1 R% Q+ o' N" d) e9 x# @
  
• 
  
  & {! H* }9 ~# p" T& r  f- c   if(algo=='P'||algo=='p')  
  
  
• 
  : C- A, B  \5 X" I1 e* L# p
  , h" x5 _- Z% d& I) f/ S) v   {  
  
  2 j7 q4 @+ z( n! W. c
• 
  + g3 x/ g: }: i. K# p1 D  @/ ~* [4 i) ]
  # N. y* |& L( {) m      create(algo); /*优先数法*/  
  
  
• 
  2 x, ~! k* o+ K6 ]
        priority(algo);  
  
  
• 
    \% g* }3 e" f4 j( F3 q
  8 r" Q/ C; h2 c# e  Y   }
  
  
• 
  # m/ T) e+ N7 u. w* D
  / f3 Y/ M- l/ b7 [9 T1 g2 G}
  & g6 P/ B0 i* b3 f) W
  ( R5 J7 \5 j7 I0 I$ @; j
  

输出结果：
) D& [# M& P2 h; u7 ^

- D! ^) T# q9 {' L8 n原文：https://blog.csdn.net/weixin_40962955/article/details/80072769