数学建模社区-数学中国

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

---

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

优先级调度算法

算法介绍
* d5 J! k; Y+ j& l' v* h. k4 {优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2 V4 E( q! _$ H3 s2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
! r7 o6 H9 n$ D  K  y# v/ X1）静态优先权
0 m( u" U' J( y静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
# n$ ~% [9 o( ?  H8 W, J

2）动态优先权

算法实现

抢占式动态优先权：

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

• 
  
  #include <stdio.h>
  
  
• 
  3 ?% E( F1 |: x- x$ \" ~1 `
  + W) o& v$ H$ g; K6 _#include <stdlib.h>  
  
  % t$ I5 _( ~" K
• 
  
    p5 d" A; n; @2 `! W4 m) a#include <string.h>  
  $ `( n9 ?0 I) l/ }( s
  ) O1 |; R8 T" q  o. E
• 
  * s* ^% _8 R4 B% y
  typedef struct node  
  & K- Q$ e& U1 _' X; n0 y; G
  
• 
  : I- s; r4 ^  V, n$ n- r6 X' B
  {  
  
  8 {& |) Q7 \8 W5 I! c" a
• 
  
     char name[10];  /*进程标识符*/  
  * l) Z2 o6 S7 ]" z7 ?
  
• 
  7 n% `" _3 c/ ^
     int prio;   /*进程优先数*/  
  * Q7 d" P+ w  Z8 `5 B% }: S
  2 S( g# ]  ?% {5 Y- j
• 
  & e! N, ~; A7 ]5 A# {
     int round;  /*进程时间轮转时间片*/  
  
  # ~5 J; _5 ]" E, C; c
• 
  
  + u; Q; _  b7 d4 F7 P3 O   int cputime; /*进程占用CPU时间*/  
  8 _) @) K0 ]0 }9 ?2 ]
  
• 
  ) o/ ^0 ~9 i- Y: Z& @8 _
     int needtime; /*进程到完成还要的时间*/  
  $ ~, C* X: T- M; x) a0 ~' f2 Y, l# @
  
• 
  
  . j& p+ n" X. Y6 {  d* Y( r   int count;  /*计数器*/  
  . u$ F9 n! @: b0 R4 @. C2 Y% b
  
• 
  
  7 P' S( O. b; r9 b5 }4 r$ B   char state; /*进程的状态*/  
  # d, U& z/ E. P& c4 x; P
  8 X& F4 C9 K4 o( D) x3 g
