优先级调度算法

杨利霞

优先级调度算法

算法介绍
优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
- A( G7 r( T# W" P1 `. a7 l& i系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
, Z& I$ q& P  u& M7 ]1 z2）抢占式优先权调度算法
, w- s7 r4 p1 w* Z8 v只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
- |, O) Z7 g+ V& G静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
( R  J9 B% @, }  @. q6 D$ N

2）动态优先权

算法实现

抢占式动态优先权：

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

• 
  
  #include <stdio.h>
  
  4 Q% O# h1 i4 e3 x! l
• 
  
  ' z. X. R# o% C8 E# m' Q#include <stdlib.h>  
  
  2 Y1 s) Z. {  ?+ J' |2 u1 z/ U6 y
• 
  ; }% |4 @8 d/ U9 D, m
  & q  s. c4 ?% O$ @: }, y% Q#include <string.h>  
  
  6 R: c( v2 }3 [  @. E
• 
  * e+ ]  q% Q6 L/ u. V
  typedef struct node  
  
  ; b. Z; J, i* j
• 
    H8 U0 @8 t. O8 F8 v8 f
  ; S! o* y/ Q' y8 g{  
  
  $ P) K$ K4 \% v
• 
  
  2 E. k) F, m* h* a$ f# S  X   char name[10];  /*进程标识符*/  
  ( t4 Z2 b: W6 a+ M+ ~
  
• 
  6 W# }# F  Y- Y' Q( k1 C
  ' d7 X/ O, X; Y" {. }5 b   int prio;   /*进程优先数*/  
  
  
• 
  
  + V0 o' i& j; n! `$ c' {4 S+ z$ c   int round;  /*进程时间轮转时间片*/  
  " w, c9 I3 x4 Y3 d$ Q$ n
  
• 
  * k4 _9 t6 U! Z" x& x
     int cputime; /*进程占用CPU时间*/  
  
  
• 
  
     int needtime; /*进程到完成还要的时间*/  
  & x/ ?% h/ O. Z3 _& N
  
• 
  ( J. F, n% T( f7 X* K$ H
     int count;  /*计数器*/  
  5 f* k7 h) S0 u. D7 R/ H
  
• 
  ( {# \/ q* q! J% `
     char state; /*进程的状态*/  
  8 P2 h# ^5 A0 M2 a' M9 Z
  , ?1 i' e0 |  m$ m& ?
• 
  
  + c- \" x" y( x, K) j   struct node *next; /*链指针*/  
  + I- f/ ~" W. j+ \1 g' X
  $ h* F+ c! d0 n1 [( N2 T3 w( }
• 
  7 T3 e2 T# g0 D& }
  }PCB;  
  
  : j  L! z7 c2 F* N3 l5 {
• 
  7 C9 P/ h  i2 ^8 o4 W3 N
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  / p# H, _6 S/ w' k5 ]
  
• 
  
  int N; /*进程数*/  
  $ N2 J" V. Z  t0 Z9 `
  ! o1 t3 n$ W2 u: p0 O. m- ]
• 
  
  : w2 o& \- _" A0 [+ V$ L/*将就绪队列中的第一个进程投入运行*/  
  
  
• 
  
  9 J2 m, t& ~* A, O/ E! wfirstin()  
  % H, C% Y1 F/ ~
  
• 
  
  2 ^0 g( a$ T1 u- K) ^) q) w5 M{  
  " v2 ^( U% Q( Q+ E& Q* p$ i
  1 t* \! g1 \1 a/ C+ x
• 
  
  ) D, E  e) m9 X   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  
• 
  ( s5 `  _# f* i, L, [: I
  ! h7 D' s$ c4 ?1 ]# Q5 q   run->state='R';   /*进程状态变为运行态*/  
  
  
• 
  
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  ! S% \  Y  N4 C) g& B. l
  
• 
  
  }  
  
  
• 
  ' E; \. a, s7 t9 H
  : D& b4 x6 d# y' C# T/*标题输出函数*/  
  1 t7 @! x9 H$ M8 z3 r1 Y
  " P3 n' E$ @) T
• 
  ( j! A8 z  e* q0 q' ?8 E
  void prt1(char a)  
  6 J7 _) n* Y4 k) `
  6 D# J% T" }) w. P, H% Y
• 
  
  9 A& }# @- Z! v" p. L0 d; P. l7 z{  
  4 g' m+ n; H, h% I# _
  7 d. }) B6 ~' c) v& X4 }1 |/ t
• 
  
     if(toupper(a)=='P') /*优先数法*/  
  
  
• 
  
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  1 H1 A* Q6 U9 y# e2 C* j( F0 Y
• 
  
     else  
  
  / }% G0 l: |  i1 Z- {
• 
  
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  ' `: Y6 Q9 {: N
  1 h$ W' N  P) j) z1 D8 b
• 
  . F9 i' v& \6 ^3 a6 A0 n# C$ a
  . R2 r: t- ^: L& w0 d}  
  
  & W; H" I2 k3 f# K% h3 p  T9 i
