优先级调度算法

杨利霞

* N) M' A2 m8 f; H' _% `优先级调度算法

算法介绍
+ O; [+ [4 U- i% i8 V) f优先调度算法的类型（用于作业调度）
0 B! }" E. M% P- F- y1）非抢占式优先权调度算法
- a! ^) M5 ^+ k8 g系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
) V3 G7 C& c. O/ C8 o1）静态优先权
/ X9 d8 m% _# C. a" J静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
# X6 E! E4 d  J0 e- S  J: S

2）动态优先权
2 u; J) N9 G! Z

算法实现

抢占式动态优先权：

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

• 
  + M/ V& i, v$ k! ]1 F+ p$ x
  #include <stdio.h>
  
  
• 
  
  #include <stdlib.h>  
  # x7 D+ N4 }  b0 C: D
  
• 
  
  #include <string.h>  
  
  , U- g! g( g* a$ ]5 R
• 
    i9 l- s0 k$ x  ~; W
  7 I/ B# w* N! p  C! a8 ~0 ltypedef struct node  
  
  
• 
  / Y6 e" h0 p. Q" a5 v$ e
  {  
  
  9 }( [: k4 d8 K+ w, Y2 n# ^$ L  B
• 
  
     char name[10];  /*进程标识符*/  
  
  " d, e' ~7 J5 j2 X# G. o* h4 d
• 
  3 N3 @! v0 ?9 o( O( L
     int prio;   /*进程优先数*/  
  
  
• 
  " V/ `9 r$ Z4 l& P
  . o3 A5 w* E5 C: N- y$ i   int round;  /*进程时间轮转时间片*/  
  
  
• 
  
     int cputime; /*进程占用CPU时间*/  
  
  5 G; o+ W  |% A/ E9 z
• 
  & @  i5 C, X; `$ B* L4 J- C
  2 p" `$ E' U5 ^7 u$ f0 v" n   int needtime; /*进程到完成还要的时间*/  
  
  
• 
  
     int count;  /*计数器*/  
  8 w, T& n7 ]7 S, s7 V) G9 Q, k
  
• 
  
     char state; /*进程的状态*/  
  
    r# p/ l1 b# K& b" R
• 
  
     struct node *next; /*链指针*/  
  
  
• 
  ( \6 c$ D7 ~! Z* V# Z# c7 i) g
  }PCB;  
  
  , @7 `( ?/ A6 ^# z; b& h7 n: F# [
• 
  
  ; G5 N" t/ P  K4 v! V' z2 J6 RPCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  
• 
  ) r8 P$ l; r: [' n, J& M: v
  ; s  f5 w* j7 V' ^" [5 ^  r- uint N; /*进程数*/  
  7 m6 H& s0 C; A: x7 \. c
  
• 
  
    A/ S6 J' M* P$ f$ u" v6 n/*将就绪队列中的第一个进程投入运行*/  
  
  : Z) P) K9 b7 U9 n- s. x: h+ u5 m
• 
  
  firstin()  
  
  " Y) c7 Z4 W& B# [" K
• 
  : w: s* {- B6 W6 E/ L  {1 F
  {  
  9 Q' O( N: M# g. f6 d' Z9 m1 I  k
  
• 
  / O. i9 Y  j! _1 j8 j& i: T
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  * [( E* G3 t/ W. U5 e+ r- W$ I$ |; b
  
• 
  4 K: A( R( h0 k  F% Q
  2 [7 w2 t' u- S. ~  b+ a. t; D/ E   run->state='R';   /*进程状态变为运行态*/  
  
  
• 
  
  1 C; Y( J4 ~& r" m( p/ r4 v5 n5 |7 |   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  4 w6 Z( L- v- l7 p
  
• 
  
  }  
  ) E9 _4 I9 L+ l/ N$ R$ z* U  z
  
• 
  
  . l$ E1 R. z+ ]5 Z/*标题输出函数*/  
  
  5 X0 l; }2 x0 Y: l# ~# J
• 
  : ~! \7 e, ^0 g; q; ~5 l
  : c' L' r5 {. j1 K6 ~9 avoid prt1(char a)  
  
  
• 
  
  {  
  7 \) y8 O! T/ ~9 [5 X. j( q2 l& [
  ' e9 k4 b" n& @3 p6 E! i- S
• 
  ) d( n$ l6 Q9 ^2 L
  ) ], I; R3 e4 x& d" q' l   if(toupper(a)=='P') /*优先数法*/  
  
  3 N- h  W4 Y% o; M/ M
• 
  : F) V  [# r# t# p2 J
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  . Z) E7 g$ {0 V7 L' V  p- k
• 
  1 H$ M2 m7 c. y6 \) ~0 @1 P
     else  
  
  ; F" [/ r9 n6 N
• 
  
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  
• 
    u6 c! a% ]/ n* w$ c; x7 O
  6 p8 i: t5 W& G9 G}  
  
  
• 
    W! M; s2 t2 B& P9 {
  7 v: f" U- L! {& m: _/*进程PCB输出*/  
  + M7 j! z6 n% T3 z. G0 Q+ \- \
  
• 
  ' B4 t. y* t4 L/ o5 W% w. a
  void prt2(char a,PCB *q)  
  * }: q, P! U- m; m1 T7 H. O4 B
  . c/ g7 [' x6 `6 X/ h+ Q7 t
