数学建模社区-数学中国

标题: 优先级调度算法 [打印本页]

---

作者: 杨利霞    时间: 2021-4-9 15:39
标题: 优先级调度算法

  ~3 Z: _. O7 K: d8 x; N  X9 B) U0 e优先级调度算法
5 R/ M1 U& s6 J

算法介绍
# v' y" q% h6 D8 R2 G, [优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
. N( v$ L: I0 U1 ]2）抢占式优先权调度算法
, J. a, S3 r5 K9 ~/ P) B& h7 Y3 v只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
3 n) Z* x! M: ^5 K0 z$ |1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
( V+ X8 c4 u# C: d

2）动态优先权

算法实现

抢占式动态优先权：

/ H( t) q: f0 O0 [) ]PS：本人认为非抢占式静态优先权没有实际价值。

• 
  
  6 g, \. U+ d! e0 G#include <stdio.h>
  ) e4 s$ @4 @; E5 k. u" z8 J3 T1 m( B
  
• 
  
  #include <stdlib.h>  
  
  , B3 C# }, E8 N. h: [/ I; r3 i
• 
  
  #include <string.h>  
  4 o5 a4 |! K* |: a/ E7 f
  , E9 ~: z" C! G4 a1 @
• 
  
  5 E: [: {# E# r5 a, otypedef struct node  
  
  
• 
  0 ?! G; s% ?- \4 e6 s9 G
  0 q/ y- P2 d' `{  
  
  ! \& e! r* R% J! {5 s
• 
  
     char name[10];  /*进程标识符*/  
  9 J7 Z! H! s) ~9 R2 M
  
• 
  % O$ U7 l2 F% }& V; V
  3 a8 c& W- F- b; r* g   int prio;   /*进程优先数*/  
  / b/ M- G* h6 n, I9 h) k7 ?
  
• 
  
  ) Y2 \" V( G' n' a4 Y+ L: Y   int round;  /*进程时间轮转时间片*/  
  
  
• 
  
  9 A+ M! C0 e* ~& d: g( ^   int cputime; /*进程占用CPU时间*/  
  9 L6 ~7 H  `  _3 C! S7 O
  
• 
  0 M! F; H6 y( L2 A' \7 J/ d
  3 t( Z+ w( @. L/ A" F   int needtime; /*进程到完成还要的时间*/  
  % N0 ?$ H5 }: D7 e( S0 [- ]
  
• 
  3 `  |2 U3 Q7 `, L: J7 G% v7 u- B
     int count;  /*计数器*/  
  
  
• 
  
     char state; /*进程的状态*/  
  9 z5 G" F3 a3 c5 @. |) O
  1 m. g$ ?1 d( ^) Z4 ?# h/ H: N) B9 D! V
• 
  
  . s3 e  n# Q! u4 f9 h* z   struct node *next; /*链指针*/  
  
  " y, K$ f8 y/ y- o& [4 Y& V0 X6 Z
• 
  " a0 I3 M) j* N2 v, S
  }PCB;  
  
  
• 
  
  6 x, A* k- p: g4 p( APCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  
• 
  ! _/ `2 w$ {1 R- I3 \5 ?( U( L
  int N; /*进程数*/  
  ; `; B' I8 _" Q) ?, v
  
• 
  # a2 h5 C6 t2 ]- l# k: y
    H, ^: ?. C5 ]% ~9 q/ |4 k# L/ d$ S& K/*将就绪队列中的第一个进程投入运行*/  
  0 _# @) i8 H$ r) `1 D7 P
  
• 
  : m8 ]6 ]* ?% |( C2 ]
  ( |' W; V! I/ U6 b' ufirstin()  
  
  / h9 H7 E+ |; M/ m, v, g
• 
  
  $ e* J- d) U) z  f# @{  
  
  ! S) \  m. C* w) C0 y6 l
