优先级调度算法

杨利霞

优先级调度算法

算法介绍
, A( J/ Z; f: u5 \0 p6 U优先调度算法的类型（用于作业调度）
; N' F' K$ x( g& s2 W3 g1）非抢占式优先权调度算法
0 I8 t4 y# _" L$ S8 h系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
# }4 @- n' P& Y" L% n# n只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
( P4 z4 x( P, P0 A0 k4 Z

2）动态优先权

算法实现

抢占式动态优先权：

* P( _/ C" m+ V' s: i: w# lPS：本人认为非抢占式静态优先权没有实际价值。

• 
  / `, B1 g- @' _$ \% T9 r2 i: t
  #include <stdio.h>
  , s4 }' Q5 D& i& ^/ i1 F
  - ^5 Q3 G" q7 D' z
• 
  * i. w* c- D$ O2 u6 @" n: R; Y
  #include <stdlib.h>  
    E! s6 I+ g- ]3 g) [- W* ]
  
• 
  ! U5 X0 D1 w2 D4 n) C
  #include <string.h>  
  
  
• 
  5 s6 O) ?8 E4 [% t. r( B2 q* D
  typedef struct node  
  % m" g  W5 s" y7 ^
  % K+ s& M2 l* j% w- e' @4 V8 A
• 
  
  1 K! C' ?, _# h# K( z5 P{  
  
  
• 
  
  6 S; ?" O4 e/ t   char name[10];  /*进程标识符*/  
  
  0 b7 {3 N/ U. M
• 
  , X+ o- X+ L9 o% L$ _; s9 R; p& Y
  3 [; ?; Z; L$ u9 ]   int prio;   /*进程优先数*/  
  6 w/ l4 C3 V8 h' {3 p$ X
  
• 
  1 l* S& |4 J( T- O
  $ o7 ^+ S  f% \' |$ b: y/ p% L& J" r   int round;  /*进程时间轮转时间片*/  
  % ]- ?; \- B- w: V1 |! b
  
• 
    L( [! f: }8 r2 }4 z1 K
  # F# E8 z9 l2 Y, y6 e' l. [. A2 a0 E   int cputime; /*进程占用CPU时间*/  
  2 Y" ]. ]4 z* r+ ^
  & O3 O) e; ]; U8 T& v
• 
  
     int needtime; /*进程到完成还要的时间*/  
  
  4 n  Z" f- k5 O( U  v4 Z2 E
• 
  7 s7 ]: X& i% e- g$ ?
  3 C# x& U4 Q% Y2 Z, U" a' l   int count;  /*计数器*/  
  - e7 Z1 c' L/ k& F3 O) H% t
  
• 
  
     char state; /*进程的状态*/  
  0 N/ F0 h' d9 W7 M! S
  
• 
  + d( f6 h2 k5 G1 Z- e
  " i4 r2 \0 q4 h: f   struct node *next; /*链指针*/  
  
  : {3 [: m8 @  ]( s$ j
• 
  
  }PCB;  
  ; \" E! q: ~3 |: V  \4 T7 ?/ Q
  
• 
  $ g8 `+ X0 H5 a( Y6 K& U! V1 {
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  , \$ S& c! z. ^( V; q1 _& b
  $ D% X) p/ }- V1 |( P) @- ^
• 
  , `2 \6 ?! B! l: w
  int N; /*进程数*/  
  
  9 f5 i( g' ^2 }3 I) ?! ^
• 
  & p$ K- I1 a- ~: L; k
  ; \- r0 Q" U' y6 ]0 w/*将就绪队列中的第一个进程投入运行*/  
  
  8 {6 }- m/ Z2 S" Y+ l
• 
  
  8 H3 y% f% T! }! _% g0 A2 y; m6 |firstin()  
  
  
• 
  
  ( `& l# D# W) x0 Z$ e  y{  
  
  , {% ~& a5 k( R- d2 G
• 
  2 Y) b; P7 W6 l9 r) P0 V7 c5 b
  4 |' }- m6 m( F( o1 |% ^+ _   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  ! E1 C8 N) A1 r3 K( s
  / S# V) [: @' u! d& I. e3 R
• 
  3 m2 A, N( [& [/ X; g) r
     run->state='R';   /*进程状态变为运行态*/  
  : `( d# m) \  U. T" q$ N, N
  
• 
  
  7 V/ S; l/ k9 Z) ^8 @4 L( H1 F9 V& A( @   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  
• 
  # E1 j9 j  f9 f
  }  
  
  
• 
  
  /*标题输出函数*/  
  
  9 m6 O: i* E' m
• 
  
  4 p; |' m" ?. P* v% X, U) J* qvoid prt1(char a)  
  
  
• 
  " w; S" R, c7 T( r4 y
  {  
  
  8 t* N+ [! o& {& [3 `. n
• 
  
     if(toupper(a)=='P') /*优先数法*/  
  
  3 ^9 w, Q: Y7 L& M$ }/ ~7 B+ L3 E
• 
  
  6 N; P0 d  K: _' h      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
    Z5 W+ a* }3 K2 [
  4 [. Y' A0 C* l" ~2 M3 x8 Z5 d
• 
  2 J! [2 l$ S; V
  0 I) O) @8 F+ x+ b8 B   else  
  # {; h" H* Z8 N$ |
  
• 
  ! ~" q& E. E8 a2 y+ Z6 ~
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  4 U/ `# [6 n/ w/ I0 c: Z9 S
• 
  $ ?; `& R# e9 g! ^/ L. x
  ! B2 H5 a4 b" m$ f2 ]  X. B}  
  
  ; Q3 c0 [2 t; k- w: x" v$ N) F
• 
  - j/ g7 ?$ X6 w1 x1 i
  2 u! f1 @5 }8 Y- ^% R$ I/*进程PCB输出*/  
  4 ^+ c- h7 ?) z, t+ b( y, j
  
• 
  . {8 Y9 ~5 V' ^6 R% M
  void prt2(char a,PCB *q)  
  4 Z7 P9 L- a$ h) W7 O
  
• 
  
  {  
  
  
• 
  * X  n; t  N4 C3 o1 D3 y  T
     if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  - `7 n, q, s+ I! ~$ v6 H
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  # h* l" @5 w4 K9 e# I# o6 U
  ! H; O2 W0 ]( e0 E5 s) y4 }
• 
  
         q->cputime,q->needtime,q->prio,q->state);  
  
  2 B, I3 i7 L/ m% G  o
• 
  ( I/ I) {9 H+ z
     else/*轮转法的输出*/  
  3 B  Q# F! p# ]
  
• 
  2 P# D' b6 ~9 q) u8 |& q0 ~/ V
  ' ~, R) L; V8 d& o4 H      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  ' C: `: w: F  Y% o+ t# q) h
  
• 
  
         q->cputime,q->needtime,q->count,q->round,q->state);  
  $ j' T$ G( E! u; l5 L3 L
  
• 
  " i1 P. G# T. z, }$ r2 Z
  }  
  , G$ Z5 p: C2 I+ O$ D7 d  Q. N7 T
  
• 
  / N% o* K# u  t7 `* D) ?; ]
  /*输出函数*/  
  . }* ?/ Y1 }6 v7 x. d
  
• 
  
  void prt(char algo)  
  
  . s+ Y( e7 ?. M: S  H& b4 Q
• 
  
  . D+ V+ J6 _, V, L" n: E$ r' U{  
  , q" v& v) e3 R/ _9 F
  
• 
  ( L5 u7 m, a. v3 o* J
  $ o6 W7 d; z+ F. j' c   PCB *p;  
  
  
• 
  
  0 _, [  [/ J3 d; F$ }0 v   prt1(algo);  /*输出标题*/  
  7 V. U2 ~+ g, O3 X2 l7 X, n
  ; w! U$ _5 K' y
• 
  
  9 p" r0 I% @  X4 X* j2 ?   if(run!=NULL) /*如果运行指针不空*/  
  
  
• 
  
  & j) w2 P4 \/ `      prt2(algo,run); /*输出当前正在运行的PCB*/  
  9 w* b5 w8 V4 e/ s4 M  N1 A
  
• 
    u! j6 {3 C) D+ @! E
     p=ready;  /*输出就绪队列PCB*/  
  
  
• 
  ) ^& R: p8 ^+ ?, m
  ! T$ t* x) e# G) g   while(p!=NULL)  
  
  
• 
  
  ! W6 G3 m) W2 g   {  
  
  
• 
  
        prt2(algo,p);  
  ' R) a: I8 g) g; z! ~1 S" J% j/ P- f
  
• 
  4 U) v+ Z3 T3 A: V$ M
  0 x0 f' U; _# |0 F3 z* n, D  E' d      p=p->next;  
  5 x, T9 z: E  P+ @
  ) e$ v% i% M9 f" g
• 
  / [5 n3 V8 K: c, ~7 K: P0 l
  7 d: j5 }( V- h% v   }  
  
  
• 
  7 p2 ?; F$ y0 @5 q  ]1 ^# f# A+ z
  / l  k3 r. L( l* x# e5 o6 B   p=finish;  /*输出完成队列的PCB*/  
  5 V, Q+ w. k/ \( {  B0 d
  4 K! F/ W! T9 ^5 b1 m
• 
  
     while(p!=NULL)  
  
  3 ~3 ]; T% f  a( U( t  C7 M) ]: f* g
• 
  ) R4 r" n8 R) B7 z1 S( G
    n+ p( o7 I( f' w   {  
  ! q6 u; M5 j/ M  l$ N& g" t
  8 M) L: V0 r: _9 c% S
• 
  
        prt2(algo,p);  
  & F3 C2 H9 J# q8 B' g* R2 _# ~$ @
  3 C% {0 j. y; i# k7 c
• 
  
        p=p->next;  
  
  ) y& o" Q2 Q" [0 N5 e+ i
• 
  : I  w" S4 d1 s0 D+ [1 M% Z9 f, ^
     }  
  3 w; f( q6 G; Q. q# \3 s
  
• 
  # V1 }! z2 e/ O; s- z* ]4 n) R
  , C: w7 `2 K/ }- A- O( B$ ?   getchar();  /*压任意键继续*/  
  . }7 @7 q2 I1 Q. r7 h  ?! U# g
  & g9 M  o& M2 G, u
• 
  
  9 b1 P+ G; p; b; E" ?}  
  
  " K$ y. ?8 U$ x* n( f2 {' D6 T
• 
  ( X7 X+ w! t4 l( B- K/ }6 L- \
  : a1 ^  B# i) ^0 w! @9 I/*优先数的插入算法*/  
  7 F! A4 F6 V2 t' i+ E" Z: e
  , i7 g; z3 w0 d- ^6 s* W2 Z( l
• 
  
  insert1(PCB *q)  
  
  
• 
  
  ; Y2 a$ q+ `0 O* C, ]' Q3 a3 g: j{  
  ' T: q0 h, ]. `# r' f1 ~
  
• 
  
     PCB *p1,*s,*r;  
  % G! \, t* }0 v
  + w4 ~4 ?$ _, \2 Z3 Q# q+ i
• 
  6 l5 d9 k7 k1 A; v' U9 B* Y
     int b;  
  
  
• 
  
  8 t! L/ X' ^; }1 ]" p6 x   s=q;  /*待插入的PCB指针*/  
  ' D' j4 @* g& ~5 y  i& c: W! |
  
• 
  * y1 H+ n& D7 h- Z
  5 |  P1 S# O+ N+ w  k# Z$ W   p1=ready; /*就绪队列头指针*/  
  # f7 I- x( s/ ]/ P0 l) y) e
  
• 
  
  0 h# M) }+ z, t# n( V   r=p1; /*r做p1的前驱指针*/  
  5 a1 K% g7 z5 ~8 u8 L$ Q
  * @3 X, F1 o1 Y
• 
  
     b=1;  
  
  
• 
  , G7 t9 f( z9 d( f& `
  ) }1 f3 ~: b7 E; y   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  
• 
  
        if(p1->prio>=s->prio)  
  / P. f: r& g+ B. ?$ u9 w8 x8 \! n
  $ @2 U: v, @* G1 N& d
• 
  ' v" @  ~2 Y; H- |. P2 e+ s
        {  
  
  - W- D' I  j2 o& @( W  W. S9 g
• 
  3 ]% i) W/ c; f, h9 q
       r=p1;  
  
  ; B6 {- p8 ]3 D. _- `3 }, d* g
• 
  2 Q! n# o9 p& l" X- Z; F5 K
       p1=p1->next;  
  2 z' M  Q  _3 ^; L
  
• 
  * G, h6 R# @  d  ?
        }  
  
  5 P: c0 ]0 b+ f; h! p6 u/ H9 L
• 
  0 ?: m' a6 ~5 m1 I! \
        else  
  
  8 Y& z/ P; t( s  H: `  h# B
• 
  
       b=0;  
  0 E" h& y" T% d
  6 {# m! ?% x, `9 c8 ]
• 
  ; e* Z! r9 q1 i. \3 \
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  5 j4 b6 n% w, s. S; A* f1 K, [
     {  
  . X( q- e8 C& y1 ]/ U8 A& D5 K
  
• 
  3 r* d4 t5 B% U/ [& D" p& F" j
        r->next=s;  
  
  
• 
  
  - [. ?! r! p8 a* ?; _) S' _" h      s->next=p1;  
  7 g- Q' P4 P2 n9 a& W
  
• 
  ) [' _+ \8 M  ?1 c
  . N2 x6 V7 S. w. _3 ~+ w8 _" c   }  
  % ~' C4 b3 ^3 [/ g/ s: U
  
• 
  
  * R5 F# @6 R6 _& n4 a   else  
  
  7 ^+ I6 ?3 Y& M' I) {% o  e: [
• 
  
     {  
  
  8 w% X# f# Y. p; N5 S
• 
  : p' H4 k$ `9 S6 Z: R
  8 t5 r) @6 ?# o& z      s->next=p1;  /*否则插入在就绪队列的头*/  
  
  
• 
  
        ready=s;  
  6 O0 h$ \0 I1 r( z; O
  
• 
  
  , e; Y! M- H! M% h6 W3 e9 H   }  
  " j" L& y: y) A2 _/ S9 {& i
  6 I: ?6 g$ r* I5 q
• 
  
  }  
  
  
• 
  : ~" G" |* m: ~$ `$ h" S
  - i9 v* X0 P9 Y6 ^: w, e& M& K/*优先数创建初始PCB信息*/  
  3 r5 d) ^" Y- C
  
• 
  
  void create(char alg)  
  # j0 F) q% }" y5 Z4 U
  " v1 F' {& ^0 z$ H9 i
• 
  % c4 [2 s: n# Z# A
  / Z& X" K* ~; s. V% A! d% j{  
  . S; |. o8 K$ ]+ B/ D6 j
  
• 
  5 I2 g5 D0 u9 B" x) v0 B5 k
     PCB *p;  
  4 c2 H" w* p9 G" s. Q- K% c
  
• 
  
     int i,time;  
  
  
• 
  2 e3 J% u6 Q9 W- \/ X' i; X  |" N
  ' h( x' Q9 \& \   char na[10];  
  : w/ N/ N4 g( V0 J/ V
  + ?/ a3 g. P" q2 e# o( l
• 
  % D, c) c( I! S! T$ _9 Y. E
     ready=NULL; /*就绪队列头指针*/  
    ]/ X7 |! r4 i3 C. F/ c* n
  
• 
  ' U( D; b9 c) `2 B. c6 t) T) G( j. r
     finish=NULL;  /*完成队列头指针*/  
  . {$ J+ G6 i4 {
  
• 
  
     run=NULL; /*运行队列指针*/  
  
  + F% O" D& z, @( S' w
• 
  
  " |& c6 A: X7 I2 g, G( s5 e   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  8 t7 C1 S3 v; u
• 
  4 K5 d8 ^4 i5 G
     for(i=1;i<=N;i++)  
  4 C! a* Y8 t: ]
  
• 
  . K0 [4 L" B5 o9 c
  6 V/ R. ^" s0 V   {  
  $ S: i  C7 H: X) H' n. D
  
• 
  ' W# s, g: `. {7 x* {; q% k
  0 ~. s0 R0 M3 ]% {- r* h; T; C      p=(PCB *)malloc(sizeof(PCB));  
  ; e" b* c: s6 _# `7 C
  
• 
  
        scanf("%s",na);  
  
  
• 
  
  ; N( I) G8 {- I5 N9 [" X      scanf("%d",&time);  
  ' y9 N3 d4 |1 X
  
• 
  
        strcpy(p->name,na);  
  
  0 A8 L; S+ c- V1 [" N2 K
• 
  
        p->cputime=0;  
  
  
• 
  
  4 v  F! ?4 B8 \& @: b& |& H      p->needtime=time;  
  
  4 W! \5 m! c, b" [1 I
• 
  ! _0 M0 D. i( t$ _
        p->state='w';  
  
  
• 
  0 o) b+ @9 ]# u* }$ _% R2 ?
  " \; s, R9 W! h# r* \      p->prio=50-time;  
  ( i' A6 p* `) {5 Z
  
• 
  
  ' b  N" H- t* D8 b- @7 d      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  & H% l/ k/ x" L* }5 X. i
  
• 
  
       insert1(p);  
  
  . n( E+ f& o+ N9 }  M
• 
  
        else  
  
  # n$ g" _! p. L
• 
  ; \/ {, |6 j4 _) E# {" l# T
        {  
  ; k: m) r! x* {: m# g% C4 u
  ( M# d& ~+ i) _  G% R
• 
  2 o$ z9 E+ c! j1 K9 t9 o( i
  ! u( E7 \1 V  a+ P# W: q, y; w7 A" h5 I     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  7 M  A1 D) u* t
• 
  1 h) `; h: s9 b, C9 \$ x# A
       ready=p;  
  ( B& X5 h1 X* i  Z
  + [- C* f6 S/ I) ?# R/ L
• 
  & F; I& Z! O# H# f7 u: u! A. N
        }  
  ; y- g5 j5 n2 \5 L7 L# V! g, N: ~- \
  
• 
  7 J/ B/ Q9 f/ g3 [9 s
  ) k% c0 q" R0 j: c; ], C  H" m   }  
  : Y+ S" {" ~* B4 u2 N9 Y& a# D) x
  
• 
  
     printf("          优先数算法输出信息:\n");  
  
  
• 
  
     printf("************************************************\n");  
  
  # |$ q. q, ~6 b8 V! O2 l
• 
  
     prt(alg);  /*输出进程PCB信息*/  
  8 r9 T$ o. y0 |. y
  : |3 f. r7 z$ j
• 
  
  * U% _" g, X4 B   run=ready; /*将就绪队列的第一个进程投入运行*/  
  7 r" Q( `; d# u
  ' q3 o4 T1 [" I7 }
• 
  6 M# K) Q  Z( c9 o  l6 B8 Y
  5 ]# \5 M$ N, K0 y+ E( t) h$ D, E& j   ready=ready->next;  
  5 `1 L  ]0 D- w/ b! c
  2 M, z6 I4 S1 I( H) d3 J* |% U
• 
  " ~0 Z9 Q7 P- C" c1 q; e
     run->state='R';  
  
  
• 
  ; N3 J* F8 @: S' q
  4 X( @9 C3 n: u/ L0 C}  
  & d+ E; R3 X$ V5 A
  " W8 Y: s1 |" p/ t
• 
  
  /*优先数调度算法*/  
  
  
• 
  
  priority(char alg)  
  
  8 g# A$ r: u  ^- U7 I
• 
  
  ' k$ E/ Z) h& Y9 h8 @+ n- l  s9 f{  
  
  
• 
  
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  
• 
  
     {  
  
  % l6 U$ o( R0 `" y- a
• 
  ; A* i$ [4 H# @5 e- g" e& n
  ! e) R! E! G, D  x" G* u; M      run->cputime=run->cputime+1;  
  " q' r) ], @. s6 }& D
  
• 
  
        run->needtime=run->needtime-1;  
  $ C! ?+ M  U* ^
  
• 
  
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  ' Y" _( U  j, p) |  i6 {1 m; r
• 
  
        PCB *p;
  ) O4 F' C/ A# s) p3 y/ _% _% l
  
• 
  5 V  b4 g3 U" d8 \" _6 {
  & q1 y: f, j! n1 E7 @      p=ready;
  ' N$ _- S5 J6 J+ _- \
  8 s7 ]. v; l: J
• 
  . B. J2 e* @$ Z' p4 ?
        while(p!=NULL)  
  * j8 M' j5 ~, [0 @
  ; k  a; Z( |- y& C+ @
• 
  7 A( W5 _  O/ w. v& N
        {  
  7 c6 I" c9 C- u
  : o3 V, p9 T6 T
• 
  ' v. R& n; g& z& _4 `; h
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  7 f9 {% C5 e% n$ J* J# k' r, P1 p
• 
  
            p=p->next;  
  3 O; [+ }8 f/ \8 C1 R+ k! r2 t5 q
  
• 
  
  6 }/ y/ I) L6 i! a, ^7 h& {- G      }  
  , Y5 z  D' P7 B9 z. G8 s- @% r' q
    y  O' V" O0 N5 x
• 
  4 v! Q( ~6 v3 ?$ |" F2 ?! O
  - J5 t; I/ Q+ S( H% U+ b7 y      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  / C: a0 h* H3 W8 R: h6 a  V, f
  
• 
  
        {  
  
  
• 
  
  0 Q/ F2 Q2 P: u6 q  |         run->next=finish;  
  9 D. g$ W* K& ^5 y; ]( r
  5 ~5 p) `4 k. t: w. t( x
• 
  ' _$ x0 p! K- m
  0 D. E! p2 I6 f9 P& x/ l         finish=run;  
  6 B" l( i) d! w7 A
  
• 
  ( }! Z$ y' K" B' C& i1 _; B
           run->state='F';  /*置状态为完成态*/  
  
  
• 
  ; }6 z6 L! m9 U- P0 W- Y6 A
           run=NULL;  /*运行队列头指针为空*/  
  9 i  f% F6 ?  E& G4 @
  " h& S0 O2 L6 _
• 
  
           if(ready!=NULL) /*如就绪队列不空*/
  
  * b. c1 z# f% w" F" L: v. q
• 
  5 N' s  R3 v: S1 D0 S, c
           {  
  
  
• 
  : w7 d* A! ?' F: D; B) h" |
  % \+ c, k' p) A) Q- c            firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  / S# R/ ^! Z# a0 F8 D
• 
  
           }
  " a8 m7 T# K3 F5 Z
  
• 
  
  9 Y9 h4 u5 M( \+ _      }  
  
  
• 
  
  8 B* y' x5 L2 T/ E) C      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  0 G+ b+ h8 P. X
  $ s. f1 E4 D: s5 y7 x
• 
  ! d4 k& k* R! K: M6 @, s
       if((ready!=NULL)&&(run->prio<ready->prio))  
  
  ( ^' V+ e9 W* ?' h4 g7 f! A. w+ `; W
• 
  6 k4 f. d6 X! B) W9 L' S4 A6 h
  $ i$ `. Z& ^+ Z/ }+ m6 U     {  
  8 P, _- U) c5 {: @7 ?9 ]) c, v
  
• 
  4 ]9 `% O% O5 E! t) U: e
          run->state='W';  
  5 ]$ x* T) y. `: k+ E! L  k
  
• 
  * |9 v2 p  c2 O+ E
  - I7 n8 \* N. R8 m        insert1(run);  
  8 J- l+ G9 \3 s1 Z5 r) n
  
• 
  
  ' |4 K( n# C/ _% E5 g1 P, d        firstin(); /*将就绪队列的第一个进程投入运行*/  
  + o+ m+ l( R  P% W8 S
  
• 
  
       }  
  ( f' l( O; C% J6 z1 P
  
• 
  
        prt(alg); /*输出进程PCB信息*/  
  . M7 q- i+ }0 I1 M
  4 R" a7 J& P1 G
• 
  
     }  
  
  7 Q2 X* Y/ p1 K- s2 e$ K. [+ P) J
• 
  
  }  
  & f7 Y& M, L5 M1 x) y' D
  
• 
  
  5 x1 ^  ^" w- {) a# ^7 ^/*主函数*/  
  9 D9 S# M% A5 w- a# Y% n
  7 H9 p. F* ~- d6 }# }6 H
• 
  : Z- k- c0 n7 r- y( Z9 {
  6 U6 x/ q5 c3 m5 }1 K* K0 qmain()  
  
  4 c1 V/ P! @4 m
• 
  9 a) |# }3 [. f! G
  ; h0 K$ K; E4 V9 Q* d  l6 D{  
  
  : ~4 ]- i" J! i) H
• 
  , k7 k1 E! ^5 h! R7 q
     char algo;  /*算法标记*/  
  
  
• 
  
     printf("输入P确定算法：优先数算法\n");  
  
  $ J0 V9 a+ d- j- z8 `# S6 b
• 
  
     scanf("%c",&algo); /*输入字符确定算法*/  
  4 }4 c! y6 T: Q  ^5 W8 V
  " }! A  {' h2 Y; x8 O+ k5 Y
• 
  
     printf("输入进程数：\n");  
  
  + o& f% V. \) M. k& |' W
• 
  
     scanf("%d",&N); /*输入进程数*/  
  & C$ {7 L; z0 G  e, p% f/ P- I
  
• 
  3 o) ^; R: s/ ?9 }- W# T
  & X7 S# }! h7 ~   if(algo=='P'||algo=='p')  
  " _# {% S* n! X0 \0 U" [+ \
  
• 
  
     {  
  8 r; ]) |; m/ s; W
  
• 
  9 f4 l' O: g! o- |! \  S' _
        create(algo); /*优先数法*/  
  
  0 W! H6 _9 \9 A8 S
• 
  
        priority(algo);  
  - R2 r8 `! Z) Y" l5 X, ^, h; M
  
• 
  2 w& n" _% y. S( d* `
  % r$ x+ s; W! I# f: {" ?. c0 ^   }
  
  
• 
  % r# E' ?; |6 ?) c- Q
  }
  2 C: M6 o0 n  j$ ~# J8 `
  
  

3 A8 @; [* H- K6 t输出结果：

) u% X% a5 b; r1 w5 g. \- b% z原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

, u: s9 K9 F  ?5 A
, p6 M) `1 x, |) v( A