• 
  
  {  
  
  
• 
  + v5 q7 ^( O' _
     if(toupper(a)=='P')  /*优先数法的输出*/  
  * l& F, ~6 H. ?3 Z1 X
  
• 
  / _, h$ ]! ~0 ?6 I0 [1 Y
  , j1 I& Y5 l; s2 k7 R/ M7 u2 N4 P      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  
• 
  : p+ q  f! R6 [# {! f6 H
  4 I' ^; u4 y. T( B% s! c       q->cputime,q->needtime,q->prio,q->state);  
  4 Y: V. v4 s/ h. R  f# |
  1 }$ q5 ~5 ?* J0 v
• 
  
  # a& s! W( H! c3 q* E   else/*轮转法的输出*/  
  . p) ~! ?: w7 b* O- G; {4 k
  7 g$ P3 q) g# ~8 `
• 
  7 X7 v  f3 j5 C- x) E( E! C1 g
  ! S9 u  k; |8 K/ ~5 z" }4 f      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  8 l- [" r2 v# N/ |- f! x
• 
  
    r. y4 {1 d. y) r: N6 k       q->cputime,q->needtime,q->count,q->round,q->state);  
  
  
• 
  
  }  
  
  + L5 I4 w7 P- [/ y/ ^9 p
• 
  9 Z# l# Y2 Z* ?' k# a! z
  , U- ?! L  b# u' b1 r" Y9 _/*输出函数*/  
  
  
• 
  
  void prt(char algo)  
  
  
• 
  2 `$ j7 w6 ?5 X- ?
  {  
  " t5 M( Q* M4 k7 l9 k3 [3 L
  & P8 z+ s2 @1 X) D% A; _' \' ]
• 
  
     PCB *p;  
  
  ' m& a6 @1 b+ S! T8 t0 x& _
• 
  
     prt1(algo);  /*输出标题*/  
  2 Z3 _( P+ Y4 |5 s. g4 o6 L
  
• 
  3 }3 U) t/ A$ w5 n8 J( u
  3 M: i4 ^" j4 s0 {6 S   if(run!=NULL) /*如果运行指针不空*/  
  
  
• 
  & ~( o! `7 l. i8 {
  + c* H5 z% e0 ?5 v& [8 x      prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  
• 
  ; {' m  a2 ?; [. [2 G1 `
     p=ready;  /*输出就绪队列PCB*/  
  # f: t8 O. w* T$ @' L# r
  9 w8 O' H2 S5 t" A8 P3 V7 D: n6 F' ?
• 
  * ^% d" X, g2 x5 x. v6 q$ ?
  + M# m% F' T9 A3 T! ~   while(p!=NULL)  
  
  
• 
  0 b+ G* q! d: O* T4 e% P4 k
     {  
  2 m! m1 V. h# R: |( ^9 |; k: a
  ! m* H9 t& X% w7 k
• 
  1 T& g; c. y. f% H- l& x$ O3 G
  ) C) T& `8 T& r( w) x; M      prt2(algo,p);  
  2 S  I: U; j, F2 b* z6 W2 K$ C
  
• 
  " [* i, o" K6 ^5 j7 L1 p
        p=p->next;  
  " r$ o7 T* w( g' M8 L4 X
  
• 
  
     }  
  $ V/ u, M7 z. o3 ?; E
  3 Y3 r: [$ O/ I+ z2 y
• 
  5 {8 j: J" W/ {" [( T) G: }' w
     p=finish;  /*输出完成队列的PCB*/  
  
  
• 
  / `6 W( v: L8 J* D
  . R$ X# u$ ?$ w3 Y( S   while(p!=NULL)  
  
  / o9 r" b- h2 L5 j7 J( G7 l3 X
• 
  
     {  
  " R+ a8 T0 v$ Q+ t! S6 b: P
  
• 
  6 N% l; ^3 H! r. G) C9 E- Z& F$ r' ~
        prt2(algo,p);  
  8 q; k9 Y+ \& t7 m) v( A0 r0 f
  
• 
  
        p=p->next;  
  ( f: \; K, _0 U) l
  
• 
    d: \# o+ M, g" m
  & e& _. d$ G6 v6 P   }  
  5 b3 s. S0 ~1 F, n1 u; L
  
• 
  
     getchar();  /*压任意键继续*/  
  
  
• 
  
  }  
  
  
• 
  ; k$ m2 U' p3 e& a
    ~! m* o' V! i( T! S/*优先数的插入算法*/  
  # t3 J/ T( s  t/ I5 C1 v
  
• 
  
  insert1(PCB *q)  
  
  9 Q4 u0 J9 {" J5 h& H' [% q
• 
  
  {  
  " `: R2 U# A9 T2 g" u
  $ e2 k6 f) T* M
• 
  
     PCB *p1,*s,*r;  
  
  / `1 s+ U1 Z9 M+ _
• 
  
  . \- z1 o1 d* d4 @1 s1 ^   int b;  
  
  : ]2 S+ v+ q# ?& W6 Z6 Z+ Y2 n! X
• 
  
     s=q;  /*待插入的PCB指针*/  
  8 E0 S, r1 W& I, c% D  S0 E
  
• 
  . e4 G3 r$ b  B
  3 v9 ]" q2 P" \/ F+ T8 N6 G0 ?   p1=ready; /*就绪队列头指针*/  
  
  
• 
  ) c& v) A* _( ^, o9 s
     r=p1; /*r做p1的前驱指针*/  
  
  : m# l- h% }6 d# m) F
• 
  , U1 Y, j# n7 z
     b=1;  
  9 [. I, _8 K4 n+ A) Z! n
  
• 
  3 K/ K' S4 X! p, [: X3 J
  " J, j# @5 J- ~& f9 N' p   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  
• 
  
        if(p1->prio>=s->prio)  
  
  . ^4 k" u" y( a" l
• 
  
  # O: E- }- l! e% v# A& l      {  
  3 I8 ]# ]+ t( Q2 d3 e
  # U/ J5 }. Z% P3 f! _: m& N2 [6 T( W
• 
  8 u/ d1 Z6 S: X4 u( S- `$ v5 e
       r=p1;  
  
  , h, C: \  R# k. E$ E1 K, k
• 
  0 T! B% q1 d+ q- Z* R3 K
       p1=p1->next;  
  1 c$ b. q" @# |/ U% y
  
• 
  ! j# N9 W1 E# S* X
        }  
  1 `3 f) E* w6 ]" m( O  ~3 ]
  
• 
  ; D) x7 M' f4 U2 Q1 U2 X
  # r) ^- f& L9 T( T      else  
  ( k7 C5 ^. J& w5 u; p5 w
  : @7 g& O& v0 \( a& r4 y' l
• 
  ! o) T, r5 m+ O+ D! ]: v+ p* z
       b=0;  
  6 M0 j; ^+ w- x' D2 i  Z
  
• 
  
  3 L- j+ a, u% U- R   if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  0 a6 H% b1 B+ y' Y, s# c) Y) z: Q
  5 i: d* Y0 W1 P3 R
• 
  ( q+ j5 u! K+ G5 F& {
  0 n+ C$ s: F0 |# G   {  
  ! P4 o! G% u8 f! `
  1 `. b1 A+ h- f; y6 R- I- b
• 
  2 X% z3 l. ?  b+ k. Q7 v) J
        r->next=s;  
  1 @% y8 s6 a! R. V- h, u' c
  
• 
  3 c2 Q, O2 {/ a
  0 K1 x; h" K0 ^0 V4 S      s->next=p1;  
  
  2 }$ D- K  N- c4 U& u
• 
  
  : e5 @  V( [7 t: b  ~+ x6 n: v   }  
  
  & ~) h  r5 n- w* b( M  A) q3 S0 X, I
• 
  
     else  
  
  ) U2 R! Z' S* v  o/ t2 l; ]
• 
  8 o* l8 A: E5 d! m) q& r. U
  + Z7 j* R) ]; `8 f& m' [   {  
  $ Q: f8 J# f7 p  S
  0 f( ~* Y+ n: I) E; A
• 
  
  . i0 R4 L3 [" ]& o      s->next=p1;  /*否则插入在就绪队列的头*/  
  
  
• 
  , o: ?3 P3 I4 T* _
  : K! O  f' K" P2 V" W) I      ready=s;  
  
  1 j9 r3 z; U2 L3 h5 o+ _
• 
  2 U. v* Q1 E5 H" Q  C5 s1 I& ?) [
  ; J# f/ K/ _0 ]6 z% }# v   }  
  7 P- o$ s' Q+ \. S& @% y' }- t
  
• 
  
  }  
  ) O5 k$ h) R' @; ]" m7 E7 }3 W
  