• 
  
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  7 t  ^2 h7 G" a
  7 X9 w, e! `, U$ |
• 
  , G( n) t5 ~  Y% W, [' N/ E. ~
     run->state='R';   /*进程状态变为运行态*/  
  
  
• 
  
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  $ y1 I5 Z8 U* p+ @% H
• 
  9 J0 s: r2 u7 Y1 n: {/ C$ K
  6 |/ k& a' X* i4 |+ e8 U}  
  ( r6 [' X5 I1 g0 n4 v1 ]& t
  
• 
  4 d, E: m$ `$ L
  # U, a! P( u1 Z7 f2 B# x/*标题输出函数*/  
  ( f3 ^4 \: R, z: s: W$ J
  & m  Q' O2 G0 F( }& F7 N. S7 y
• 
  
  void prt1(char a)  
  
  
• 
    k, g% j' z  e- e/ w% u
  {  
  
  : r/ A( ]& ]3 Y
• 
  
  . F: E0 a: U, A% D   if(toupper(a)=='P') /*优先数法*/  
  $ ^% `& f$ R* B' k2 [) a( [
  : u- g; N6 L* i
• 
  
  3 o8 ~! C( G3 k5 P& s: B/ p      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  / S3 C2 J6 \+ R
• 
  
     else  
  ( _" l& F- z+ V9 n5 r
  9 u: p, \# x: b8 V$ I, y- E
• 
  
  7 z" P: T  G& R* w6 v      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  ; g+ b1 G8 z0 g
• 
  - s/ H5 i8 p0 \4 E( S  f6 ]
  }  
  
  
• 
  
  /*进程PCB输出*/  
  . u- T7 _" i0 n0 Q' V) o
  9 R' c- ]: k' B5 N: G8 T! ]
• 
  
  void prt2(char a,PCB *q)  
  
  
• 
  
  4 n0 X: g- r) ]% m{  
  # U, N9 C* Z  e- R
  
• 
  
  % M; J" z, G4 X   if(toupper(a)=='P')  /*优先数法的输出*/  
  
  
• 
  3 ]& h4 f" r! u7 o
  , t- H9 v; [1 l# ?5 Y7 J      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  " w$ k# g3 B1 A, S
  * P0 J) V: C, D' u' G
• 
  
  . z) }4 H* W& s& P% p       q->cputime,q->needtime,q->prio,q->state);  
  0 |7 L8 {$ r) A' g7 ^. d! O
  ! S# N6 {% ?! R* z1 y( v* q3 N6 o( a
• 
  
  , U- _$ B( u. f+ s3 \& g   else/*轮转法的输出*/  
  , d" o" Q' y5 G& }1 [
  3 V% ?. X3 F) F$ T" t* o  e3 Q
• 
  ) \; e8 ~  s: A! w1 O9 @, u- q
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  8 v: X' q2 M& {; n) b5 }
• 
  
  5 u  E% H3 |8 W6 \       q->cputime,q->needtime,q->count,q->round,q->state);  
  
  0 r+ I8 h9 Q" b6 y# t
• 
  ! y8 C; S8 e) k8 y( j9 I- V$ A5 T! E
  }  
  4 X  @2 @* g( M' d8 |
  
• 
  
  4 ?  i2 @# k! F/*输出函数*/  
  ' _5 v9 R/ M$ e9 \) P! k1 \2 P
  4 ]; t0 M! s# G2 M
• 
  
  void prt(char algo)  
  
  
• 
  0 k4 g# d4 c4 ]
  {  
  
  * j: c- q7 U( W0 q9 m/ g+ ~
• 
  ' Y8 i. W9 c& B/ G# W$ H3 U
     PCB *p;  
  3 a% V& n: Y6 o% @
  ) |, p+ D. i$ ~& g6 o
• 
  & g$ X( |: r) Y  o5 p
     prt1(algo);  /*输出标题*/  
  
  
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  ( e( l* S" m. i
  4 V3 `! l! z( H
• 
  
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  
• 
  
     p=ready;  /*输出就绪队列PCB*/  
  ; w0 z# Y( [. b$ t! B/ I
  
• 
  4 U  m4 z, k2 Q6 r3 c$ W. R* C
     while(p!=NULL)  
  - k9 }+ c( s  Y' `$ @6 c  D
  8 \+ t. }8 q1 C  b+ D) h
