数学建模社区-数学中国

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

---

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

优先级调度算法

算法介绍
优先调度算法的类型（用于作业调度）
# K& s3 u. p( v+ Z* ^) Z1）非抢占式优先权调度算法
( D& F. m# k: J系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
' k( E1 \& |% h) y+ l只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

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

2）动态优先权

算法实现

抢占式动态优先权：

( U* r6 ]  j/ }# OPS：本人认为非抢占式静态优先权没有实际价值。

• 
  : Y' l+ {, Q3 {# Z) ^' }) E
  #include <stdio.h>
  
  
• 
  
  #include <stdlib.h>  
  
  5 {- R! y* F% j; d. E5 p& K
• 
  
  7 n3 t. V. P) ~4 g#include <string.h>  
  " x* x- ~- @' o1 z5 R6 I6 O2 k
  
• 
  
  0 k! g: b" Q- h; u$ Wtypedef struct node  
  
  + W" t4 j& e2 h/ j0 w  J+ B0 z
• 
  
  ! U" ?& K$ ^; R0 t' r! ]2 i{  
  5 X0 K5 p% h4 s; t7 ?* \
  
• 
  * v' x9 L. E' ?' d- O7 F
  ! _! g6 M- g4 Z1 Q   char name[10];  /*进程标识符*/  
  3 g7 D. L( d1 i$ l1 Z& F  O$ L
  # Y* v& U! x9 |/ i
• 
  
     int prio;   /*进程优先数*/  
  
    `/ i, ~' h0 b( z: @. `, m) m5 o  h
• 
  
     int round;  /*进程时间轮转时间片*/  
  
  
• 
  
     int cputime; /*进程占用CPU时间*/  
  
  