• 
  8 H) X9 w6 T# `
  8 Y' ?2 P% K, R8 h' c0 P/*进程PCB输出*/  
  7 ^& d) I( k' C
  
• 
  1 u5 b" [- L" [" D* K" k1 a. u  e
  * h; A9 n; ]0 a9 X! Ovoid prt2(char a,PCB *q)  
  
  0 Z: ?6 J7 X4 q2 p. E* l$ D& t
• 
  
  # ~+ T2 {0 n% l! v3 |{  
  8 u9 T$ O4 _2 [
  3 `' x+ Q. _( ~
• 
  7 r. @: c# i: r5 T' k# H: F
  # f# b2 X6 q$ g  J1 a  @0 C   if(toupper(a)=='P')  /*优先数法的输出*/  
  * u! Q+ i2 I9 o0 I9 f' n
  
• 
  " G6 w, n! u! O+ N0 m6 W
  . t9 r& y4 Q% n! H9 ^; Q      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  & u& `3 ?# L% W
  
• 
  - n8 V/ U& q9 O; u0 o
         q->cputime,q->needtime,q->prio,q->state);  
  $ G9 d3 {1 Z- j+ A0 X$ E
  
• 
  
     else/*轮转法的输出*/  
  
  
• 
  
  / k7 h  n$ M! S; h# K$ b9 ^      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  
         q->cputime,q->needtime,q->count,q->round,q->state);  
  ! D- b) O- t# i+ @
  % M" V! @# P3 d7 r7 d
• 
  % e4 T* n$ v' t6 A4 J1 r
  ) E* y) D2 d1 g$ n}  
  5 m' l: P5 D+ \' e
  7 b( a8 C! i7 M& X9 L
• 
  
  # ?8 B" M4 O8 R2 G% O( w/*输出函数*/  
  & y- u5 M1 Y' z9 t, s: Z7 m
  
• 
  
  ; M9 W  Z  s) Gvoid prt(char algo)  
  
  ! k3 [# ~9 c2 g
• 
  
  {  
  
  
• 
  6 z% f8 v: S; h* p$ M( d3 p
     PCB *p;  
  ) ]& a8 x% n; O9 U6 T. Y6 W
  $ B5 T/ F4 Z- Z9 {" B$ A0 C6 d
• 
  
  5 \/ I) }8 p+ Q- x3 d   prt1(algo);  /*输出标题*/  
  
  
• 
  
  + c# Y7 R6 ]4 b, e   if(run!=NULL) /*如果运行指针不空*/  
  
  0 {7 ]! R5 k; P( W7 N9 _3 H0 W3 O: d
• 
  0 \3 \% U, M* D% w+ N/ I3 ]" Y1 U
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  4 w" ~% @$ _$ }6 x) F1 z
  " Y3 C4 w( s5 e0 o& P9 ]+ K