• 
  3 C3 i5 {& ~5 ^8 {; j- r3 W6 t
  ' X5 @6 W% \1 J* C- v) t4 {) s0 \/*优先数创建初始PCB信息*/  
  
  
• 
  & C8 T5 C, H4 x
  7 a! \5 n9 i/ V: cvoid create(char alg)  
  
    I" M+ S" e& v
• 
  3 k1 r$ l# m* f" @
  3 D. c$ ?. T; }6 N* J2 `{  
  : T5 u. Q# @9 F8 p+ I
  % \% ?) b: K( P, R& ?, i# g
• 
  
  + i1 j! X# `! @& |1 l  ?   PCB *p;  
  
  4 R; p) a: G" u; m& S, m1 ?/ |
• 
  9 C- n$ t! }2 t7 o, B2 e1 O" }% a" S
     int i,time;  
  % s$ e' Y# q3 J* z) e( x+ |
  
• 
  
  - W3 n# D: w9 Z# S   char na[10];  
  
  
• 
  
  5 A, O$ V2 t# R   ready=NULL; /*就绪队列头指针*/  
  0 d+ D: u. l# U: Z" Z
  
• 
  
     finish=NULL;  /*完成队列头指针*/  
    j6 _+ Z1 Q3 }! b+ @+ q# a
  