• 
  
  ! u( @& K" G0 T# u   int needtime; /*进程到完成还要的时间*/  
  7 P2 @8 e; M  @, X2 I. C8 m
  ! ~/ P: ^/ d: j5 D- |$ I
• 
  & S% S8 d1 C8 D3 I
     int count;  /*计数器*/  
  
  
• 
  
     char state; /*进程的状态*/  
  
  / [6 M6 a, e! U: a
• 
  * u7 B' N$ z2 O
     struct node *next; /*链指针*/  
  
  $ S. t$ S* D7 J' L' t; [
• 
  
  + l0 c6 r2 n' p) u. e8 b}PCB;  
  
  
• 
  7 z2 f4 O; a! S5 R1 Y4 |' u2 A: n' p
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  
• 
  
  int N; /*进程数*/  
  1 Q  h% ~1 H  G* k' Y+ R6 p
  
• 
  7 Q! ^9 w: M4 K3 f6 ?
  /*将就绪队列中的第一个进程投入运行*/  
  ' S, ^+ j5 F% u2 L/ ]
  
• 
  ; O( I! R7 S2 P: E$ M: ]
  firstin()  
  
  3 [4 i. A+ D% Q# d0 d/ J; E) j; q
• 
  
  ! K  e2 i- H, X" B{  
  
  , ^- d$ C# _/ N3 [: A) q
• 
  
  9 Z. s6 i" N& s% ]- O   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  & ~" `1 {( p0 Y7 N
  
• 
  
  ( y' q0 d2 g' v/ x0 Q   run->state='R';   /*进程状态变为运行态*/  
  
  
• 
  
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  
• 
  
  % ~9 n* K0 B1 d1 S}  
  ) j, ?1 G; K$ B0 R* a: g6 I& F% v
  
• 
  
    h! z4 e& B5 ^6 d: L1 O2 p/*标题输出函数*/  
  
  2 b& C; x5 H3 i4 P! @$ P
• 
  0 u4 }5 J: N: Y& Z+ R
  void prt1(char a)  
  6 i3 j- F* ^2 {) q& ]+ Y  U
  ! F- g1 A8 k& a7 P2 {" F+ |' C
• 
  
  {  
  ( t" r) K$ |) S. K1 @* d0 l* i
  
• 
  ! v. O: C4 o3 j8 [" v2 g# G
     if(toupper(a)=='P') /*优先数法*/  
  : ?' @& ^* @4 O% W6 o& q
  
• 
  , y0 ~9 L' L3 }6 k
  3 R7 _) I- b6 W$ n# u6 I2 R, ~      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  3 k. W' J3 B0 {6 q2 `6 `( v
  $ W: }' l) k+ m+ b# R8 q
• 
  
  . q( s8 F4 T  P1 A# E' F4 b* g+ y   else  
  & u5 p! o* ?6 h
  & r" g2 Y) |  T
• 
  1 E# R$ V. Y& e1 c
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  . F' Y3 i" Y* q) M) F
  4 g2 `, R! n1 E! I8 s' p$ E% u
• 
  ; h: R1 x6 J7 \/ |
  0 N, Q, K0 |1 |0 S$ n}  
    ~/ [9 [, [$ z5 z+ U3 s
  & ~. k4 o( u, b/ ~
• 
  & Q* B  L" G# N4 ]
  ( P0 b( v  `, t8 J2 X9 X# I/*进程PCB输出*/  
  
  
• 
  
  void prt2(char a,PCB *q)  
  2 j9 f# s. H# A2 \5 r1 `5 ^9 K$ B: }( D
  & l9 g% J4 l( ]
• 
  ! w7 w- _- v, v7 O9 S; A( v
  {  
  " ?( Z! t+ N' |8 k: m
  ( L3 Z7 f  d1 S; N6 p+ ]- \
• 
  
  ' r0 E6 \. w8 L   if(toupper(a)=='P')  /*优先数法的输出*/  
  % g2 G9 W0 ]1 f+ U3 d# O6 V
  
• 
  
  : b0 m; d5 o' D4 o) t" L* ?5 N* m      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  ; o' L  \- D) U3 o0 \# J: Q# }0 j* x
  9 K& ]# m/ `/ c8 i. }, h# c' D
• 
  
         q->cputime,q->needtime,q->prio,q->state);  
  4 z! L4 l0 ~5 N7 Y$ ]+ d+ I
  
• 
  
     else/*轮转法的输出*/  
  9 W" P/ o. F! q9 `# M1 e! A$ N
  6 V# [. [+ K) }0 z
• 
  
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  # d, F( n8 U/ e1 C$ [$ N' S0 d+ K. f
  
• 
  ! V2 ~" y$ Q/ N5 a* _
  0 d4 ~! v5 e! ?       q->cputime,q->needtime,q->count,q->round,q->state);  
  4 C4 Q% D4 x) G6 W; F
  7 o) S, j/ k0 G9 o. [8 \: O
• 
  ( M6 X% j1 H: R2 ^7 T1 m. {
  8 {6 m; {- Y7 A9 C9 y7 r3 d}  
  ! x+ @( Z% D3 O3 D4 R
  
• 
  
  # Y" t; F+ W# j% Q9 n4 I/*输出函数*/  
  , D! `7 ^- i' Z0 `0 @3 c1 `/ A+ z
  
• 
  
  void prt(char algo)  
  8 m% C7 |  J) v3 b2 V( g* B
  , G) U7 i. m$ B  E
• 
  
  {  
    S% S! s4 c$ o9 Q2 c: p# T" ~1 H6 D
  
• 
  . s1 s5 i. Q, T+ m& z
  ! K1 \1 ]" r" m6 ?4 ?   PCB *p;  
  ( A$ V5 ?+ P  d  i) h
  : d8 n" Z% D  n: A% J+ Z
• 
  
     prt1(algo);  /*输出标题*/  
  7 [: Z! _7 i1 ~8 \; g, w. a7 q
  / q9 G  r; p. y9 m) C
• 
  3 s% v' ?# s# d6 x! o/ T% z
  # B6 L# b1 H! y' Z: j+ f   if(run!=NULL) /*如果运行指针不空*/  
  6 E* D' L; t; H* A
  
• 
  & o2 Q- W/ y5 K# I# n
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  
• 
  
     p=ready;  /*输出就绪队列PCB*/  
  9 d+ M( M, ^* p' [6 H
  $ Q8 {- l: P; s) Z
• 
  
  5 k- m' r! Q1 f' C7 z   while(p!=NULL)  
  9 @; b/ U0 [0 F* z- b/ u/ X
  
• 
  
     {  
  
  
• 
  1 b! ~1 U1 E& k2 w; y7 s4 I
  , f6 X/ y3 ?2 t' G8 O1 K& d      prt2(algo,p);  
  
  
• 
  : e. E4 y- J9 i9 Z( v1 B0 T; S
  ! {; h0 [% w+ Y; Y0 N. O      p=p->next;  
  
  
• 
  $ K) f6 m& T, k! ?9 f: p( {
  9 s% ~2 ^% Q2 h7 b   }  
  & d& E2 G; V4 l" v
  
• 
  & ~# Z7 @( v$ G5 k' R
  " R0 D5 E* t% b) R3 e   p=finish;  /*输出完成队列的PCB*/  
  & c8 L: B; I  k9 b5 u0 X* r  h
  ( y+ M2 h% m" b( N- _2 P
• 
  6 Q' \  s- S  j' u- Q
  + a! O# }& B% v) g5 ]2 \: U   while(p!=NULL)  
  3 d* v7 D' `- O4 C  `, }
  * x. W. K5 W. p
• 
  
  . \; A. N- }; E( d- d7 W8 O/ P   {  
  7 U  A: A: t" y: h* w$ \) D
  
• 
  
  ' z1 c8 a6 A3 j* U7 [      prt2(algo,p);  
  6 X2 l$ O6 b( C/ d. r9 E
  
• 
  ( g' y5 c  e4 O% D) V; x
        p=p->next;  
  
  ( i5 ?. o5 v. g* A- g7 e5 ?) g
• 
  3 T( d3 i+ K8 e
  6 z$ J) Q8 z& p% n   }  
  
  
• 
  
  + g7 D5 w& x4 U/ s1 }* o3 C   getchar();  /*压任意键继续*/  
    [0 Q% }/ D$ |- Y5 ~
  ' R, Y% ~* V/ x* O) I# A
• 
  
  " w. u4 n+ g  {}  
    H& }2 A' Q: ~; l  I- |
  
• 
  
  /*优先数的插入算法*/  
  
  
• 
  $ `, C. g) i4 S$ Q" y
  6 ^" b' j! Z7 E+ d& Xinsert1(PCB *q)  
  , V3 t) T+ D5 L  d6 `( s2 V- |; e
  1 q8 v' k6 D8 X
• 
  $ R- {% m, Y& Z/ Y
  {  
  4 F  z8 H+ L: o, _, z
  2 {* v* I2 L  v& k% \
• 
  9 g/ p3 g0 j. S3 k- D
  ( ^, W/ m! g# E& a: V   PCB *p1,*s,*r;  
  
  
• 
  
  7 D2 M" r) i6 _4 X; h2 U   int b;  
  # O2 u8 ?  `1 y* K6 |, }' v8 B
  $ v! t2 c! s* [8 M4 Z! w
• 
  $ |6 C: \; g! w1 _  S5 m$ I/ ^3 m
  " ^: N: i; u2 ~7 u" g$ d3 r   s=q;  /*待插入的PCB指针*/  
  
  - I$ i4 @  `: K
• 
  $ }" R! a3 ~( P( c" g# ?
     p1=ready; /*就绪队列头指针*/  
  ( X* s- v$ O; o- n
  ( S; g( z4 Q# n4 a7 U
• 
  2 v$ U; Z+ z8 @5 u( o3 D' {
     r=p1; /*r做p1的前驱指针*/  
  ; F, G  i" X9 ?1 T* h7 ?1 q# b
  ! B& q  G/ r! v/ a
• 
  $ J! m6 A1 d$ z, r8 J
     b=1;  
  
  
• 
  3 Z7 T& P4 H! k1 X$ ?
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  
• 
  
        if(p1->prio>=s->prio)  
  , ?' v. e% R  `& `- O, R: k$ s
  
• 
  8 l: v- m4 S: v* i$ ~6 z8 l( u0 u
  ' L" k  U- u5 b      {  
  
  
• 
  * X$ |- }8 r! M/ }7 @
       r=p1;  
  - w- z7 ?  \* d# O
  
• 
  , }( @1 j3 @: }' ]; x% q* S% B
       p1=p1->next;  
  4 ?/ q$ r: N6 T6 r
  , Q" l3 b9 b3 d; k) s6 k, _" O1 O
• 
  
        }  
  
  % A- }8 V7 Q$ w  o/ O; u
• 
  4 J. X3 W2 E, Q8 E
  3 q( ~$ U% P$ l* M8 U% Q      else  
  
  1 |8 w9 a+ A" ^: p, P. P+ x& O
• 
  $ n; \8 u9 t& G  F$ B1 s
       b=0;  
  ; e9 j4 y8 H: {5 Y7 o5 v, `0 q
  ! j" l( z3 S, s6 q' ]0 q
• 
  
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  
  ( y. x8 i" f9 r7 T   {  
  
  
• 
  1 n- S) d/ z; E1 g7 ~3 f4 f
        r->next=s;  
  6 N6 p1 Z- Q; Z: Y7 u9 O7 ?6 v
  
• 
  
  - l4 G% r6 n3 e( }# z2 X/ Y4 j      s->next=p1;  
  & K3 O' X, ~7 t# [9 T# o
  
• 
  
     }  
  ' ?  h5 A6 `8 H9 `5 d* e! g
  
• 
  
  8 j5 }; K! G9 `) q' C3 B   else  
  
  
• 
  % b" Y+ r! G! V
     {  
  
  1 |# X: t' H+ R% a4 g  r1 }
• 
  
        s->next=p1;  /*否则插入在就绪队列的头*/  
  5 }5 Z6 @6 U: r8 |0 v2 C7 g
  + Y& S5 t3 [8 b2 _# K( Q
• 
  
  0 _, D0 m' p) H5 Q$ N      ready=s;  
  9 x# \8 F( J# L: b% D% d7 u
  : L9 w# f) f  w
• 
  4 i1 T" ?% [1 T; T1 I$ [5 W  `
  & @6 K& H( g8 V. x, Z   }  
  ) S, X& ^' I8 \8 K" Y* X
  
• 
  0 Y+ A; a2 K" T$ _( f
  0 Q$ p2 v/ U7 l0 Y' @( e7 T2 D}  
  
  
• 
  9 l5 V4 T1 Q  {' |
  5 b/ f$ |* `8 L, e, n. J, z: x/*优先数创建初始PCB信息*/  
  
  
• 
  & b8 G) D5 V. }
  ! U( C  A8 A' G7 a/ ^: n% R0 Rvoid create(char alg)  
  2 R; C, m% m, G7 [
  % R# d1 D% q% v6 p; X
• 
  
  {  
  
  
• 
  
     PCB *p;  
  
  - l. J% h2 F' k: z9 h2 Q( y
• 
  . f" M; k( e6 P; M2 ]/ H! v
  8 _. u5 d, S1 M8 ]3 b   int i,time;  
  
  . P" b4 r6 T) s
• 
  9 h$ M1 J9 a6 D0 n. a; B2 c" t
     char na[10];  
  
  
• 
  
     ready=NULL; /*就绪队列头指针*/  
  ) u" J* Q/ w+ e5 Z( D
  
• 
  1 f, t+ O  V+ |; A' O! a8 {6 ]- Y
  . D; L5 |" c: @% e   finish=NULL;  /*完成队列头指针*/  
  
  
• 
  
  & m, M5 |$ I3 M* j6 s9 `, Z   run=NULL; /*运行队列指针*/  
  
  
• 
  
  / o2 h' J" h9 K! `' z   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  , x0 f7 O& }4 P5 c' E
• 
  * g! e1 Y% G; }. h9 u
  + d& g; Y4 a+ b- F   for(i=1;i<=N;i++)  
  & r" ~3 M; [  J8 _) l1 o7 y
  - b5 ^7 r4 ~1 F' B0 Q: J* y
• 
  
     {  
  " J; a4 r, k3 g1 S! V+ P
  
• 
  3 j, R" U1 j/ V& V
  * I: L# f0 M) Z& F4 R/ s      p=(PCB *)malloc(sizeof(PCB));  
  
  1 J; Q% k" I2 n- ?3 ~% u
• 
  * P2 H+ A4 _. X) q& C9 F
  8 e+ e& W! G5 s6 a" r& Y5 W" l1 s      scanf("%s",na);  
  , _0 _1 b0 V# t  _6 o7 Y
  
• 
  
        scanf("%d",&time);  
  
  3 s6 v3 x, e5 L3 j% I, z: _+ G
• 
  
        strcpy(p->name,na);  
  
  ! X! q' _0 |9 I, w. {
• 
  7 R9 `0 s# @7 R* b+ n, u
  4 J# ^. Z: m; p, Q" d1 {      p->cputime=0;  
  / b. `! _4 ~, I1 ]! J
  
• 
  
  ) [$ ~3 x' Q5 V. \+ f3 p1 S  Z      p->needtime=time;  
  2 m5 c$ a3 \1 Z0 S. U1 y5 R
  $ U! A3 o# U5 s9 L' R8 F, t
• 
  $ N# \4 n# |5 r; I. x- x
  ) t8 c. a; Z0 K7 @6 d1 V7 W# Z! P, G      p->state='w';  
  
  