• 
  % o' v$ A4 W3 w1 B7 n
     {  
  / H0 P6 w. N2 {% A% R" N4 Z
  
• 
  
        prt2(algo,p);  
  7 N0 c) L/ B3 t4 p' v
  
• 
  8 N- T3 z6 r4 I; J: ?
        p=p->next;  
  
  2 y* `+ B; l3 R+ g: H% r
• 
  
     }  
  2 w- V' W. I, c/ |% B
  9 W; W* ]7 k: x" ]  \
• 
  ! Q# I0 p: g9 J9 w/ A+ b
  ) N* f( b0 n& P) m6 g& u5 M2 J5 G; l) ?   p=finish;  /*输出完成队列的PCB*/  
  
  3 N. \0 L: u$ n4 E: Q
• 
  , c. N' L3 f- V/ L( t: Z: K
  / F; C$ y- [# y" j% Y" H   while(p!=NULL)  
  8 T! \% ^% t! J8 E2 D! V/ K
  & N9 H, Y6 D' |3 O
• 
  9 Y) Y& m0 N8 y5 N0 w
  + Q& D, @. s7 e0 p! `   {  
  " h; H! ]+ R' E* P9 N4 i
  : p" M! O2 H& L) L6 p4 ]
• 
  
  : p* F7 V$ }9 L1 }' y      prt2(algo,p);  
  , [/ u; \2 p! }! Y
  # C3 B6 V& v3 H# O% @
• 
  , j8 y3 V# q" `' E
        p=p->next;  
  8 P. J' Z; k. c
  1 {4 o) o3 o2 X, E