• 
  ( f% f1 `7 Y! k0 H% d- P+ D
  ! ~2 U' |8 Y4 @# q   run=NULL; /*运行队列指针*/  
  2 {) ~( b, ?, O2 s
  
• 
  
    o: D0 O6 Y  ^9 }  G   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  * G' b, j* o6 E3 w+ f4 L9 z4 |2 @6 m
  ! l& L9 U$ T3 N, ~4 _- t
• 
  
  8 y' V8 m( \6 u: i$ k, x6 l   for(i=1;i<=N;i++)  
  
  
• 
  
     {  
  
  
• 
  
  # ]/ _) S4 I4 S! z      p=(PCB *)malloc(sizeof(PCB));  
  . ~) x3 \+ z6 c' P0 `5 R+ J
  
• 
  1 |7 B7 H- z* @. a' O. m; Y
  8 b, q7 K. ^( c8 w6 l3 N      scanf("%s",na);  
  
  - _7 H$ p/ g- Z, \) M+ D
• 
  + [2 m! ~. t' B9 j
  # O# L8 P- I, L/ f( z. u3 X' u      scanf("%d",&time);  
  % Z- s$ w! ?$ x
  + j  m# T% t" }/ ]6 e; k
• 
  4 g5 x* B) ~" Q) L  L
        strcpy(p->name,na);  
  
  / d4 @. [+ N/ F
• 
  
  4 B; I, |4 C2 |5 {; ~      p->cputime=0;  
  $ g1 a" P3 H" m) n0 _
  $ `8 `2 {  s* l7 }$ d$ [4 K0 o7 X
• 
  
  5 H) P4 N% t" G7 C1 v, H+ @+ |' b* ]      p->needtime=time;  
  * J+ e$ ^3 e% t. t# Z: s% w7 b' h  r
  
• 
  
        p->state='w';  
  
  9 }" k6 _, P3 y$ h. P5 ]8 c
• 
  
        p->prio=50-time;  
  
  
• 
  + x2 S& N- v3 V& \3 _
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  
• 
  - j% ?6 \/ ]! x$ }
  ' ]0 e/ E* h$ v  V) {3 x2 d     insert1(p);  
  
  