• 
  ; U! {8 \; F" L
  " B+ {0 b" M! Q) x+ \3 K      p->prio=50-time;  
  
  
• 
  
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  ' u( _7 T0 J2 J8 d" B0 M
  % s; x4 f$ R+ ^7 S
• 
  
  , F  A) O1 @' Z) v     insert1(p);  
  
  
• 
  1 x8 P& `  K. ]8 @; Z& d
        else  
  
  
• 
  
  * L$ H- _7 n2 P) i      {  
  
  
• 
  % `7 a$ t2 ~( J4 O$ `- M
  . y1 r: I" g0 f/ w: i& v     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  7 A* l$ o4 v5 ]" Z3 |" M3 N% S
• 
  7 p3 S% @7 R. h) ~
  ' f4 S, B- E) ^3 m7 v1 E  a# Y, f; ~     ready=p;  
  
  8 c! U& C. Z. N+ y- `
• 
  
        }  
  
  ! B7 b* J& K$ y2 }4 p1 z
• 
  : y0 p" F. P5 n7 ]- h  V2 [+ M
     }  
  
  - V3 b" P3 @# Z2 q, J  ]
• 
  
  0 i, W3 j7 m0 ^' _   printf("          优先数算法输出信息:\n");  
  
  
• 
  
  4 v" T; M4 s  c2 {1 ^  e# h   printf("************************************************\n");  
  9 _( U/ U$ l4 e% S- i: }
  