• 
  
     }  
  0 y! {$ r( \4 S  ^6 `( q2 y
  7 Q5 ^  ?7 p8 U2 C2 i- w$ i
• 
  5 o; @2 x1 ?# z9 d- l! L
     getchar();  /*压任意键继续*/  
  4 z3 N. K: p/ V, ^
  1 A9 Y2 W6 [5 u; l0 i0 M
• 
  3 ~2 P% I6 S. m# F  a% E9 f+ o7 S1 [# ]
  }  
  % u! S( L0 S, l( N
  0 X; t3 P5 R# g+ J9 n7 A& C: E
• 
  3 v& l; p. m( p
  . a! b  g/ v* t) Q+ r- ?/*优先数的插入算法*/  
  5 r  Z& w, S& y, G( m
  
• 
  7 a( a% D8 Z" \  e7 E6 N! Z
  insert1(PCB *q)  
  7 P$ t! p0 I# x
  
• 
  3 m( S, h0 g: W8 Z% \% U
  {  
  # O% D5 |0 @5 M. m$ F# R+ x. G: D
  
• 
  . R* [# Q+ O; `* [2 U
     PCB *p1,*s,*r;  
  3 m0 l1 u+ o0 {5 n5 m
  
• 
  
     int b;  
  
  
• 
  
  1 L2 d, ?+ Z) n) p: J2 X   s=q;  /*待插入的PCB指针*/  
  
  8 O/ Q/ H/ ~! w& X0 v. S: D$ m6 b3 ?
• 
  , h6 B, m6 n! @- R, ^+ J
  2 I% e2 _" y, R/ o   p1=ready; /*就绪队列头指针*/  
  : T1 I0 y+ O3 q: v" z5 |5 i
  & q1 v6 {+ J3 \" ]" i- y
• 
  
  & T" y8 K' [2 w& p5 C   r=p1; /*r做p1的前驱指针*/  
  
  ( n7 e7 M  R& `! {' O% E0 s
• 
  
  1 x$ [/ c% G  \, I( b0 K) Q   b=1;  
  
  ; D3 v  W  O5 P9 r
• 
  ) c9 L1 {4 K7 q
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  6 P! H% J$ b9 I/ B$ i8 M
  
• 
  
  2 v3 p, \! e) W* g0 \9 r, y! T9 H3 C% d      if(p1->prio>=s->prio)  
  8 b# E6 t7 i, q( c8 W
  
• 
  / P8 Y  @  E% d( {) X2 \& L
  , N+ c" c% Q! R. u      {  
  
  
• 
  
       r=p1;  
  5 j% J# X1 k$ H1 c4 q+ d) @) n
  
• 
  
       p1=p1->next;  
  4 c7 L" P) h3 ^6 {( r
  
• 
  ( @5 e- j' U1 [  v
  ' x! Y. b1 t! F: s0 M- _6 e" }9 y      }  
  & X+ Q$ p# i" [  b0 N
  ; L' H) t9 q! S' c; P
• 
  ( y; G! E: l: Z( v
  . b& b8 v% F, |; B      else  
  
  
• 
  5 E- w/ ~3 b$ T% G& I
       b=0;  
  ; X% {1 f  r! E4 `. ~
  ! ?# q& T( @8 m: y4 d2 \5 D0 j, T4 r
• 
  
  ( I8 L( D* Y1 k$ z* I$ d% E: w) C   if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  ' Q! I# ^; y8 ~% s* g8 m/ i1 |
  ) N0 I! ^% ?* z! j
• 
  
     {  
  
  
• 
  
        r->next=s;  
  8 f) Q6 ~1 \. d5 ?9 V
  
• 
  
        s->next=p1;  
  9 C5 {7 q' Y( B4 E- _0 |' t
  ; ~/ {: V- w- ^' @1 c
• 
  5 A+ C( |9 |. r6 l* r; T
     }  
  
  6 f6 w2 g6 E4 ?5 j5 v& I, U
• 
  ! T2 u6 v' n2 a4 ^: u6 f
  / @5 D. l" P+ ^6 N' o$ i   else  
  : _, |) H) |3 G! L
  2 D  @+ D2 J# m: ^9 T
• 
  
  ) n7 C' ~% g, d: @" N! F   {  
  9 E; U2 r8 X! M0 r8 ^
  
• 
  
  5 o8 O4 I. N- l3 f5 d8 o; d1 {      s->next=p1;  /*否则插入在就绪队列的头*/  
  2 {+ k3 r9 R! ?1 s; z3 f6 e$ Y% {
  
• 
  
  4 f) g  s8 y1 _! I- d' n/ f  g      ready=s;  
  
  
• 
  " v5 P. h* v/ v7 ~' j* `& x; n
     }  
  
  
• 
  ; ~: ~( [/ a! g. k
  & s& q2 D5 P- I}  
  2 M8 @8 o4 g/ B7 p" Z
  : z* X9 G* s# T
• 
  % ?3 Z/ Y% W& L. G8 r( |
  ; J! F' ?0 {! F/*优先数创建初始PCB信息*/  
  
  
• 
  , I# N6 k: z7 s( Y  C- T" y& m
  void create(char alg)  
  
  ! [3 J# M  E2 H. a9 ?$ t2 t
• 
  
  {  
  ; d% r& F& ]# U" X' ?7 L
  
• 
  
  ; H" @$ W$ G" ~   PCB *p;  
  
  
• 
  
  * [1 O4 n+ S$ g7 `5 K. O7 |# ~   int i,time;  
  
  1 Z2 K* \5 Y1 N4 q
• 
  ( {2 X/ t/ U% R
  2 N+ C, F* M$ ]. Z' w   char na[10];  
  - n5 m% @5 t* l; M& P2 a' b
  
• 
  ) D. m5 ~! q5 G; D
  & N% L- `6 [4 z5 e( T   ready=NULL; /*就绪队列头指针*/  
  
  
• 
  
  8 N  @- T( {8 n6 y   finish=NULL;  /*完成队列头指针*/  
  3 V/ k. k" e' S3 {6 v. s
  
• 
  
     run=NULL; /*运行队列指针*/  
  
  2 h$ w/ Q3 [) a
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  4 v8 A9 F% N3 |' K
  ! ~( Q3 c% R" B/ Q5 w
• 
  8 l; {9 g5 @4 d3 K
     for(i=1;i<=N;i++)  
  / n. P* I) y( G7 ?5 M8 t  `9 Z/ Y8 u
  
• 
  
  ; e1 O# a4 z. {( v3 I( Q( b2 z   {  
  
  
• 
  7 Y3 {+ G* ]+ g
  ' Y5 M' T( w$ s+ Q* ^9 \      p=(PCB *)malloc(sizeof(PCB));  
  4 S& w9 |# H' l2 t+ U
  
• 
  
        scanf("%s",na);  
  ' }# J1 ?/ o3 f1 S' K- s
  2 ^5 R; |4 Q5 l; y6 i
• 
  * Z" d) L; p; o, Z4 K8 j
  . v; B$ }8 b' ~- l      scanf("%d",&time);  
  
  
• 
  
  9 O: r: P' Q4 Y$ q8 y8 ?; f2 P      strcpy(p->name,na);  
  0 ?5 t5 B# S6 m0 w+ [, Q
  9 [, J2 ]& J* V
• 
  4 N. m7 y* i: ~5 H
  * m5 K' _3 \. p* A6 m      p->cputime=0;  
  . d4 G* [( b& M8 k
  
• 
  + `, p& J7 [/ u. `/ i
  " O: `1 _' l6 ~5 C      p->needtime=time;  
  
  
• 
  
        p->state='w';  
  
  
• 
  , n$ p* D9 m1 L9 Q
  8 E% f7 K* @2 ?      p->prio=50-time;  
  1 b1 m% l4 i# J( \5 g) g) g* |0 B
  0 a" n3 G& A/ ?- E
• 
  . ?  X* `9 K' E& @
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
    X4 T. G, m# o! f5 J8 w
  0 C1 L5 B4 u- c
• 
  6 V# `/ {$ Y+ r" I0 y
       insert1(p);  
  
  
• 
  
  9 M6 _' _! ]8 e' _1 Y      else  
  
  % n; a/ a0 F& M: j+ s
• 
  
  / G2 Y' P& {+ e+ \      {  
  
    W6 `: G' u6 q% Y
• 
  - C. {$ b/ k" j6 B
       p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  
• 
  : V% l- c$ t7 y7 G6 I' K9 @3 v
  : Z. C3 b, Q8 }, A1 e. z     ready=p;  
  $ `. K3 x' ~/ B9 e5 r
  
• 
    r7 a9 B* N8 q, b3 S4 e$ H5 E
        }  
  
  
• 
  
  ! {2 F+ j2 D+ v8 z/ \" K2 l   }  
  
  
• 
  
  & @- P9 z; L" q% f+ s   printf("          优先数算法输出信息:\n");  
  
  % X- X( Y6 i( L9 r
• 
  
     printf("************************************************\n");  
  6 _- B! x! {9 S. Q% I# c! g6 _" W0 E
  
• 
  
  + S( {& k2 r, Z   prt(alg);  /*输出进程PCB信息*/  
  
  
• 
  : y# q* L8 a6 c. t( O' q0 s
  : A' h+ {0 V; M% D- [/ U/ a  M   run=ready; /*将就绪队列的第一个进程投入运行*/  
  7 O, {$ |+ [  V# T8 c8 R
  ( Z$ ?+ F3 W* O# c. m$ f. F
• 
  
  7 C6 H' {6 }6 I( j   ready=ready->next;  
  * D7 W3 Y$ P$ P6 D5 q9 x
  7 s. o  p8 U1 z2 i2 F
• 
  
  ( [4 L  [) K5 ~; n' f8 f   run->state='R';  
  2 w0 ]* B: o% j6 _7 r, J9 r: s) t$ I
  
• 
  9 B4 i; [. ~. F# E7 L
  }  
  
  ' R7 {% S$ O. x' z- }
• 
  7 o+ H& E6 @. q+ Y
  " z8 A- j  U! @6 L/*优先数调度算法*/  
  
  ( }/ X9 h, N. v8 ^
• 
  7 P2 _/ U: m4 Z3 h# B* s% m
  priority(char alg)  
  7 a' b: X" q5 Z4 t2 {
  1 o* Z# w, V) @6 C0 m6 l+ l3 m8 E
• 
  
  {  
  ) A3 s, Z- X+ h; h3 j
  # E/ S9 T4 L* I  d# E! V
• 
  % V% G5 V* {6 ^" g$ s7 l
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  , T) N1 V7 n3 o
  
• 
  
     {  
  . H; C0 M  ]5 Z. j& [$ Z
  
• 
  
  * i' m% l; D. X" |7 c: }1 {      run->cputime=run->cputime+1;  
  
  ' R# V! f. H$ A( m/ e/ F% M8 ~
• 
  
  ) Z" Z; ~6 [$ j8 ?; y# x, r, R      run->needtime=run->needtime-1;  
  
  ) q0 z5 m2 a- z- L8 J
• 
  7 A! v  J/ ?5 b2 ^- x
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  : o6 _- P; Q% X, p' ~1 A& {+ h
  1 O8 W+ c$ ^: w4 y% J
• 
  
  1 ?0 x( x; w# E- I9 f      PCB *p;
    J( m5 C8 K% s" w, s- R
  
• 
  
  7 e6 q$ ]% S2 s, P      p=ready;
  + y% j, L1 h6 |/ k/ d) j* s2 T
  
• 
  8 \0 W; b1 W8 ~+ r
        while(p!=NULL)  
  
  
• 
  
        {  
  5 r" k0 c8 o" _% \/ U, d( n9 h
  % S# `1 E' l4 o* O7 y
• 
  
  4 e2 A1 `0 U7 y; [  \  x% q' O1 n: q          p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  5 C* V  Q( {% N, A1 p3 d; B
  8 u" g- b2 c1 V
• 
  / a1 z2 i; @( {2 `+ U$ W; K* F
  . t2 G8 b& x  `8 X2 i5 a          p=p->next;  
  ' s/ ~, f3 ^4 [3 S* _& l; m! U
  , m% P  ]3 h0 Q$ @/ v( K
• 
  
    Z+ T4 C  T5 ^$ Q* l* h      }  
  
  , |5 p- V  ^3 X# E
• 
  & Q7 o3 S/ g7 n( ], h
  , H0 e5 Z3 N/ H5 [. ~4 P3 a  [      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  1 i1 X( V8 g% R
  3 S. t" v+ E/ X4 S1 f! ~
• 
  * r4 b0 y7 {/ ?3 \
        {  
  
  
• 
  8 [# J# R+ b& T+ v
           run->next=finish;  
  % V9 |* R3 z, U+ a
  ) j5 D2 B; b. h$ V% t
• 
  
  % b( E2 j+ s8 l# p& Y         finish=run;  
  
  
• 
  7 \! @; O5 K$ p& Z7 f/ N- \6 U9 A
  0 j" o) b/ }) q& b" d& R5 K         run->state='F';  /*置状态为完成态*/  
  
  
• 
  . f+ X6 G9 w! s, X
           run=NULL;  /*运行队列头指针为空*/  
  6 L1 z* I: v# h- A" l
  ' p3 }  u; W4 B, q) ?
• 
  . e3 f0 P2 Z# h2 s
  - V& |" k9 c' X3 j8 X         if(ready!=NULL) /*如就绪队列不空*/
  
  ) ?! q1 v. L1 |% ^9 p
• 
  ! L" e5 h8 D6 [9 ~. ]2 U, }
  5 C2 q9 e) a9 a3 U* W         {  
  
  
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  # S8 D, y' F4 L. b# A
  
• 
  
  - B1 O+ o! S$ i' I# _         }
  3 C  j* n+ f. T/ ~5 I2 D
  ; y6 e- f+ ]. \# I. J8 ^
• 
  
        }  
  
  
• 
  
  4 E, _+ E: [0 I" Z5 k& a7 v; k      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  / P7 e9 k6 \0 y2 W- K* p0 x
    m+ Z+ |1 x5 Z0 j
• 
  
       if((ready!=NULL)&&(run->prio<ready->prio))  
  
    g, g$ M# y. q' l2 }
• 
  + I8 n$ j  j2 Z2 i* g
  # |$ U+ A/ y0 K) ]) L5 D' ~     {  
  1 y8 ^' x8 D3 Q$ X% B
  
• 
  
  : M4 c/ Q& L" [8 X3 s  N        run->state='W';  
  : v+ N( r* ^5 h) \. U1 j3 A+ w$ P
  * Z" q8 F# M- [+ D' c7 D1 f7 m! c
• 
  , U9 L& |8 `2 E3 I
          insert1(run);  
  
  3 o& d% z: _# i8 i% K
• 
  $ W2 V9 T# M5 z  ^1 G9 `
  : W& J$ I* P2 @/ C3 c        firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  
       }  
  . X, I$ n( C/ K5 ~
  ) a% G7 q; [8 o" m8 U( F2 x
• 
  ) W6 D, I, ]* A3 J. I! \. x
  % o' i1 t5 O3 O, l1 }8 G# n- ^      prt(alg); /*输出进程PCB信息*/  
  
  
• 
  
     }  
  
  ' ^2 K1 e9 c6 y2 `' v3 {
• 
  
  }  
  2 q- S- k  H, N2 U; D- w, @
  
• 
  
  /*主函数*/  
  
  
• 
  
  9 z% b) P  e& E- V5 v% i6 U$ Z! bmain()  
  4 S+ x% U( F, S2 i" {4 K
  3 y9 ~; \4 K3 P8 j, R" O( A
• 
  8 Z8 {, b+ ^& F5 J5 Z: `
  2 f9 B# }. T' s) `4 @$ c6 H{  
  
  " h  z5 ^- Q! X* C  z! K5 P
• 
  - s5 ?4 k  t0 u' j- T
     char algo;  /*算法标记*/  
  # w& |+ z0 t1 L
  
• 
  + V7 D  d* f9 L$ h9 v1 {! g
     printf("输入P确定算法：优先数算法\n");  
  
  ' F4 B: m) T, X  D  _
• 
  4 d8 l, J+ x; R
  + Y* h3 K) O" p& |6 A   scanf("%c",&algo); /*输入字符确定算法*/  
    R8 a  N+ d3 [! R! P7 q! n
  * d" A9 g. M9 |+ s5 w8 \
• 
  
  % r" ^1 G0 U* c7 j% |: f   printf("输入进程数：\n");  
  
  9 R  `! [4 T5 h0 H" N+ O
• 
  
  - t% I% v2 E, F   scanf("%d",&N); /*输入进程数*/  
  
  ; D( _! d1 @# N# t# P7 d$ U5 P
• 
  - ], |' [( Q  |% b: h
  1 r5 j' P  A- m+ u/ a/ \3 c   if(algo=='P'||algo=='p')  
  
  
• 
  4 c$ V! A' N0 @3 q
  ! q; [' y6 a" a# W& W  ]   {  
  
  
• 
    h( B( m# v* J0 a& R
        create(algo); /*优先数法*/  
  4 t9 p2 c) ~3 Z
  * n7 G0 z! i+ m
• 
  $ y2 l8 j7 d) s& e9 u& W3 C
        priority(algo);  
  6 U+ n1 Z6 i  @/ c0 l
  
• 
  
     }
  6 r: ]1 n  Y% |$ J
  6 @  o  \+ ], J% c% S' K$ G
• 
  * I2 ]- ^7 R5 u& ]6 q; }
  6 d1 j3 S  }- `  O6 O4 e- \}
  ' D, W/ R% Y6 `: S: X4 W
  
  

) O4 Q, w' V# \3 {3 V& y4 @' n* \输出结果：

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

* T7 m4 w! b5 s. K+ X6 E

---

欢迎光临 数学建模社区-数学中国 (http://www.madio.net/)

Powered by Discuz! X2.5