• 
  - v( c0 x4 @# m* o
  " D- l5 i  W8 x7 H" h3 {6 [5 o   p=ready;  /*输出就绪队列PCB*/  
  2 a: X( L' m. D3 z5 r
  
• 
  : q7 \; s6 g$ Y# O- M2 u4 q( D
  , K& |( I* h' Z; K$ y   while(p!=NULL)  
  
  
• 
  + {4 [7 H- E# k8 _8 P8 _
     {  
  
  4 k3 o- b% ^+ N# [
• 
  
  - X$ X$ _5 T4 h* A' a      prt2(algo,p);  
  
  
• 
  9 s8 r7 d* N! K0 }/ b! k1 F$ |. c
  0 d8 m- W* V" Y4 v& q      p=p->next;  
  3 J4 a. I% n  E. Q' A8 b; n. n
  
• 
  7 o) T* w+ v0 I, {  i' m- {* o
  % j- I6 K: s: @9 I   }  
  
  # A/ o4 t" N0 ]/ I. G1 Z6 D! g7 v
• 
  % M( f/ A4 D' z2 W% u. @* M
  8 I! e# Y% {( j& @   p=finish;  /*输出完成队列的PCB*/  
  
  
• 
  
     while(p!=NULL)  
  
  
• 
  
     {  
  
  4 E8 G5 j, `& Y& k. g" x/ h# {& O8 j
• 
  
        prt2(algo,p);  
  
  5 R4 p6 S. h0 i. i0 E$ @& |$ m5 V' Y
• 
  ' o0 b: ~4 u% V0 s$ ?* O
        p=p->next;  
  3 B2 {/ u9 f) h, `, t
  
• 
  
     }  
  
  
• 
  
     getchar();  /*压任意键继续*/  
  5 E- D/ {$ P) {
  
• 
  5 q  ^6 ~& H  [1 V& R5 ^0 }6 R& z
  }  
  
  + F- g5 _) H) X0 P
• 
  
  /*优先数的插入算法*/  
  
  
• 
  
  6 c) W3 N3 ^# b4 Z7 f: Zinsert1(PCB *q)  
  # S) S/ ]6 a& d; n
  
• 
  1 _2 a" j3 r+ Q& x8 {
  4 \$ M! I) M6 H  Z{  
  & Z7 q" Y, V) u- G$ v/ Z
  $ J! ^2 v$ B( c
• 
  % }4 p! g" D$ ?- A
     PCB *p1,*s,*r;  
  
  0 u( h4 f6 ?" G# `: M! _
• 
  ) N5 B" L  t0 m7 c; a2 G& {
     int b;  
  
  
• 
  , X; U5 m, [7 F! ], P: P
  : g, _. F+ w5 P' E" U   s=q;  /*待插入的PCB指针*/  
  , P. L1 A& x; b
  * q. W0 G4 K9 L+ N4 [. X4 y3 `
• 
  
  : t) r, S' F3 C' X" N4 Z  v   p1=ready; /*就绪队列头指针*/  
  
  
• 
  7 i- T2 p2 D: z7 Y: g
  ; ~  I& R- {& z   r=p1; /*r做p1的前驱指针*/  
  
  
• 
  ' `3 D' E8 J7 x4 \' Q
  ! s) u4 {$ ^: q9 p- F   b=1;  
  , j9 \- T  q4 A9 _* p
  2 P4 q" p2 \7 F8 B
• 
  1 A! n: Z0 `9 [8 ^8 c# K- E' N
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
    v: o; s, f  S( a
  2 ~  i# X/ m9 E* w+ j/ l
• 
  
        if(p1->prio>=s->prio)  
  
  - E9 }% N9 J+ a7 S& v1 h; @
• 
  
        {  
  
  6 j; B0 S' t4 O: M  g4 N) Y
• 
  $ ]7 i: \7 R0 D; w- b. J
  ! F- d- C$ l0 Z) v( ]     r=p1;  
  
  ) [! n" Q" u  d( Z: p0 U, u
• 
  
  % h6 S- E1 x4 F" ], Q  L1 X     p1=p1->next;  
  3 T$ O( {% B6 ~/ ~4 N
  6 g6 i* L( R4 B4 K4 Z! ^) b5 n* {: m# T
• 
  
  ; i3 h& E8 e( l2 e% `5 W+ E      }  
  
  & h7 S- C9 @8 j+ Z2 v3 f
• 
  9 N' @$ G% R) z" K  o$ `* ?
  / V; {  E3 X, T, u# @# \      else  
  
  
• 
  + J6 ~4 q& E% D
       b=0;  
  
  
• 
  & |; S) _$ V: L2 f! y$ T/ E
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  : O7 v! B5 {4 y. ]
  
• 
  
     {  
  6 S- o4 ^0 z! z" c5 [1 w5 P
  7 `  ?& ]% p9 y4 P( ?/ A" M
• 
  
        r->next=s;  
  
  
• 
  " P( i) N% ~+ E# X
        s->next=p1;  
  ) V; Z. }; k5 R, D
  
• 
  
  " f" C- t0 c( ^# Y: ]   }  
  % @8 e4 a: y- o; A& [
  
• 
  2 U0 p, _! L8 u' f% s/ ?# I
  : j4 D% [% b) Y1 d7 |8 P% m   else  
  
  2 `/ V$ c  x4 c  U
• 
  
     {  
    Y2 Z( O- F  f5 u$ l
  
• 
  $ f& ^( O4 S* }3 A! n4 r! j
        s->next=p1;  /*否则插入在就绪队列的头*/  
  4 H8 X  B1 Z0 v+ A7 c
  
• 
  + f  [: }3 A# g4 w$ ?# e
        ready=s;  
  ' r7 F) Y' n% N8 S) X! a' g
  
• 
  
  8 J: H( z& U$ ~4 k* @( o   }  
  
  & s5 W4 g% w1 `
• 
  * F- Q7 o/ b- g  K2 r- T$ @
  }  
  
  
• 
  
  /*优先数创建初始PCB信息*/  
  
  + O2 K" k' }) V0 E
• 
  - M! N$ C) W0 M# q: ~: h
  4 r( r/ e. d5 avoid create(char alg)  
  
  
• 
  4 g0 j* E8 @# x1 n
  1 u, H/ L: |# m% e7 T{  
  
  . a* f0 A3 i+ `  S
• 
  
  9 R- q" b& f+ ^, a0 b   PCB *p;  
  - E& V7 k9 g% k
  
• 
  
  ' p! \! ~1 w5 H# K   int i,time;  
  
  
• 
  2 Y# E1 p2 M" V& q2 t. |" d
     char na[10];  
  
  
• 
  ; [# z; o$ c5 d& J7 `
  8 f, k8 Q, w. v+ L! h* P  O   ready=NULL; /*就绪队列头指针*/  
  
  
• 
    f  }  O9 E3 Y5 C4 E
  " N' O8 L% ^+ t  Z' Z   finish=NULL;  /*完成队列头指针*/  
  % n6 \# E8 X- M% K& `+ R. a# M9 O. |
  ! {; S  B; @: z
• 
  " m# L& p7 R4 J8 m5 g9 {
     run=NULL; /*运行队列指针*/  
  
  
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  4 k! t- J( F% T
• 
  
  : m  C9 A' h: {  B: ]: C# J7 X. [   for(i=1;i<=N;i++)  
  
  ' Z& i8 y7 |& m# f2 w" t" P
• 
  
     {  
  
  4 L$ s- g; I- u7 x. @+ e. W
• 
  
        p=(PCB *)malloc(sizeof(PCB));  
  # M$ L0 m, W' k7 }$ ?+ a( s
  0 g* m7 Y3 Q( K1 k' ~
• 
  
  0 H* s  ?. v# }+ K! D5 ~/ a' S      scanf("%s",na);  
  
  ! ^6 z. k8 t1 C! f$ g
• 
  ( i6 J9 Q; [6 Q
  1 J) m1 u, N7 c) K- d+ |; h% I" z      scanf("%d",&time);  
  
  3 `# {0 X+ q* n# w$ ]
• 
  6 |5 i) o5 O; ^* _
        strcpy(p->name,na);  
  : ^" F* b- I# L: B; o
  & P) f  K* P! o4 Z/ `2 ?
• 
  
  9 d: m* n- }& Y4 i      p->cputime=0;  
  
  
• 
  5 S& R. M/ s8 `1 l/ A, }1 N
        p->needtime=time;  
  
  
• 
  ( v" F9 w; _% b
  5 J$ a+ \. r! s+ h! W: f& c5 p      p->state='w';  
  
  
• 
  ' |  g+ Z3 s4 T' b% T9 j2 ]! c$ X
  ( V9 J% q& r8 _$ Q      p->prio=50-time;  
  
  3 ^5 f: `8 H* X8 _3 K
• 
  ( W: e$ n* S$ ~; X1 ]; V
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  9 s6 s( u$ X- ^# C, ?( L( g; W  j
  ! H' F  N0 g7 `/ _; B
• 
  
    ^* x+ K8 {  Z; y     insert1(p);  
  
  
• 
  + C- S3 S: p# X/ Z( h8 k
  * N$ b9 n7 b5 f! f      else  
  
  " N2 F) f) k1 J/ p; P0 ?" _
• 
  - R% D) @0 f/ q- @' u6 V
  ( h5 _$ g' c: m" k* o8 _4 ^1 }      {  
  
  
• 
  
       p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  
• 
  
  : `" H. I' {" ~8 G# n& f     ready=p;  
  
  
• 
  " A8 |* T, [" e  ?6 Q0 @+ K
        }  
  + f  W" U# j4 Q; S, f
  
• 
  # U' {3 v* A- b- |3 K
     }  
  1 i6 ^0 J+ [' Y+ Y
  
• 
  
     printf("          优先数算法输出信息:\n");  
  
  
• 
  * ]( D6 i: k" ]: u$ E
     printf("************************************************\n");  
  
  % C$ y( F8 k7 F" V4 @7 U8 D# J! q& |+ ?
• 
  ; F* r, H1 O0 r) f3 ]7 a9 x' p
  - P+ J& l; S, r5 ^1 ~   prt(alg);  /*输出进程PCB信息*/  
  
  7 j- ]0 \8 d) y, f" D0 ~7 C
• 
  
  9 W5 }: g5 Y/ K, d+ A7 B' J   run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  % p" _3 L0 Z& l
• 
  
  / ^! q, a" k" s6 k/ u   ready=ready->next;  
  ) y0 h0 D) q# V# j* T2 p5 }
  
• 
  
  . t; y- S9 D4 P& d+ B& t4 w+ S   run->state='R';  
  
  / |5 O* l# |6 P9 t
• 
  
  ; m! l( E# i, W+ B' K. L2 s( F}  
  
  $ Z. Y$ I  O9 U  @
• 
  ! ^. E" \6 _) a# {4 D9 C4 z
  7 K3 y1 v3 k/ R  L/*优先数调度算法*/  
  4 s( f' g* J/ K  _' a( |
  
• 
  , l0 {) I  }5 r( x0 H- W. H% A3 d
  priority(char alg)  
  , H6 c) s9 o9 h
  2 Z7 o6 G7 f, L* {0 d
• 
  
  ) p0 A% Z! o" b{  
  5 X. b4 F4 w3 j
  
• 
  # ~& P* G  K9 h! u, y# ~
  , i8 }5 y8 f! M7 c- {5 h# Y   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  5 _6 V, t* {: B) A4 g' `6 X
  6 F. g6 H! r( L8 @# b, u5 ~
• 
  
  0 d* M: n1 N1 o2 X9 Q% j' B7 F   {  
  2 _) y" W$ s  Y9 u
  
• 
  ' Y7 ]( n4 _' ~6 }' M
  4 L. k  \8 D6 O& `      run->cputime=run->cputime+1;  
  
  
• 
  
  . q: }; M7 c* B2 x" G      run->needtime=run->needtime-1;  
  
  ! `5 i* t! \+ L
• 
  
    p$ E; q- \8 v7 r2 x! M9 e      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  : o3 E5 {0 R6 W+ x% R! t
• 
  . k4 W, H5 I! k6 v* \/ p/ w+ D
  * b" C  G* I* \8 y! W7 b      PCB *p;
  
  0 x. U# j) h' w/ Q, k) C3 G& Y- n
• 
  6 N  p; l9 k: O3 X, X/ \
        p=ready;
  5 I7 x9 D3 @$ Q
  " m2 k/ M+ `  Z: u' x" w
• 
  6 G( H0 h6 d" ~+ K
  / F1 y, ~' x8 I# J! ~      while(p!=NULL)  
  
  : n6 |4 r2 X* a* `( R
• 
  
        {  
  & \$ n% V" ~3 [
  
• 
  ' u( H3 S  \& E9 {- n/ U; v) ^9 L6 N
  + q6 z) l8 g" J5 w& D) Q( C          p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  
• 
  
  / D/ _( W0 u& u6 x7 _          p=p->next;  
  * d- q2 @& |4 E+ w& A5 D
  1 z% ]$ e; S% d7 @4 q
• 
  
  ( w) f4 v0 o" n; T6 e& v      }  
  % U; e5 ?6 s9 B+ r' s5 F6 t
  7 A. e0 t1 p- F0 N9 U0 n
• 
  
  6 q7 ]) @' |/ Q) X      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  
• 
  ) x3 a- B7 V& B' K
  ' q: G8 u  I! h2 H" Q+ Y      {  
  
  9 E* Q9 h) W0 E+ ?, z5 u1 K- H
• 
  ! K  k# Q3 Q+ V! N0 Y' O
           run->next=finish;  
  
  
• 
  
           finish=run;  
  
  0 C5 O; P( s5 }$ s) e
• 
  0 u  h2 R, y: G; |  K  f& s
  & f9 D9 t2 [. B  C6 G9 M8 x0 s         run->state='F';  /*置状态为完成态*/  
  ' _( o% u! q' \# X2 }( V$ f. D
  
• 
  , i' r) t8 J# I/ W! A6 U
  ) D, R4 S# k& ~5 }9 t         run=NULL;  /*运行队列头指针为空*/  
  
  
• 
  7 N. q! N/ Q* Q
  2 C9 u. X8 R4 ?: K: i  F9 M         if(ready!=NULL) /*如就绪队列不空*/
  0 e1 s, [# R8 G
  
• 
  % r9 n2 U; n, _( A
  & O4 o: S( l) s6 D         {  
  
  0 ?8 v7 _. L5 T1 E& z4 ]9 n( V
• 
  
  ! l( k1 t( l8 c            firstin(); /*将就绪对列的第一个进程投入运行*/  
  5 I2 @" W5 E8 W% Q# e$ Z% W3 f
  " k% `1 f! \3 N9 a
• 
  - `" n' s, d4 P7 D0 O; T( d
           }
  
  
• 
  
        }  
  0 M( k3 g) ?$ y! J: o, a
  ) m! b' T( `2 }( q% Y6 Y- Z
• 
  
  # |, U5 e. J, U! V2 v: o7 F      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  " G4 I# Z- |1 P
  ; ~* h) ~+ E$ P4 u6 E2 ]0 h     if((ready!=NULL)&&(run->prio<ready->prio))  
  
  
• 
  
  2 x1 n4 @7 P' t4 i0 ?- D! N     {  
  
  2 Z- q- ?# t6 r5 A8 p5 H
• 
  
  8 S. a  C- C$ q4 e        run->state='W';  
  
  
• 
  1 J8 s' C/ s' p. F3 s. p
          insert1(run);  
  5 W5 @: H) L* Z  S! |2 d- h
  / }" ^9 f' l- K; ~
• 
  - @( u( c/ h' E7 T" W
  9 g/ N# E+ A8 o# k5 K. s& n        firstin(); /*将就绪队列的第一个进程投入运行*/  
  7 ]1 ]+ x( e2 ~7 j" n8 Q2 t4 Q
  3 P7 k, j/ }8 u
• 
  
       }  
  
  
• 
  
        prt(alg); /*输出进程PCB信息*/  
  - M& n. A" r. |& O' ]6 A3 @
  
• 
  
  ; R; f0 Y- l2 L- o# u' R, v! ]   }  
  
  
• 
  9 R* S7 P$ I5 d4 P2 Z3 r$ |
  ! }3 P# }; Y* X2 U}  
  8 U' p6 z* W" C3 Z; H. }! o
  , B. F1 r1 S: v6 i' o; l
• 
  
  * F* F$ j2 W, N' ]" I0 V/*主函数*/  
  2 w0 ?  n2 _' @# Q
  % R# n; Z. X5 a( r* G2 h
• 
  . q. D! X: B* o6 H- E
  main()  
  # {" A# A7 T9 B& u' p! a
  ) W) o  r* _5 F$ o; C
• 
  % ^' d3 G# w& _( k4 z
  * B/ Y: }: w5 M( T0 z* R, S{  
  0 Z2 w# H# k3 P0 |
  
• 
  ' P' L7 d, |0 I2 T& O$ a: v
  8 j3 q7 X2 F7 L   char algo;  /*算法标记*/  
  
  
• 
  . `) C  D- H. V6 W; E+ y' z
     printf("输入P确定算法：优先数算法\n");  
  
  % Q5 k) U7 C8 m; o- n
• 
  , I: U- f% H$ [
     scanf("%c",&algo); /*输入字符确定算法*/  
  9 u* {( Y  O7 [
  
• 
  ( w; E! x, f0 |5 n! U  o6 {. _
     printf("输入进程数：\n");  
  
  2 a8 v$ j% K- P. ~3 {8 O
• 
  9 o- F: _+ L( q5 h" h1 G: V  }
     scanf("%d",&N); /*输入进程数*/  
  
  3 n. O$ n2 ?, S6 R% r5 O
• 
    n. l: A/ R3 W& U! Y% q
     if(algo=='P'||algo=='p')  
  
  ' K" S! K% H9 A! n  n6 A
• 
  
  4 V; |2 ]; t9 H& l1 x   {  
  ! T% b: t8 `7 w* d4 v5 p
  % S) [. x9 M) U6 |" D/ X9 J# [
• 
  7 V4 ^- v# H' ?
  ) P7 p. [: Q6 a2 h      create(algo); /*优先数法*/  
  , n1 n8 H( d2 c6 G" @
  
• 
  & B2 D# I9 V7 c" U, N1 g( k! ~! O
  . M% c( f; z% E5 r8 G      priority(algo);  
  
  $ d" U5 r! j! Z# B: \+ M
• 
  5 d3 v( N  _) A5 [
     }
  
  
• 
  ; O% A0 o2 p$ C" p7 C; O& q- [, d% G
  }
  
  
  5 A: ^" l) ~# J4 A

* p1 [& R( d/ U输出结果：
! Z4 g/ S# u0 N

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