• 
  . F" ?# Q6 y( n
     prt(alg);  /*输出进程PCB信息*/  
  ! }. V$ T  }# D  {0 u
  
• 
  0 G- e2 Y" `6 \, W' ?; s! O
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  ; e# s9 E' H. [4 v
  ( {' E2 ^7 A0 n4 o1 r   ready=ready->next;  
  
  
• 
  ; }: I/ C% W2 ]* w* Y
  3 }4 S% x7 ~( I) g$ y   run->state='R';  
  
  5 Y/ B3 Q7 f2 P/ D# R9 N  l# q
• 
  
  " z/ u/ L% k0 M: c}  
    e$ [5 S! T1 L( h- d5 b# F
  
• 
  
  /*优先数调度算法*/  
  
  
• 
  " b( Q; H/ w. {- R* k
  priority(char alg)  
  
  / b! R8 R7 F  w( x3 O3 [
• 
  ! ~: `2 L" |) ?) `6 d' {- a. m
  4 z2 s9 }4 A% }5 X{  
  
  * v; X3 R* a' @+ C: f+ Z
• 
  
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  7 A- P# V$ b( ?; H$ l
• 
    h0 Q9 m4 H1 I0 V. v
     {  
  
  2 ~& B3 S1 w: Q9 X" [- z7 J
• 
  
        run->cputime=run->cputime+1;  
    S: ?; J( h* _. r  H" F  O4 B, N
  
• 
  8 l7 O5 P3 f! D2 }
  8 o+ N+ |# W: g: L' b$ e' [      run->needtime=run->needtime-1;  
  
  1 ?+ c4 S8 B9 P4 K5 h2 v
• 
  
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  / a3 Y% y* k0 P$ X5 Z
  - Q% A- e. [1 A3 n8 a! [
• 
  6 q! @9 b% o/ Z# X
        PCB *p;
  / t2 G1 q8 {. G  w  N. Y6 w' `0 y  `
  7 |4 a! Z3 m- A3 V
• 
  ) G0 ~6 q6 o) o* v1 {8 a
  9 }* G' L5 c& d* V! }9 z      p=ready;
  
  
• 
  
        while(p!=NULL)  
  9 Z2 Z' `# D1 l7 M& A+ T. ~
  / H# G) N) m! n
• 
  
  - Z5 M1 X* q$ C2 l& [      {  
  " _0 O4 l! ^. F# n, f7 s
  * W. i5 T' W7 h6 o5 ~  W6 \$ w
• 
  9 @6 e9 N' P% W, b
  , D, Y& H* C! {5 \/ t) P          p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  $ V& N7 o* L8 u) U( |6 K9 k  j) N
• 
  . F, u* N: a+ B( O
  , M8 X: B: u3 t9 P) c$ a# S( O( x! J          p=p->next;  
  
  
• 
  
        }  
  ! Q2 D3 n/ P1 U- `. S7 L0 O( H% [
  $ _5 }! E$ w6 F7 H4 f* B1 K1 l  {
• 
  
  % t% B; a! w: ~* r0 Y3 i' W% i3 `      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  8 ^0 G, T# N, _; T
  
• 
  + U/ ^8 E& V5 l) `
        {  
  ' R. B1 J1 d& z
  
• 
  7 Y7 n0 \5 K' \: T
  3 ]9 D+ v+ l, N* r" t" F. Y/ i         run->next=finish;  
  
  
• 
  9 y+ P8 ]  d/ O* s5 S+ k
  5 i' t/ |9 L6 w' d         finish=run;  
  ' B! S. W5 [" A1 Q
  ! k: w2 g; K% Y8 o, Y: S* l
• 
  " Y% `; \& L& \' d9 ]# X* o! M0 z
  ; u  K1 @4 A5 F' ]# C         run->state='F';  /*置状态为完成态*/  
  6 ^& m+ t  b6 H! N* [* A) g3 O, B
  : [2 |* o/ f; F. [
• 
  
  0 O  J/ O, a0 R3 `" W) v         run=NULL;  /*运行队列头指针为空*/  
  - C9 R) ]  y  R
  , D' s/ z; a, G  p* e8 p
• 
  
           if(ready!=NULL) /*如就绪队列不空*/
  ; j) p# c1 N# q+ \1 `8 n
  
• 
  $ O$ }# q$ Y1 t- J6 n8 ?# P
           {  
  & o+ N, Z: K7 B9 C. N* h
  
• 
  ! ~' F1 i& n, P% o' I  o
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  
• 
  
  $ a1 }& v9 n1 i# X; w         }
  
  
• 
  
        }  
  ' V3 f6 v* H6 b( `0 {$ u
  " h8 ~7 O3 o: c" D. ~7 @
• 
  * E/ f7 h$ y1 M% l$ Z0 L
  ; o0 A( P& G; V4 N      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  " p1 W3 s" ^! W
  5 K1 }" z/ [3 ~6 O+ w     if((ready!=NULL)&&(run->prio<ready->prio))  
  
  
• 
  
       {  
  , Z9 _6 i  N* ~( c
  , @) c/ Y1 M9 x5 s" m
• 
  
          run->state='W';  
  
  , E0 M9 G/ Q, @3 X- l
• 
  
  4 [* a* ~0 E' }/ g  p9 j        insert1(run);  
  9 u2 c! \+ b& U
  / O# W; A: n. j0 F( r5 I
• 
  
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  
       }  
  9 N% ?4 ~! W/ \2 x' y$ P0 K
  ' z) M! u( I7 i8 C
• 
  5 N$ e3 `7 a  H$ I
        prt(alg); /*输出进程PCB信息*/  
  # M+ y+ b) `& L! r: U' ]3 I
  & P3 l( D1 |  Q) f# v- D8 H
• 
  ) X8 b7 j2 d* {0 K$ ~2 w
  : k7 F( q' `& A   }  
  
  
• 
  9 I3 O. D, h" _8 H/ U) u  H
  " o" a/ z9 P& m6 z/ K6 [}  
  " u0 ?0 d: D1 ~3 R' ~
  
• 
  , `$ N) G) Q! n2 w: l% t9 x' n
  /*主函数*/  
  
  % r" T" J1 S; R( ?$ P! a
• 
  8 O1 @2 b- I$ ]+ r7 n3 |, d
  main()  
  
  
• 
  : P' f5 b3 s# n# G5 V/ [( {: f
  {  
  
  ( d1 P, i" {- i" p9 S+ S
• 
  ' g! R6 i3 F: a1 k4 s& y  O" i
     char algo;  /*算法标记*/  
  
  3 Y  w& z% d0 x$ [9 N8 E
• 
  
  : E4 n' k+ q1 w; h+ r   printf("输入P确定算法：优先数算法\n");  
  5 b! A* g1 {5 C3 z" W* c) J; z5 w! }
  # N2 H; m4 J8 |# |  b, x+ K: K
• 
  1 E) n5 B4 P/ P0 l8 m% a
  7 Z3 L" |9 ?& e   scanf("%c",&algo); /*输入字符确定算法*/  
  1 i; s' ~  _( o( u: Q' [
  & O! ^/ ?; h; ^) ?; p, _6 f
• 
  
  & y4 t. ?2 R& z) p! q0 j, ?   printf("输入进程数：\n");  
  & a+ E3 g$ ?% U. W  R) c
  
• 
  
     scanf("%d",&N); /*输入进程数*/  
  
  0 y0 L7 D# R$ B# ^3 g
• 
  
     if(algo=='P'||algo=='p')  
  ! h; Z( j- k$ c# w7 G2 f, S
  1 X9 l. A2 F2 }9 j/ E* y7 I
• 
  1 f, `: x9 a$ B+ m. _
  / c" I8 d- w. ~$ t  }   {  
  & I8 `8 i, Q$ ~, P% l' z' b
  2 V# a& o& q- Y
• 
  
  $ ^6 j, w9 Q! k$ ?5 n      create(algo); /*优先数法*/  
  
  & {3 s& ^, s# E
• 
  
        priority(algo);  
  
  + x$ [& v( _2 T: I, b
• 
  
     }
  
  
• 
  
    N& {& E0 N; j  j. [; i}
  
  
  0 E  t1 y, ]" T7 K. S% ]; T

输出结果：
5 ~/ a2 D* G1 n# x

: s0 _3 v) y( H3 y原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

. k0 z( c9 T1 p- o5 a- Y

---

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

Powered by Discuz! X2.5