• 
  
  , e9 f' L1 E" {# M( ?      else  
  
  
• 
  : \7 Z8 m. l6 R7 K( b3 j
  3 _* O' P  ]% Q3 u/ V# H7 z      {  
  : k! o. H1 h: c& q
    s3 a9 v6 y! d' Q
• 
  
       p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  " `+ n9 _9 o8 Q/ y+ c
• 
    U$ ^) m1 w. i5 N1 g) Z0 F" P
  , v* e0 V" ^. ]* M( y     ready=p;  
  ) }: _! I0 ]8 @$ T5 t4 E/ i3 y
  " }( e2 H$ M- Z: G' @" G
• 
  
        }  
  
  
• 
  ; U2 q; h) C# |
     }  
  & p3 n! e  H6 U5 ]  w6 ^
  
• 
  7 _3 b- m* J  y, x
     printf("          优先数算法输出信息:\n");  
  
  
• 
  
  - q# f" f  B! I/ L/ D   printf("************************************************\n");  
  
  3 Z2 Y2 G! h$ `& k7 D' k8 P7 v& L
• 
  
  ' x# o4 V0 [  `0 N! q$ E   prt(alg);  /*输出进程PCB信息*/  
  & f" A* l# P; T% U/ n9 V7 ^) g
  
• 
  * _/ H) i6 H1 Z
  & Q* E8 N2 C6 V   run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  7 z6 S1 _$ h9 Z! T$ N