• 
  & }! X+ v0 x& R9 _: I4 s2 {
     struct node *next; /*链指针*/  
  7 E, |+ g8 S, G
  
• 
  
  }PCB;  
  4 t6 I  `: V& b- O/ F
  
• 
  
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  4 ~0 y; [0 V& q8 u
• 
  5 \1 n3 E; ?0 |% a, A0 a- @3 M
  int N; /*进程数*/  
  , Y; _) O. E0 A6 z' H+ ]
  7 |$ x3 J# V5 _; h# `. z9 v0 [5 `
• 
  
  /*将就绪队列中的第一个进程投入运行*/  
  1 {( Q6 `& X8 Y$ C2 K
  
• 
  ; ^% f5 G1 S5 n
  6 V1 H0 d  q6 q! e9 @firstin()  
  6 m0 q+ W1 z3 z# a
  
• 
  3 v7 a! |/ M5 g9 i! [
  # @' w; C: }" e! e9 n{  
  
  . o* ?1 ?- W! L' _+ W! N$ F
• 
  
  9 I  q( q: Y+ \0 D) F0 C   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  # z. t' [$ G6 O. [
  
• 
  9 l# W  u0 p/ I3 ?
     run->state='R';   /*进程状态变为运行态*/  
  
  
• 
  9 M4 n. U3 v0 S  ]( y
  3 h' D6 Z4 {% y  V; z# o+ M, C( K   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  / Z: O, z7 L6 z
• 
  
  ) q* x! ?2 _' I+ U}  
  5 F. j' s. h. {* h1 Y0 l( _  t7 t
  
• 
  
  /*标题输出函数*/  
  
  / G7 [  s) X7 T9 L- R
• 
  
  ( y' l3 f+ Q8 q- a8 F: Evoid prt1(char a)  
  
  
• 
  
  {  
  
  6 [! F3 h/ }3 d3 Q9 r2 @( R7 a
• 
  ' _9 {& W2 a7 A' x) G1 ]+ Q! G  `3 R" v
  6 g3 D. M$ z& j0 K   if(toupper(a)=='P') /*优先数法*/  
  - K" ]2 ]. b8 g' q+ @
  2 \* V& t5 v' P( N; l& a
• 
  # w. \9 y( }5 ~/ q; r' M/ P
  7 c. `+ |7 R7 j5 {9 h      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  7 n9 ~" u4 w+ R2 a* W
  
• 
  1 R1 @) L# y) I3 p
     else  
  6 R& u3 |2 e( B
  
• 
  6 a  F2 M3 T" ^4 |8 t, G
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  " M3 B  W& T" L. y1 u" j
• 
  7 T) Z# \$ v: O
  }  
  9 {. _  b% l! e; ~  N9 F7 q
  
• 
  5 L" E9 h# Q2 h! _+ |# R2 [" \- A
  + [9 `3 _6 B% t( l1 Y8 ~/*进程PCB输出*/  
  : v- ~! u$ `6 E1 Z, U& ^  K
  
• 
  4 k( J5 ]7 P& X" q
  void prt2(char a,PCB *q)  
  
  $ r$ x; K1 ^/ M, g4 M
• 
  4 ?3 W/ F) M# e! M' n' d. F: H! P
  {  
  9 N7 i/ s9 ^# {6 X3 ]
  
• 
  
     if(toupper(a)=='P')  /*优先数法的输出*/  
  2 d8 V9 I( ~9 B' o& ~
  4 x$ \: i4 |9 v. o% p6 B- z9 z
• 
  
  ( w- Q0 o8 q1 \4 i      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  
• 
  : k7 J% _+ J& C& m5 t( D/ D
         q->cputime,q->needtime,q->prio,q->state);  
  & c! }, T- Z4 q- ]' t, R
  
• 
  
     else/*轮转法的输出*/  
  ' k6 l* G# C/ Q7 k
  
• 
  " q3 }7 J0 o" q2 l
  % }+ X7 V4 `8 _2 v+ _      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  5 t# @& E' K  q; o6 |
         q->cputime,q->needtime,q->count,q->round,q->state);  
  ; h7 X4 ^0 @" K3 H( V
  
• 
  
  }  
  $ J: k. L/ @* G+ p7 Z
  
• 
  ) ?( u" k7 N0 x1 c
    W0 s2 P& K1 T: ]# e/*输出函数*/  
  
  5 @4 Y. F3 p9 h% |! w( D% L  M
• 
  . i4 g* W! n; m3 e! Y4 r& v5 u
  # ^7 Q- E( @  V; p2 P: h9 M( Avoid prt(char algo)  
  
  
• 
  4 g% N) B: a3 ]6 o# ^
  {  
  
  3 \3 f; y$ U& S* z# z& Y+ ?5 s4 _
• 
  
  $ d) ~, J$ B' R+ n, K5 J: U   PCB *p;  
  
  
• 
  
  , H1 w+ a7 f: V3 F$ y   prt1(algo);  /*输出标题*/  
  
  $ g% h9 |3 W6 V' L
• 
  $ z0 W2 Y: n. C: L% e# L
  5 D% B9 k' t" K! L: T   if(run!=NULL) /*如果运行指针不空*/  
  * t5 Q$ Q- e$ r" f
  
• 
  7 P( J1 h# g8 Q' `+ o
  ( a7 I& J2 u+ v; E* l% g! z. S      prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  
• 
  
  ! u" G* w, w& C   p=ready;  /*输出就绪队列PCB*/  
  
  
• 
  / E- u" s! J: m2 o/ i
  . j- h4 H+ U2 H0 H8 a* w7 I   while(p!=NULL)  
  
  
• 
  
  6 x# b& ^, ]" F& b8 E1 e5 w2 K+ y3 [   {  
  8 r) }" f5 \8 }
  
• 
  " {* X. H1 y, Z  J
        prt2(algo,p);  
  
  
• 
  
  3 x8 X* g" I' v  T( X      p=p->next;  
  " R) ^1 w, I+ v5 Z
  1 e  {' f1 D" h1 c$ O7 Y
• 
  " O: x" m8 j* e  {6 V4 q
  $ t7 q- h# O" c2 j   }  
  : n: L0 z6 c1 n, g% K# n
  
• 
  ! H4 k: g: _7 _& t/ s
     p=finish;  /*输出完成队列的PCB*/  
  2 m' c. Q& E9 S9 f* t6 O1 \2 y
  
• 
  
     while(p!=NULL)  
  
  7 @( O. C) H$ Z: j8 O
• 
  7 O! Y9 C  e' C" E, z# e7 t0 h
     {  
  
  4 k( E' X1 D# n7 n
• 
  
        prt2(algo,p);  
  ! P$ |8 x3 C9 R1 Y9 _, m0 j
  
• 
  
  8 Z% q* q* v' p  H8 T. L% t      p=p->next;  
  * J# @  Y0 ?- r' f) F! b
  
• 
  1 j: ~7 s0 B2 K' J
  / u- m" O: W; g. b; O- H6 G   }  
  
  
• 
  
     getchar();  /*压任意键继续*/  
  9 I5 u$ Z; Z  D( `" y1 p
  ( r. K6 Q9 O3 u& @8 k' ^9 d
• 
  ( D5 D/ l' p4 c% x
  * `2 s3 m! K# X5 \8 {" J3 T7 I9 ?}  
  
  
• 
  
  /*优先数的插入算法*/  
  8 u% T" ^3 J' Z; a8 _5 ~
  
• 
  
  insert1(PCB *q)  
  $ s% b) J4 U4 V$ t  ]
  - b; ~+ \5 E6 e; W. u$ v
• 
  
  1 e/ Y" |- r" V3 w{  
  
  ; T8 B3 L/ J. X
• 
  
     PCB *p1,*s,*r;  
  
  
• 
  ) J. i. {/ Q; v
     int b;  
  
  % k3 I: k* ?2 a0 |
• 
  
     s=q;  /*待插入的PCB指针*/  
  $ x+ C6 L; q9 N( r. U
  
• 
  1 t" l) |8 w  }# Z, J
     p1=ready; /*就绪队列头指针*/  
  , |+ Q6 G1 s: k
  
• 
  ! K! Z" f) l4 U8 \* d+ g! k
  % T+ k: n4 n8 V' `) y! E   r=p1; /*r做p1的前驱指针*/  
  
  - D. Z+ |; M( e2 J# ~$ \# [" H
• 
  7 q+ F" Q5 k) K" f# K. ^# L' X8 v8 A
     b=1;  
  ' `7 n# W" l. a4 i! r- Z2 [
  ! i4 g2 }; I8 T7 i9 k
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  7 N( J; @. F* O7 }( t
  , e$ U  u1 }9 G( P% ^' @
• 
  
  2 g9 n$ C. `. @% C# l      if(p1->prio>=s->prio)  
  5 Z4 ?. p+ P/ h' i9 T$ }/ D
  ( L& j. \2 I. [, b8 v' h" X/ X
• 
  
  ) {( ?# e0 T! r( _; z, l      {  
  6 R* x; e7 g( k* v
  
• 
  1 h1 H7 J7 q9 M8 M
  0 w+ w2 Y! J3 c. M9 T) i+ k- `     r=p1;  
  0 x2 j) _# N. t) o0 e5 l9 x
  1 y( g, k' Q; K& I; f7 k& |+ l
• 
  6 B# m2 r/ B$ u
  ) c/ |, P2 q/ i! b9 D2 o" E; y     p1=p1->next;  
  
  
• 
  
        }  
  
  8 U# G9 P0 O/ @
• 
  
  ( O' {. G$ |7 G* k& F1 R      else  
  
  
• 
  
  % ~8 U, u9 u( u9 j8 ]: `     b=0;  
  ! ?) ?* N  Z/ q5 S- P
  & |9 Y8 F) v7 s& j$ U, M" V. L- h; `
• 
  $ U+ D1 [/ w; V* N. t; x3 U
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  
  " J1 C' f  l7 \' ?. R   {  
  : ]' q2 h) ^3 m+ M. c' x
  ( l7 V+ [$ f( w) Z2 V' L
• 
  
  ' j, g% i- N# t! w      r->next=s;  
  
  
• 
  " e+ ?9 `! k, _" j1 |: c& d
        s->next=p1;  
  3 @( E# W6 o! @2 `7 F, l
  8 i; c" c6 j& @- m* Y
• 
  
     }  
  
  2 i3 d  {6 h5 Y$ c; X
• 
  
  - u. n+ B8 v1 i1 |   else  
  
  1 O. u$ L9 v0 W
• 
  5 O" B- S- o- v% P+ S2 X
  6 O& e0 X$ c% ^5 i/ z  l/ B! x   {  
  
  
• 
  * H7 p$ I! f8 N8 M
        s->next=p1;  /*否则插入在就绪队列的头*/  
  
  
• 
  ( m5 U  U/ T) y; L
        ready=s;  
  
  
• 
  
     }  
  
  * J& n- B9 Y% ]: t8 M' h
• 
  " N2 Q! Q* ?& E" s: x  O* b4 R
  $ ?. R3 f$ h$ @0 R  f0 p! Z# V}  
  
  
• 
  
  /*优先数创建初始PCB信息*/  
  
  " S+ G. ~' X2 {& I' {) @! T
• 
  
  void create(char alg)  
  7 S7 e8 F1 E" j8 Q! `
    w: }" j6 I6 o+ ^: I: Y
• 
  
  ; F; \. G% A& i( ^{  
  
  3 e3 m5 [& o: {
• 
  
  ! q' K0 j! P- Z   PCB *p;  
  
  ! Y: k7 d0 |4 H" g; Y
• 
  2 u4 |2 F' I& I/ k: x. ?$ l( V
  8 R! ^9 Q, U' B8 m2 {- ~   int i,time;  
  
  & K6 j9 H& }' l) G9 h+ e  j# o
• 
  
  # V% C. Y# _  E5 J* P: Q   char na[10];  
  
  
• 
  
  8 _+ Q' ]7 V8 ?' }   ready=NULL; /*就绪队列头指针*/  
  9 f& X8 R! r. T& c- q% w% v
  ' M5 ?; E. j6 a3 T1 [8 Y8 H+ V
• 
  
     finish=NULL;  /*完成队列头指针*/  
  
  4 F7 n4 p) W5 k8 a" R% {0 g
• 
  ( k: g+ r# X0 s3 r. _# F+ K5 X" H" t
     run=NULL; /*运行队列指针*/  
  0 r: C' v8 r" e' O' P
  3 r! F, x+ o- L( R( a
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  6 q/ P7 q: l/ o
• 
  
     for(i=1;i<=N;i++)  
  
    f; `( [  [$ O( K8 I. t
• 
  * @2 R# j$ N7 V3 N# e+ k
     {  
  7 Y0 {* I/ d. ~4 F2 o% Y& h3 A6 R
  8 C2 V3 m! P9 r& U; W) F6 N
• 
  ) b9 f) S. g7 A2 S2 n$ L
        p=(PCB *)malloc(sizeof(PCB));  
  ; Q6 g3 e- c" b
  ' X9 Q. d. z& m2 E6 U8 B  L. f% @
• 
  6 i# R+ m1 J. y9 }& @' K/ s( r
  % _: @* r$ N2 D      scanf("%s",na);  
  
  1 D* V* {! v3 k" x" L4 b) s: i( I5 R
• 
  ; N7 c7 Q8 M8 T( V
        scanf("%d",&time);  
  ) ~  r0 Z* t: B6 b8 e) [% Y
  ( Y$ {, V# i0 }
• 
  
        strcpy(p->name,na);  
  
  
• 
  ! @, f. K. i  T" m- x7 O
  1 W4 ~% M# X/ c& L# h* w      p->cputime=0;  
  
  4 o3 n" Y: j7 @  B" X7 M- r
• 
  
        p->needtime=time;  
  , O3 t& J5 |) S+ ~! p5 k" N
  + k, T* S  [" p, ~
• 
  
        p->state='w';  
  
  
• 
  
        p->prio=50-time;  
  . t! U7 n3 q" g2 x
  
• 
  
  $ l4 E, Z8 O; K' u. [      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  + Z; }9 g: e$ Z" M) b
  
• 
  
  + k9 Q  c0 X$ e) X6 s, G     insert1(p);  
  
  ! ], i* N2 }, |" |4 B: C
• 
  * j3 Y) X6 c. U; O( M2 l! N
  4 v4 w6 b, J. ~' {      else  
  
  0 ]5 d7 C% j# u1 v
• 
  
        {  
  . @+ m# b9 J8 k6 A" |7 X& x* q
  9 l( }* ~/ l8 \$ j
• 
  & }$ I" o/ W+ Z9 d& d, Y6 ]8 |
       p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  
• 
  / V+ l$ l% x, T' A2 v; t
  ( l8 e( F9 P4 Q. ?" z     ready=p;  
  
  ) }2 q% M3 V+ K" D4 e4 _: G
• 
  + s, l  Z( X4 s: ?
  + ?# L+ v4 G: T% @0 |5 q% I      }  
  8 V, E0 R, \# q  n1 l4 e
  7 l. N# G& ^  g$ p0 N
• 
  ! ?% ?$ U0 n7 T
     }  
  $ g& G: {" N. _+ P* v/ S
  6 h) B, F* x3 ~8 q
• 
  
  4 G5 v, y) a1 b% a   printf("          优先数算法输出信息:\n");  
  7 A" j6 G/ k6 C2 A+ I$ @
  
• 
  
     printf("************************************************\n");  
  
  - Y' `% w" f0 w( j/ v8 g9 Z3 s: |
• 
  + v4 @* I% p; l& I
     prt(alg);  /*输出进程PCB信息*/  
  " k2 B( U6 p" c  ]) }
  ; p% t$ `' i1 q  r3 z
• 
  # W8 y8 L" q2 m  m! s
  ' M) w+ A3 O0 u, D   run=ready; /*将就绪队列的第一个进程投入运行*/  
  # O8 E& l  A! j5 L
  ( `/ [  Q/ ]( X3 O" e) E5 s) t# y
• 
  
  : c( h$ s& @% w* g& w2 S   ready=ready->next;  
  0 e  \6 j; {% d" Q6 v# s$ C+ f& u
  
• 
  
     run->state='R';  
  
    [/ u( }* C5 C5 H1 J! a1 a: _8 D
• 
  
  . ~6 y' D! K. K}  
  
  8 i4 B- W" B+ R6 ]! z4 _
• 
  
  /*优先数调度算法*/  
  
  
• 
    w8 @1 P7 ^- [3 `+ }
  priority(char alg)  
  , y3 _& B: J/ E+ ^" {9 |
  
• 
  1 L( ?1 S* d5 W% a! U# i
  6 L! o7 F8 W- J. P{  
  
  ; k; ~3 b1 |0 a- T9 Z$ m! E" g
• 
  # l' [# p) |( u* J* N
  3 `( ]7 [0 N" K! |1 n# T, S$ n1 y4 z   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  
• 
  * Q4 A  R6 @+ o8 h9 H3 l/ d3 f' `
  , n$ s) S( E- T   {  
  9 w* e5 O9 `2 o7 p
  
• 
  
  2 P: L( f0 r: Z. Q1 x: p      run->cputime=run->cputime+1;  
  ( k' x2 X0 K. Y+ o" I  D  T/ g
  
• 
  
  ' R4 a. z# g( a( l: q% ]0 L$ `" a      run->needtime=run->needtime-1;  
  
  $ ^. N, T9 Z4 e4 J/ Q
• 
  
  6 d9 y% p3 P$ F' b# v      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  * g) `1 f* I: }$ z6 ^
• 
  : g' e; k5 X* S8 y# X, y! ~3 R
  6 Z* z( p' r7 u6 H/ W      PCB *p;
  
  / ?/ M9 J  k2 E; C7 K6 ]6 k
• 
  ; t9 q: R/ c% O# n3 j$ t
  " r$ n$ Z% C4 x' C) r      p=ready;
  
  2 {/ ^8 h7 J/ I) U& F, H
• 
  & _/ Z% ]/ O5 m' [9 y. g. M- o
        while(p!=NULL)  
  - S. {- _' w# o- @
  , l/ L3 G# f& _* L8 G
• 
  % I5 @% f/ b6 f* r& _
  ( @8 B4 H/ A0 z- J      {  
  2 |0 i) _+ X0 |8 c" r
  - L0 P+ v; J( V8 D* e/ C
• 
  ! I7 m  O5 j3 x' L# F8 ?9 ~* H
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  
• 
  ( h: X3 L- r1 s, e+ I0 T3 t
  4 e$ [4 x% h& R. d) N          p=p->next;  
  5 j: C* b! E, ?% L5 [
  9 N3 g  e- u  o9 C
• 
  ( v$ z$ b3 b' E; J1 Y: d4 \7 ^7 e
        }  
  5 `5 P; M3 y* H8 l, {# o
  
• 
  3 q" u/ N! l1 R3 y
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  " a: d( Z, q, ]: F' S6 _  P
  
• 
  6 O& P  w$ b" q8 J4 g
  8 f# _4 }- X& d+ f3 W& G% V      {  
  # W$ h% L- }5 Z3 E( T/ w. T! D
  4 f8 k: |8 H* O8 B; Z% e5 f7 V
• 
  1 n3 [- @+ z' [  W. T) I5 h/ M$ ]
  9 Z' t9 Z% q$ F" t1 Y) B         run->next=finish;  
  
  7 p0 L8 p/ K5 l
• 
  
  7 H' z2 H3 B" m, ?         finish=run;  
  
  * {6 C" g) _6 B  l8 I
• 
  
  5 {; X  Z4 B- J3 @         run->state='F';  /*置状态为完成态*/  
  & X, F6 a* c% a, Y* T, K
  
• 
  
  $ y' F' v) w, i; _& A8 n0 G         run=NULL;  /*运行队列头指针为空*/  
  
  
• 
  
  2 S1 [0 u& l1 A  S7 O3 @         if(ready!=NULL) /*如就绪队列不空*/
  ' u) Y" ~  T9 r& g3 ?
  7 C7 Y& Y1 t* _/ h# X' U. X
• 
  
           {  
  + K% @2 w  J1 j1 k. O
  
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  
• 
  6 P, V0 U. B# f1 E1 h- K
  8 U* e7 H% X3 R9 _% R         }
  4 H0 S  |3 D5 {% v' V
  9 g# r. x1 O( H0 l
• 
  . i. `6 R5 o6 y8 ]/ }3 {
        }  
  
  9 F; Z" V" c% f7 k% e
• 
  " m+ S1 n1 {, |, f6 l  T
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  6 L/ ]( P) d9 N1 y& n8 Y* ~
  2 c( d0 O$ P9 q" J/ O     if((ready!=NULL)&&(run->prio<ready->prio))  
  
  
• 
  ; ]7 E- E' A& K+ K
       {  
  * o: j+ Y. B9 m" _
  3 p+ O2 q: Y: T0 v. [0 o& `
• 
  
  * ~! B$ c8 |1 u+ [& I0 Y7 _! v        run->state='W';  
  
  ; K6 l1 _% |4 E* @7 l
• 
  
  8 p6 d5 Z$ o* ~% t; k3 f( v% T( j        insert1(run);  
  
  * J7 c/ n/ S5 Q; E
• 
  
  6 v/ H3 l( T+ g# K( x+ p        firstin(); /*将就绪队列的第一个进程投入运行*/  
  : ^8 w9 L2 V4 j# P: d
  
• 
  
       }  
  
  " g9 H; E$ R4 b9 ~8 J) d0 m
• 
  9 Z0 q2 v) |$ @- @. m* }" B3 R, ^
  , _  U6 s' g; I; J% [      prt(alg); /*输出进程PCB信息*/  
  
  
• 
  
     }  
  
  6 B- b9 k& R. d
• 
  
  }  
  5 e6 D2 l) Y) O2 x* s/ s' q; u
  - p0 p  h/ ]+ v7 _& z6 O( M0 i% Q
• 
  
  /*主函数*/  
  1 r! [/ s1 j# o% j! `8 `
  
• 
  $ M# ?' E  Y+ |$ h9 Z
  : r( s/ z3 V: a2 \9 @2 O4 t- zmain()  
  / X2 b& X# V1 F& e' D9 h, p9 e
  
• 
  
  {  
  
  & {4 O9 z# O( i! L1 {1 F
• 
  
     char algo;  /*算法标记*/  
  ) h9 Z+ r8 ]( Y' Z" x- ^9 T
  
• 
  
     printf("输入P确定算法：优先数算法\n");  
  
  ) l* a( }: X9 |# u
• 
  7 |+ G; n: p7 T. `$ X$ c% v3 C
  : A$ k# i' g/ v- D3 r1 e0 c! o( l   scanf("%c",&algo); /*输入字符确定算法*/  
  % Y& w7 W# f  t2 k, p  J
  
• 
  
  : k" |! g9 q* h- v( a5 P; ]   printf("输入进程数：\n");  
  ( f# E/ B: k' L; v; ~( E. ?
  
• 
  
     scanf("%d",&N); /*输入进程数*/  
  
  
• 
  
  8 s5 }% s* v) [7 I: _2 S0 J   if(algo=='P'||algo=='p')  
  9 l$ V' L1 R. S- @7 R' d
  
• 
  2 V* P- J: R6 c. N) ~
     {  
  
  / T5 t8 c9 y- A  ^- y
• 
  
  5 g2 U5 s5 c3 B& C, w0 Q  ^      create(algo); /*优先数法*/  
  1 z' f( W! E+ A4 `& u
  
• 
  
        priority(algo);  
  ) N$ U5 T, _; u4 G
  
• 
  
  ) |# d9 ?; F" ~! w1 D: ~   }
  , M1 R4 r; n& V" q; V* _
  
• 
  - v) ?, X7 n4 |: B, R0 m0 L2 n: U
  }
  ! |: E$ b8 k- ?' y' V/ N
  
  , m! {; h  V1 [+ U' [+ R

: i8 u' l6 d) z. ]( ?输出结果：

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

8 D* \2 w6 i* Q, T! a

---

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

Powered by Discuz! X2.5