数学建模社区-数学中国

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

---

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

. ]! e* t# c: C) W9 `优先级调度算法

算法介绍
  P( l; a& a' l% _优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
6 G1 \3 j8 z* R0 x" L$ g2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
+ _9 \% A* C& U+ o, t$ \% V% B

2）动态优先权
- E! v& b. K4 t/ f1 A' ]

算法实现

抢占式动态优先权：

5 k  c6 j5 F; U# m4 XPS：本人认为非抢占式静态优先权没有实际价值。

• 
  ! O. C/ Y7 k1 h
  #include <stdio.h>
  
  ! c4 q+ x4 h8 n
• 
  
  #include <stdlib.h>  
  % a2 E* {( r+ e& r/ N3 x
  
• 
  
  #include <string.h>  
  $ e9 H# G. F2 |# C
  9 V+ f9 O% ~0 J! ~) C
• 
  
  6 _3 z5 K1 R% atypedef struct node  
  
  
• 
  
  8 W( K" P1 g8 w{  
  
  
• 
  / j: D! t6 [4 c- S/ @
  3 O( O+ r; V$ T$ t& A) j- ~   char name[10];  /*进程标识符*/  
  5 S; @9 D8 T* F6 L: V
  
• 
  ) c! T+ @7 Z; k5 [! w
    V5 H) k+ _0 R, U   int prio;   /*进程优先数*/  
  3 f# k8 \# O, p& x& S  ]' l* x
  8 ~4 |& d$ y  [  x+ U4 |
• 
  
     int round;  /*进程时间轮转时间片*/  
  $ G8 V' V+ q" C( i$ P/ |8 D9 o
  
• 
  
     int cputime; /*进程占用CPU时间*/  
  
  2 v5 h$ h; {' o! k7 K: S4 Z
• 
  % u  q) g( j. |) g/ c* k
  0 T" ?& u( B2 u   int needtime; /*进程到完成还要的时间*/  
  0 p; P+ \; q8 u3 s( @# I: Z' Z
  0 {- O; N9 i7 R, k( w4 V
• 
  * o  X* s3 y" @( q; x- H3 w
     int count;  /*计数器*/  
  
  
• 
  
     char state; /*进程的状态*/  
  2 M$ k/ {1 F1 ^' ?
  
• 
  * H: o0 b! `) c
  - u! J. k* N$ p( j, B% r) ]$ J   struct node *next; /*链指针*/  
  
  ' v1 A- J' V$ r4 t7 T8 ~- y( N
• 
  
  }PCB;  
  3 Y: G1 j1 T7 R) n* P
  
• 
  
  / Z; k9 S! a& P: z3 ?# {; Y; {$ TPCB *finish,*ready,*tail,*run; /*队列指针*/  
  ; U0 h" [4 {, |$ h* h
  7 n/ M' E6 t$ y, m
• 
  
  ' u' I' v0 ~. v, S; o' {int N; /*进程数*/  
  1 ]# {" P3 o- X5 C( E3 D
  
• 
  , J6 }1 [2 J, g4 J+ U# e  T' [
  : U4 \4 Z2 S4 O8 ]. T% a  @/*将就绪队列中的第一个进程投入运行*/  
  
  * o' G" o  n7 m7 y$ w' w* d( C9 G
• 
  
  firstin()  
  # ^$ E( |, F. q6 I- j
  2 \3 ~  J% j' t1 Y# A% z
• 
  5 [5 N; A) m/ C0 ]  u/ l
  0 t# C, |# x0 \' a1 |{  
  / s/ x4 Y) @6 Z; ]: a
  
• 
  / Q- f$ o& y# E( E& |
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  + e' E; L) O7 p7 u
    y' r6 M  R- G" o0 n
• 
  
  , F1 F0 }. d/ P. u& Y# W   run->state='R';   /*进程状态变为运行态*/  
  3 @' v. q2 K9 U0 r' b5 `! }2 t
  
• 
  
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  
• 
  5 N' _6 X% B' M+ @" O' t& E0 j
  }  
  
  ( H: S+ `8 V. o; W( T1 g& a
• 
  # f  f; [; c) n" C, E* S) `
  ( j$ {8 ]2 i8 c) W" C4 W/*标题输出函数*/  
  
  
• 
  
  void prt1(char a)  
  
  9 I: N0 [2 e. O. Z$ i+ |9 D; F  I
• 
  ; E, y/ U9 H2 t
  {  
  8 x2 S+ Y* P$ e, R  ?# L' x
  8 `2 v9 E3 D! h$ W  O
• 
  
  ) @* V- c- W4 W& @  X% s   if(toupper(a)=='P') /*优先数法*/  
  " e2 Y+ C7 k! e$ E
  
• 
  / V; M2 Y; h/ e) J4 ]+ G0 F
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  # B! Q0 Y, I$ E) J
  + ?; ]% x. R* g6 k
• 
  ; R9 Y1 q# c- w# ^- f: o* \
     else  
  : N) E* e  I+ @+ S
  ' I1 I+ O* I+ \
• 
  
  # w) b/ }* B  g3 Y( k1 u( @, V      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  5 D' {; H5 A6 ~( L% O
• 
  
  ! M$ k. ?0 d6 e0 D% B# J}  
  
  $ ~% T4 U5 H" V9 t0 }+ A1 g
• 
  
  /*进程PCB输出*/  
  $ ~( k3 G- Z! r6 K' ?
  ) t- M# p5 g' P7 B
• 
  4 I" ]& W8 a% s4 }/ n0 h# T& y2 f
  void prt2(char a,PCB *q)  
  4 G- n( n- b4 s$ C5 a% a
  
• 
  6 E' q! b4 s( C9 M& U4 L6 W
  {  
  
  : f" T' G7 H  L: Q5 }
• 
  ; \" J, b/ i" x
  ( P, ?; J% b% y6 j" O5 v   if(toupper(a)=='P')  /*优先数法的输出*/  
  ( F& W7 w9 @$ N9 q9 ~5 y3 y6 o
  
• 
  , {# \+ d- Q0 t& S; n8 J
  4 U. s* N, z! ]: b* I      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  8 L7 X0 M0 S; {7 B' v- R
  
• 
  
  4 ~5 P4 ?1 _7 |' ?5 r       q->cputime,q->needtime,q->prio,q->state);  
  
  
• 
  
     else/*轮转法的输出*/  
  : f. S; c! O$ P. c% I! a% b
  $ M! n$ _) w; U. N7 f; E* X/ n
• 
  * R* H' |% d9 }; z3 n
  % @4 O4 \$ Y- r, p" R; `& v      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  / k$ E2 y3 r$ S6 H. v( d1 Y. v- h
  
• 
  
         q->cputime,q->needtime,q->count,q->round,q->state);  
  9 j0 R  e& n9 C. X" J/ A
  
• 
  7 C3 t+ S( Q! \6 |7 j7 q+ s
  6 [0 a8 l5 G- U& |8 P}  
  
  4 f4 {# H/ i: ^! S, O
• 
  
  ! V: t- |0 l! l8 D  T, O* b/*输出函数*/  
  6 Z3 Q+ B: s0 H- U
  & Q4 N+ S4 g  n; g5 J
• 
  ) T4 Y) ~7 I9 T! w/ N, H- x
  void prt(char algo)  
  , `  R/ g& G. W6 V) X7 h8 q
  
• 
  1 R6 [* J5 K1 ]( `
  {  
  3 R. _0 c4 w( L  A0 }
  4 j9 Z' m2 V* |0 y& d0 c+ w$ h
• 
  5 D4 V0 [- K" E% d6 q
  6 l! q3 L0 ^7 O5 R' ~( _5 B   PCB *p;  
  
  . C9 e5 z; y8 f; D- K* C5 c
• 
  
  ; x- h) O6 x" ?! S+ h, `$ w  ?   prt1(algo);  /*输出标题*/  
  5 A; @4 x; v' J
  8 |$ ]2 @3 I! a: T# e
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  
  
• 
  
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  
• 
  
     p=ready;  /*输出就绪队列PCB*/  
  0 R/ q  x8 O0 @+ D6 E2 Y$ l
  / h! R% P5 p0 e) S7 p" ~' b
• 
  
  ; |$ ^8 r0 O; d/ Z& t5 Y8 y5 L   while(p!=NULL)  
  - `* d) L3 ~1 _  j; y1 ~: U5 o
  
• 
  5 @5 d- f1 I$ V! R( |
     {  
  
  - `6 e5 w- h" A2 G* q( H
• 
  
        prt2(algo,p);  
  
    S  t. Z# H  ]0 U
• 
  
        p=p->next;  
  
  6 M$ b( K! |6 [: w% h% p6 h
• 
  3 G% N/ ^8 s" I# I: i9 j5 S0 }
     }  
  
  
• 
  
  - _* u+ g+ t: i3 Q' _   p=finish;  /*输出完成队列的PCB*/  
  
  . D* M8 K( D1 c3 y; Q3 \. d
• 
  $ B4 h/ _/ R+ r, i3 a
     while(p!=NULL)  
  # |* B# G8 ~7 h) ?6 d! Q
  
• 
  
     {  
  
  
• 
  
  0 C; E  _9 X' Q# u; _      prt2(algo,p);  
  
  
• 
  ' m5 \7 v2 t" @
  ' [5 z6 k5 V9 q7 D' D7 B      p=p->next;  
  7 J4 V) y6 c9 O+ a& \$ B
  7 ?. s$ g( L: _% C
• 
  
  % O. H5 H( m' a6 Y1 Y* f   }  
  
  
• 
  
     getchar();  /*压任意键继续*/  
  4 s9 H% \$ B  |" c4 s
  
• 
  0 i: g- O1 a& t* e. p
  8 X5 A1 }$ W- j) y}  
    ?$ e' `" ~% b. B: ], P* e
  # `) C7 C2 \6 d& R5 v
• 
  , x- K9 \/ b3 L1 B8 i
  /*优先数的插入算法*/  
  
    e7 D' E) G( @. V
• 
  3 C( p4 G( E9 ^( r1 r6 s3 T+ z% ?
  insert1(PCB *q)  
  
  
• 
  
  , z) _8 _! p5 `) j/ x) ]{  
  
  * m* N% e7 n* ^- Y9 i- p2 [. @
• 
  
     PCB *p1,*s,*r;  
  
  
• 
  7 w1 O* e  c; _/ O, b
  : _" B0 g- |; c! j+ `; E4 N   int b;  
  # H- C2 m8 R% f
  8 A1 z$ Z2 p: _, K0 A6 H0 I# i
• 
  
  9 s3 w- W( Y/ ?   s=q;  /*待插入的PCB指针*/  
  ; o/ J8 p" ?8 y8 _# P
  4 O# t! L% R" m" V' u( j2 p( q) b+ [
• 
  
  ; ], z( p; B" p0 K. q. a   p1=ready; /*就绪队列头指针*/  
  ' ^7 l4 p3 U4 o
  
• 
  ! ?6 \( |5 Z5 h( `$ l+ j) ?9 @! z
  8 f) x( C* n7 ]4 u, p3 V   r=p1; /*r做p1的前驱指针*/  
  
  0 C+ o, Z1 R6 r, E' s, T4 d: {
• 
  6 \- j0 r0 i4 n( C7 y2 |
     b=1;  
  
  
• 
  " }& @$ {* H2 I" U  z! X8 g( G
  4 @; v4 D4 B2 f) e+ J3 s   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  7 s: |" Z6 u4 d
  
• 
  + S% w/ s  W- m7 G5 G" W1 d
        if(p1->prio>=s->prio)  
  ; F- ?8 i! I& [! q, b3 q
  
• 
  4 Y0 \  Y4 Q2 O' i0 q( l6 o
  - I% u; B( q6 p6 I- s$ u9 o      {  
  
  
• 
  ) B; D  ^' e5 e0 i% l; I
  1 G9 B/ _; n% |3 u0 F     r=p1;  
  
  ; i& b( y5 }2 t7 r9 g5 _0 v
• 
  
       p1=p1->next;  
  + e; y+ g$ I) `
  
• 
  + c' W: Z( V1 n# N! K" c" {
        }  
  
  : Y: p5 P9 j5 Z. ?5 a& S; n
• 
  
  4 @* `  ]4 Q1 w3 }6 T5 W      else  
    u- P& Y- E& Q, N6 S
  
• 
  
  3 Q. i5 G5 U: c6 S$ _! D3 A     b=0;  
  ; Z/ I1 d7 H7 m: s. a  g
  
• 
  9 ?$ U# x+ R2 z( E
  6 H* r, L, @( V) u4 T' _7 f   if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  - e2 F3 A" t% N9 h& W' b( q' `
  
• 
  
     {  
  
  , L' q* C7 X- M
• 
  
  ( \" K2 Q- b5 V      r->next=s;  
  . ^( \' U" f" @2 o
  
• 
  
        s->next=p1;  
  
  
• 
  
     }  
  
  % V# C2 [8 O) F& W6 w. r8 ~; g$ r
• 
  
     else  
  
  
• 
  
  % l9 ^0 c8 h% v3 E* R   {  
  ; H% o- Y' ~% D
  6 ~" A1 K4 ^& ~& V3 G
• 
  5 H  K, u/ d( s* {
  , H; Y; O1 K7 E7 ?, c1 M% `      s->next=p1;  /*否则插入在就绪队列的头*/  
  : o- o+ _8 B0 W& S5 \) D+ a* j0 ?
  
• 
  ! {% }. r/ d2 w2 S8 ?+ Z2 t( ?
  6 M( l7 S  T1 l6 h      ready=s;  
  
  8 l, W5 I4 I, D4 r4 w3 P1 `
• 
  # a$ U6 r/ N( f" g9 ]
     }  
  
  % F, C2 ~# T6 [
• 
  
  }  
  ! q) c8 D; H- f
  
• 
  % Y/ o! }3 l; B1 S3 y7 l
  $ A% K1 F; d: a) f7 o7 y! L/*优先数创建初始PCB信息*/  
  & E- B# R$ S8 ]& T
  
• 
  
  void create(char alg)  
  8 ^$ G* P/ j( D3 u9 H- K0 U5 A; F
  3 X! r9 @8 T: u2 ?
• 
  
  % a/ B( B7 e  w{  
  0 A5 f/ m5 U; y9 E( S. ]5 Y  V  j
  3 V4 e/ g2 l. [! W+ m7 l
• 
  . o! f. i$ S0 _
     PCB *p;  
  
  
• 
  * B1 b8 n; {1 c" W* g4 [
  & w/ \3 @% C+ r" [1 ?   int i,time;  
  
  + q" E4 W7 @. Q; m) T
• 
  ! D; q" x) T& O( z' ?) n# b
     char na[10];  
  
  
• 
  
  & E" G, O5 A7 O( s2 V0 _0 C   ready=NULL; /*就绪队列头指针*/  
  
  3 U3 W  C# D' H
• 
  
  5 E) t/ Y1 D4 S9 u# r" w7 _# s   finish=NULL;  /*完成队列头指针*/  
  
  
• 
  
     run=NULL; /*运行队列指针*/  
  
  
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  
• 
  
     for(i=1;i<=N;i++)  
  
  
• 
  
     {  
  , M$ |3 a3 `' ]
  . ~0 @4 j3 Z9 B# ^& P, |: ~# l
• 
  
        p=(PCB *)malloc(sizeof(PCB));  
  
  + i' V' f, f5 P
• 
  
        scanf("%s",na);  
  
  
• 
  
        scanf("%d",&time);  
  
  
• 
  
  ( Y9 N4 V( ?  w& [3 s+ F& q      strcpy(p->name,na);  
  
  * g8 z+ i9 M# @7 F
• 
  
  & n$ ^4 ?6 m. E$ Z3 ^& L4 o      p->cputime=0;  
  5 x: k) j9 w8 l0 F5 B4 S! j
  
• 
  ; h6 f4 N7 P, q) [/ ]& ?
        p->needtime=time;  
  - I% z: K% X( ?3 ~
  
• 
  
        p->state='w';  
  1 s# O, i0 v! C0 Y% n0 d1 [) c
  
• 
  7 |$ x3 C& K5 m9 Y8 j7 g3 h
  0 z  @5 N5 G: j. T- O7 a" I      p->prio=50-time;  
  
  
• 
  
  ; D  J& f1 }+ s% l, U2 x      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  7 n2 t) _3 w: y, {% h3 _
• 
  
       insert1(p);  
  
  
• 
  * ?0 _7 k0 c; c* W% e% V
        else  
  ( U- T  S3 ?3 k6 p, J% [
  8 s; ^5 b. F& k3 w
• 
  
        {  
  
  # s0 T7 {( q' ^9 @
• 
  
  7 N: w4 P! P. h) T: Y     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  
• 
  ! x; H# q( ~2 t' o) X: `5 v( D
  0 J" z- e6 f2 }8 \7 V: n     ready=p;  
  
  
• 
  
  & ]0 ~" t4 L) \! {; U      }  
  & C  j2 A: R! z
  / p; r  ~6 B$ `! q
• 
  # ~5 Q2 \% [. g5 {2 t3 e
     }  
  1 P$ Z5 m& {4 v. J
  7 t4 Q" f4 Y. C& q8 O1 ]# N9 c
• 
  ! U5 g# u5 y1 z5 v; T
     printf("          优先数算法输出信息:\n");  
  
  , B& m, d2 j3 Y" b: E5 N  |
• 
  $ `* l3 ?+ c, c* t& |: [
     printf("************************************************\n");  
  
  " e5 O( A3 K9 l, U; e
• 
  
     prt(alg);  /*输出进程PCB信息*/  
  
  
• 
  " O8 z( m# D: I( _% p
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  - P" s) R  o0 F2 p2 J& q# `7 A/ P
  * [; v: ]2 n$ T$ s
• 
  
  ) ^6 s& U$ p  Y, R& B. c9 Z   ready=ready->next;  
  7 q; D8 q9 ~9 F0 q) d0 {
  
• 
  6 e8 k# K2 o2 w* o
  5 i2 Y0 K* c( G. x! n( J6 u4 W' ~   run->state='R';  
  
  # t0 ~7 U) Q+ U/ E' f5 Y% l8 w
• 
  
  }  
  
  8 a7 a6 P5 D+ f7 z1 a5 ~
• 
  4 p9 g7 f" A) n' y9 R' O; v
  0 T% ?' Z; O6 L1 ~. _5 C/*优先数调度算法*/  
  : n) Z2 t2 X, z: \$ z5 x+ I
  ' M% h$ H2 {1 N) {  x7 E3 Z  D
• 
  
  priority(char alg)  
  
  
• 
  ! Y& T! U4 }' z/ }2 c
  {  
  * g; a7 F+ A8 @. R" F) |# k( Q
  
• 
  
    b+ \% Y( u8 \* ^. G& ]2 L   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  ' D& T0 X9 i7 s9 }- O! a% d( c  \8 _
  
• 
  
  * {; `% A9 I# I. O5 U- u   {  
  1 B  P1 p- w- k7 M6 V
  
• 
  0 K, D3 R" ~) N$ {- h0 x: R
    h3 Z" {% [9 Z8 [! A8 C      run->cputime=run->cputime+1;  
  3 x# i! T: r& l, q
  
• 
  
  : d; r6 f. Z! Y% M- J  F% S      run->needtime=run->needtime-1;  
  - B" Z6 s- o1 R# s% @9 D" h, c
  1 d+ h1 }) }& L& ?6 N
• 
  
  % _( M8 l2 d4 I      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  
• 
  ; R4 l4 `2 c" @
  * A! K- n/ S* Y9 N2 g      PCB *p;
  
  
• 
  
        p=ready;
  " g. X% G% y8 [; v0 v" p  ]$ R$ v
  
• 
  , _7 B0 A" [$ @2 B
  3 ]3 z# V! J  U      while(p!=NULL)  
  
  
• 
  ) j& _) e$ Q: E
  " p/ {7 N2 n/ M9 g      {  
  ' |+ ~& f+ D, j0 E0 A
  0 F8 c5 ~% O& ~8 r& j) e  p
• 
  
  ! s7 X. b4 J/ X9 w" N2 u# V  U          p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  * e0 S1 m8 f; o7 i1 X' Z0 e
  
• 
  , x4 {0 l4 j! `8 Z$ o& l/ `
            p=p->next;  
  1 f: \! k& W& ]2 B( X
  6 X) `! l/ p6 ^+ Q  h2 I
• 
  0 c9 D) [& q7 t' q; x' i8 R
  ; @; a& ^/ s( N( b7 P) Q      }  
  
  
• 
  5 f' t4 H: c" _8 p
  4 i4 x  O! h( x# Q$ q" k      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  % u5 L% f2 ]5 z3 H3 f: \- ?
  
• 
  
  5 C  ~/ H# t: F      {  
  
  
• 
  ) c& ]. r( c. Z5 P5 J" N! ^: c. o
           run->next=finish;  
  " T) t6 c+ x& s
  
• 
  6 b. b4 W/ N) q7 L, `
  / i5 I" L2 V, ]6 V/ m& x5 `) [         finish=run;  
  
  
• 
  
  3 a& I, A6 f2 A         run->state='F';  /*置状态为完成态*/  
  $ }* A% S0 ?& \, R+ ]
  8 y: U' T! D9 S2 x
• 
  % i: O0 v' r: S* G2 e" B  g
           run=NULL;  /*运行队列头指针为空*/  
  9 g1 E9 {) d. o4 W" n5 S5 R: N8 w
  : z* e1 E6 m2 f) n9 [1 v; J
• 
  
           if(ready!=NULL) /*如就绪队列不空*/
  , k. U8 N  K& @% S' f7 N; V- A
  2 y7 e3 L4 H/ z( P- I( a
• 
  . W# `1 Q9 I3 a: |
           {  
  " [. ]# u9 W7 n' i/ ^3 O
  
• 
  
  ! c1 a. I* }+ G% t( f            firstin(); /*将就绪对列的第一个进程投入运行*/  
  / P# F! f1 q7 v( O4 [! G
  
• 
  
           }
  1 |$ R9 \% I0 x$ G: x! G# B
  
• 
  & L/ t$ [' J; B7 w, @# \
  5 W) g* Q  H9 |' }; h+ _( S" L      }  
  4 R3 F- B0 D  F6 ~
  
• 
  
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  1 W7 q; R+ `6 T
  . e: [: [+ _6 ~4 l" G
• 
  
       if((ready!=NULL)&&(run->prio<ready->prio))  
  
  4 V3 T+ k7 q1 S% [% N* q! A
• 
  ! P# O& b( _1 i1 @7 F' B
       {  
  , Q) B6 {! m+ ^" j0 q
  9 J" Q( D. J$ ?7 l$ _& k' ~
• 
  
          run->state='W';  
  
  
• 
  
          insert1(run);  
  
  
• 
  7 o$ ]' h9 Q, u. m$ [8 J0 i
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  ' U4 x7 h+ E' f7 J% p' k" F
  
• 
  5 d/ [! q; N! ]2 b6 C
       }  
  
  
• 
  
        prt(alg); /*输出进程PCB信息*/  
  
  
• 
  
    r3 o8 {& [1 G   }  
  
  # T& t6 r0 D: P2 H$ Y
• 
  2 ~6 o9 [" h# @. i5 u9 l' b
  }  
  
  # u5 q+ \0 L3 z
• 
  6 V  h. H( g& {, `4 ?/ w' {' a
  /*主函数*/  
  5 n( o1 ]  f1 p7 k+ C
    s4 A  n# D# ]6 C4 y: O* P
• 
  : n3 D6 g# j9 @( C& ^
  ; b5 e, c$ K( I, M% Xmain()  
  
  $ v: i6 Y9 J( R, n7 S' U2 C% T. _
• 
  
  ) [2 n- U7 K- N& w7 p{  
  5 k0 G* _( y$ O% P) h( u8 U( ?
  4 Z3 [& U- U/ t
• 
  ) v1 w/ j. a4 |! S' o+ ^% b
     char algo;  /*算法标记*/  
  * B2 w& U- b- s- j: T
  
• 
  2 l9 b: R6 S! H/ u' ^, r
  , c6 b$ s: |$ K   printf("输入P确定算法：优先数算法\n");  
  3 E* J, ~7 z4 H  \
  
• 
  # @& U! V0 z0 p- Q0 b
  & F5 Z5 @3 _8 N2 }   scanf("%c",&algo); /*输入字符确定算法*/  
  8 v& v( j" G8 Z" k9 I0 E' G
  6 I; T8 {% V: q8 }3 q( C
• 
  
  6 U# }& l' M0 O3 p; B( G: i# J   printf("输入进程数：\n");  
  
  
• 
  ' b, f  v9 Y' e
     scanf("%d",&N); /*输入进程数*/  
    j& w* l5 j+ g/ ~
  - u, D5 d1 w0 S# X* d
• 
  
     if(algo=='P'||algo=='p')  
  $ Q$ P# {: V- L8 h* h) u; W5 D7 X
  
• 
  8 v+ T+ e2 `8 b6 W: h" b# y' R, Z
  " ^$ w& P3 D' \. W   {  
  ' \! J7 {: E1 ^+ u; l7 c
  
• 
  
  * @4 V1 L# R6 x7 z% V      create(algo); /*优先数法*/  
  ! y5 U4 a3 q, t) c: t2 \" m
  
• 
  
  5 t; n, W) U$ {2 q6 c0 E# s, k      priority(algo);  
  
  7 d. i1 W3 x  `, |# d
• 
  
  # e* @; |0 V( d   }
  
  
• 
  6 E  N  y* b1 _# P' i
  }
  
  - f  E  g. y% b# e3 u! T
  

输出结果：

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

---

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

Powered by Discuz! X2.5