• 
  
  , b2 ?7 n5 F% ]. ~, w9 u  |* b( u   ready=ready->next;  
  
  
• 
  
     run->state='R';  
  + X- a3 E/ E" A2 m, e* `
  
• 
  ( \6 Z; i8 L3 `' b6 o
  8 `# B+ a5 ^3 P}  
  9 |% ^- k" v1 V
  
• 
  ( D4 W/ I  C7 J$ h
    q1 b8 ^4 q# g0 W; `- Z- x3 _/*优先数调度算法*/  
  3 R9 x7 m! G9 j8 k; p0 u# b4 C9 n
  " a) r) F- E3 o; b1 Z
• 
  
    t- L$ K. j# z) S3 B9 _priority(char alg)  
  
  
• 
  
  {  
  
  # H3 ~) t( T6 @: L4 r
• 
  
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  8 ~8 x* F5 z0 P3 p
• 
  $ v. h6 q) u) x, R- z
  ( [8 C  S9 |3 u' y" t6 c   {  
  
  
• 
  
        run->cputime=run->cputime+1;  
  
  3 J7 B+ y# E$ o2 O/ X
• 
  
  ' J; O1 l; F; l% Z) e" m; B      run->needtime=run->needtime-1;  
  
  
• 
  ( p8 s( u1 p! B3 I. Z
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  & W, l& ^7 l! H5 T. E( p
  + ~, g$ B7 q/ h3 k
• 
  
        PCB *p;
  9 R6 U' v  r  G# {& V4 }6 J4 O! F
  ! U  L9 g4 A/ x* z# b8 A5 a" ]
• 
  
  ) ~) M) f# X. t- b2 t$ [      p=ready;
  
  
• 
  
        while(p!=NULL)  
  
  
• 
  
  ) a) _. Q- Q# \( y      {  
  
  
• 
  1 D2 f/ I: [( F. O! i. K1 N
  ' D/ ]" _$ u1 E. ^" W8 y2 U          p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  
• 
  
            p=p->next;  
  . f$ n  n8 |  l: }: z
  
• 
  6 z( z' e! [4 }6 w7 f7 o7 `3 j
  ) D7 u4 e- B( T! R3 _8 B- z# x. j      }  
  
  
• 
  
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  & P9 I. }! D1 H
• 
  - O  h, z! E( c% H6 ?5 m
  " e( B8 O+ z2 Y0 J; [; W1 j      {  
  
  & J; `3 z' T. E$ m8 G
• 
  8 a4 V; O% Q/ n
           run->next=finish;  
  9 g2 L/ Z* [3 {! ?3 y& G
  
• 
  
  ; I- a* X8 X, A# Z         finish=run;  
  ; }( K3 w7 f+ n! @
  ) l. b; Y9 P, u- k: |: ?( F" S+ p7 v' s
• 
    ?# d  H' a7 y5 h) B4 A
           run->state='F';  /*置状态为完成态*/  
  
  ) d' {5 q8 o* F0 E
• 
  % b+ M1 `- |% o7 z" L
  3 d3 z- X. _- \( v& T         run=NULL;  /*运行队列头指针为空*/  
  ) E3 |2 J7 _" W0 V& D2 w4 b: S2 O2 k
  
• 
  
  ; u+ P. g* Y' ?: B' y0 R) f         if(ready!=NULL) /*如就绪队列不空*/
  
  
• 
  3 \) @! o, L# W: ^& c8 [' b
  2 C" M# J7 h( h" \" z         {  
  
  
• 
  / }" O7 n' j7 S. r* a8 X& U" z
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  * o: V' ?* d) l: p5 g& W+ B& d9 E, c
  + C* l2 i: q: B7 f( k% u
• 
  , x8 E- e8 K* R; Y% [8 m2 I- Q$ W( ]
           }
  ' ]# \3 z! I( o
  6 l' a& x7 D6 q4 ~; E
• 
  
  / n0 U; J, d1 @6 s# ?- n      }  
  5 S+ k& a6 M/ |) F6 D' j
  9 j& S, l* Q8 s7 b3 Q+ @
• 
  5 F/ z  j% `& C" R0 f9 E3 R4 `! |
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  
       if((ready!=NULL)&&(run->prio<ready->prio))  
    V; L: f: D9 ^. R+ t
  
• 
  
       {  
  
  . P" W* O* D+ O3 D' y. z
• 
  
  ( [- D1 q' J9 V5 I# w0 ]! n; j0 E        run->state='W';  
  1 l( M! G2 g( W* X4 m6 O8 U
  
• 
  0 j  H4 p- g4 E9 l% q! G( B; p
          insert1(run);  
  + O; x, L8 s3 R" `
  ) v- F* s7 Q( e. A
• 
  7 C: p! M+ F2 q. {1 h" O. r. j' O
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  + N7 L9 T9 U/ S
• 
  
  " ?0 S% a0 [, H/ Q* F( T+ U4 r     }  
  # V1 c2 Y2 L3 a: }
  
• 
  
        prt(alg); /*输出进程PCB信息*/  
  & x( F1 K: j2 C$ U  t
  
• 
  ! [6 f8 O3 X4 D
     }  
  
  
• 
  
  ! `( f; Y# R( ?1 n( o% c9 F}  
  ' f6 ]9 F0 p  a% ?( V% _' ^. P8 T
  
• 
  
  /*主函数*/  
  
  
• 
  3 m0 _: a' [$ H  S( \$ _, x
  6 p! p/ \  L1 h; |+ A* }6 }5 f- J7 kmain()  
  
  
• 
  
  + m9 T7 {- q# U+ i, @  k; l$ G; P{  
  
  ! j  k  `- u' ]: _" Q. c7 B' K% n
• 
  . c& A2 y) q. d' u7 O$ U
  % Y# r1 M) g9 g) e2 S   char algo;  /*算法标记*/  
  
  3 U8 v2 o/ m2 l4 q- H/ _3 z
• 
  9 p- f! N) D! B( y( A" x
  - n& e/ M" r3 q' W# B   printf("输入P确定算法：优先数算法\n");  
  0 [* i1 T0 f; g  t4 W4 E2 Q
  & q6 P7 h% a+ c) `: \) d: n3 A0 F. L
• 
  / h$ v* @3 Q- T, [
  3 K8 q7 ^; g$ B0 r- L   scanf("%c",&algo); /*输入字符确定算法*/  
  
  1 N# I+ x: e) k. j
• 
    U3 Q+ S- f: M( ~
  * `2 D& b5 D/ ^! \; V' w* `   printf("输入进程数：\n");  
  
  
• 
  " u9 E0 Q3 i* }& Y
  ) ~) j" |4 U. }: T: N) `: L   scanf("%d",&N); /*输入进程数*/  
  8 _4 c! K& X7 \  x/ @* O) ]8 p
  - D( s. i1 O7 Q, f% `% @
• 
  0 G( l$ V+ K& Z, t
  . u. m( w$ g3 a3 f$ k   if(algo=='P'||algo=='p')  
  - e  A$ Y5 A9 _4 ]+ k6 p. h- s
  4 [4 b3 W! w; f& E0 e
• 
  
     {  
  
  ! P* M! w, z7 n3 a
• 
  . e6 k! e, L6 z+ O$ N
        create(algo); /*优先数法*/  
  
  
• 
  
  5 X! L" z4 z9 c5 h      priority(algo);  
  6 i2 n2 B  s8 x
  
• 
  
     }
  9 e* W; y- u3 y& W) S( O3 v0 Q
  ! z1 J& ~. F+ G5 p9 i& {
• 
    D9 c+ {" w* T8 M. d+ W/ Q
  ! V# w) m# l2 x. {8 [}
  ! V! g! \0 ?" d# v# {- p2 B( F) a
  - R% Q4 I3 t- Q2 H0 V0 C7 H
  , e8 C; X  m0 f, e2 y! y

输出结果：

$ k4 N/ j7 E0 m% v* v: @/ I原文：https://blog.csdn.net/weixin_40962955/article/details/80072769