QQ登录

只需要一步,快速开始

 注册地址  找回密码
查看: 3173|回复: 0
打印 上一主题 下一主题

优先级调度算法

[复制链接]
字体大小: 正常 放大
杨利霞        

5273

主题

82

听众

17万

积分

  • TA的每日心情
    开心
    2021-8-11 17:59
  • 签到天数: 17 天

    [LV.4]偶尔看看III

    网络挑战赛参赛者

    网络挑战赛参赛者

    自我介绍
    本人女,毕业于内蒙古科技大学,担任文职专业,毕业专业英语。

    群组2018美赛大象算法课程

    群组2018美赛护航培训课程

    群组2019年 数学中国站长建

    群组2019年数据分析师课程

    群组2018年大象老师国赛优

    跳转到指定楼层
    1#
    发表于 2021-4-9 15:39 |只看该作者 |倒序浏览
    |招呼Ta 关注Ta

    # z" h. r$ _3 @/ m0 _0 R4 R! v: @! Y优先级调度算法
    7 P/ P/ d. `8 _- b+ z

    算法介绍! H( E5 g. j. d: ^* i8 e" h4 q
    优先调度算法的类型(用于作业调度)
    + K  n- f) }) z1)非抢占式优先权调度算法 9 z0 J0 A) R: Z; H' U; w4 q' R! K; j
    系统一旦把处理机分配给优先权最高的进程后,便一直执行下去,至完成。 6 J0 S) k& Y6 z  l4 R
    2)抢占式优先权调度算法 " |1 D1 y: Y- C1 X" W
    只要系统中出现一个新的就绪进程,就进行优先权比较 。若出现优先权更高的进程,则立即停止当前执行,并将处理机分配给新到的优先权最高的进程。

    优先权类型# ]1 k2 D9 m3 s& j& n
    1)静态优先权 8 d9 S/ L' `5 C( G6 h5 m
    静态优先权在创建进程时确定,且在进程的整个运行期间保持不变。- b3 i% K% E, C% k- T

    2)动态优先权 * _; {6 Y9 Y- w" U# c1 s/ x& f

    算法实现

    抢占式动态优先权:


    . f" v+ R7 g) r- C! E8 O/ o5 cPS:本人认为非抢占式静态优先权没有实际价值。

    •   Y7 r) I& ^# [
      3 `3 h4 ^9 q. G, j, h
      #include <stdio.h> " t8 A* U' G) ~9 |! E; v- V4 n" K

      / r' v/ r$ d2 d
    • , {, ~$ O$ |) G0 C8 |2 ]5 q
      2 U! k( `. W* D# A4 l
      #include <stdlib.h>  
      / m' I, W& R+ S) K0 w
      . D% u0 G$ k4 K" f8 v1 j' V1 X; X- t

    • ) Z+ ?" o& @! h+ v, H' S: Z
      9 t3 }" E+ d! d1 z
      #include <string.h>  4 |( P: v. ]2 w8 F) b5 F; P9 v
      6 _4 R( G6 X+ m9 n: A% n
    • 5 _3 \- N) T# d0 A; r, n
      + p8 u& W( r. Q. O, d
      typedef struct node  7 m0 b2 K$ ^& X+ V3 L2 ~9 m' s: @

      , e- V) u! |9 x' n5 ~$ n
    • 1 v( `/ @" O% |0 s) I

      ) c  E8 G' s# w5 _0 n1 k{  
      6 f( G! L5 r" {& f- h4 K
      $ y5 U, u7 x  S8 A
    • 9 t, s" o5 v( `! a' f8 S3 u

      2 u, o8 V7 Z5 u" B- }8 i8 X   char name[10];  /*进程标识符*/  7 D) z, X- p+ W6 f$ I. r' L
      9 H# Z5 n8 I$ j. t
    • ' ~+ P2 t+ T) V+ R
      " K; Y* F1 _4 A# B, k
         int prio;   /*进程优先数*/  
      " i- p5 r9 ]& K1 R1 Z, f

        C/ ^2 X0 Z% |* S

    • 8 ?# g& y: k1 i; o5 g
      ' _3 _9 f! {# w9 U0 l% \3 J! G
         int round;  /*进程时间轮转时间片*/  
      " p; N# k  P/ Q5 M6 n
      8 t7 x3 e4 G' M, p* I

    • * {' @3 z) l9 y- r+ A
      " v  g$ Q% M& f( h3 j
         int cputime; /*进程占用CPU时间*/  
      + Q; s+ a/ w  r2 J

      5 {5 L) o1 ]- N4 z

    • 5 x+ d6 g0 j) T: _. [9 A+ R1 x

      * c4 S% i) ?! C- x) I  L   int needtime; /*进程到完成还要的时间*/  
      # K# K: P; n  H1 P) L/ n0 p
      + G" K' s! J5 Y$ f7 y' G3 {2 ]
    • & z( h/ C6 W! }, ^" m$ u  a& O

      ' i9 g, f6 |8 d   int count;  /*计数器*/  
      ; u. L6 X, \; {0 w% ^: r! b
      2 O6 i  l' D  H7 g# u0 |
    • * y: c! }0 m# ~7 x* N) H& E
        x+ z( J' Q; Z+ c# x$ j% i. O4 b
         char state; /*进程的状态*/  
      ! d7 e& x! p2 J& k, O$ c6 t$ G

      , m4 M9 r4 K0 j. S# c9 E

    • ! O/ J5 X9 R  R$ v

      ; n2 e! v+ L7 o* S: _1 Q2 V   struct node *next; /*链指针*/  
      7 y, z5 v. C1 q& \( C3 O  d
      ' q7 j% k! S& ?/ b( y
    • , ~9 E: Z$ ^% N# Q% G( i2 [/ g/ G+ Q

      9 a8 G9 C( _+ [3 O9 S! }, y}PCB;  
      ) Q% d3 F3 w& I6 K5 u

      ( s. M& A8 d& r8 l( p+ H$ G

    • 1 @4 H6 D7 Z- [' ]* r4 X( `
      , d$ ^0 Z0 O9 L  A) p* K
      PCB *finish,*ready,*tail,*run; /*队列指针*/  % w/ H9 P, C9 D. Y/ k8 f5 x; B$ h

      4 F: s0 M' q/ y5 B8 S

    • . {- E' b8 S, b) q# c% f
      " {3 S2 A; M. e# h, c- T
      int N; /*进程数*/  
        d( u( ]/ ~4 V& _# F' q

      6 a% d  d- X2 _
    • % y( s5 D+ F' o* f/ t  v2 t3 u

      7 _+ d! t, A# O2 R2 H5 ~/*将就绪队列中的第一个进程投入运行*/  
      4 L4 N( Y1 \$ f

      , l; Q1 Z3 B3 J+ S
    • 3 H0 n% r: ?" K) m; Y7 ^" ~  l
      4 r& W6 l- h, D7 K: X
      firstin()  6 ]9 c, z9 t7 l5 J5 ]  B6 f* ^/ d
      + D" V% b8 ^; F( w/ |* l3 P& u

    • ) ?+ ]# Q3 C' b3 e! [6 f9 r

      . @/ @: z3 N$ K{  
      9 `9 a8 G4 q* Y7 |' f: c& Z' [

      1 Q' k9 j& |  M! F" C* U' x" h
    • 6 t# u! N4 \6 p" `6 U

      2 ~) Q$ O3 Z, `3 S   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
      - M8 e' K+ D0 e* a) C
      % n- h) W) D# ]
    • * s( d' L* Y7 \8 d- V4 }

      - `6 n$ K, X, o, T0 p- M   run->state='R';   /*进程状态变为运行态*/  
      8 y  y. Z# D2 D* I) R  m8 n
      4 E. n8 `1 v. d( D

    • ( F* e2 l7 Y  i+ ?

      - R2 u3 G: J% c( }6 Z   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  ) K" o0 b% V, f6 Q0 v
      6 S. L  }! ?$ Y

    • / u! ]  ]! c- q& y6 W

      $ [  T+ [7 T, ]) E6 {}  
      6 m: h3 N8 [1 P. n4 E
      * W4 Q& Y% u+ ]4 V% I- o$ }2 {. X$ \

    • 5 e) ]3 g/ \) A! k2 m( _

      7 M8 x6 n( y# m: J7 {/*标题输出函数*/  " }9 T! b( K# L+ W0 G- J
      ! ~# v; J7 D2 k* R  R

    • $ r* P( f# F; ^. z: `
      / R3 [& e8 t4 X( V  o; b+ m1 c
      void prt1(char a)  
      1 B, O; c7 F8 Y1 ^5 I& p+ p
      7 x5 ]4 a, Q7 a2 W& M& E6 b
    • " D' s0 j6 k% j8 Y" J: Y
      + F! D1 C% L5 @* l+ E, }; T
      {  9 A- {/ k: _/ ]2 f  q7 B* X, G
      ! G) w8 w( v- y8 U

    • ) M/ H/ n8 o5 h
      ' d. |# X0 _/ \% T) L
         if(toupper(a)=='P') /*优先数法*/  + R' O$ @+ S; [
      ; V7 |: w7 `: a4 A: q+ S4 g

    • , f* G9 [1 I4 E$ J% D& p9 e- x: P

      * ]1 v. S! \+ c; b5 d      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
      ) L8 d& T; j& ?, ]1 A6 _  J$ ]
      ' w" G; v' H7 h# R

    • / u7 J, A4 x% _% ^# ^, K. a5 C: E

      * }- E$ ?$ n! S3 ]* ?8 n   else  
      ( z/ X0 g5 L/ a5 [1 ]
      , I( O* \0 h+ f* W
    • 4 C$ T6 F0 s/ u2 b# @

      0 y8 n6 o" a) J4 ?- z2 _      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
      2 {) G. j  f+ Y7 @+ h
      , a. @) f. j, N: {, {

    • 3 N: d: M0 w- o, Z; c: m
      . _4 i# h2 w, p$ F+ H3 N
      }  1 P8 g# n, t' h+ M8 J
      ) f3 Y! o& D+ x& o& l4 X

    • , g- }. ]: Y* f8 l
      - T, x5 G6 n% K# t
      /*进程PCB输出*/  ( P+ L( ^& a5 U
      / o8 K; k3 F) D7 L4 _- V

    • " Y& U* D5 M) N, C0 S
      9 G5 a2 s; m: v9 k
      void prt2(char a,PCB *q)  
      8 V/ D( }$ z' v+ R1 J% n: U
      1 [/ k9 ^2 T# x  X

    • * X6 T6 z$ Q- M0 x: H

      7 u1 y4 I( \0 G9 Z4 R{  
      3 a2 o/ Z2 C( O* H; V2 M

      1 G. ?9 r8 H% M* n! |. a5 M

    • . c" ^3 z* Q. m. r
      $ Z" m( U4 D6 S; ?; t4 T" Q1 x8 v
         if(toupper(a)=='P')  /*优先数法的输出*/  7 ]' M. o4 Q* {9 O, A4 ~$ O/ w# G

      ! H# F( p$ @- k* O2 R5 w  C5 o; O# ?0 _

    • ) P' q" g/ ]8 _* j9 M/ o4 f

      7 i/ W2 f' r, m6 O      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  6 U9 w( Q3 l# Q: Q- T

      ) F3 [8 A' r& T

    • : u9 {4 v) y0 s% ?

      9 a( `! g  d7 n& {! J       q->cputime,q->needtime,q->prio,q->state);  , O' o  f) e3 \. w5 X* W0 ]0 w
      + ^3 X& ]5 k* ?+ W1 W
    • ' W+ H7 z6 {& E* G; T

      ' c8 x/ T+ t; W9 n! w- e   else/*轮转法的输出*/  
      5 B$ N7 X+ ~# Q2 ]4 E! f
      0 Z  z  m7 j" _7 y- U8 k

    • 6 Y) B( T. ^! ]8 g4 t/ Q- y
      & K" r7 \& z* ]
            printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  * K! S/ S  i" Y

      0 v1 w' F8 e$ \9 ?" s; _
    • - c5 z  S3 v& u: K4 X' D

      3 I7 U& P% s) G       q->cputime,q->needtime,q->count,q->round,q->state);  
        c' v/ n% Q, n2 P# I

      3 f( g3 q1 {% W. @3 A
    • % ]5 y- d6 }% p/ u* {! B% u* \; R3 `
      + E* |! o" Y! U2 m( f6 `% o& S
      }  
      ! {3 E1 p+ [) K# c
      5 h* o  o5 x! U
    • 4 `0 ~) i4 ?: D: h
      2 Q: a5 J2 ^* ^$ M9 _4 q% t
      /*输出函数*/  ) K/ p( V; ^. {- Z* q
      & L9 Y  v4 F: b6 g$ f+ i) B4 \& i9 ?

    • 1 C+ j* ]+ t% \; O

      " n: U/ i0 {1 m& Q7 P3 x0 \+ Nvoid prt(char algo)  
      ( n$ r7 u. ]5 U* f
      - C; `' @& x  E

    •   v, g; y" O0 U* O
      : {+ m; x. ?! M' o0 Y% t
      {  , h# S  @% b2 i# V

      : j' W2 `! {  @& g8 f/ ]# }

    • ' v' Q+ t" _9 D; J# s: G$ H% q

      2 y  \' `( b, m- [# i# U$ ]  J   PCB *p;  
      ( r/ r7 i. D3 [) C- f$ s8 d! ~0 {6 a
      - w5 |* b. `" F+ Q" Y
    • - a( J7 R7 \! P" _4 i
      " i0 A0 d* y! W% N/ u) D# ?
         prt1(algo);  /*输出标题*/  # r2 M0 ]. a( K5 A, g3 C
      0 V9 ], s% @1 i( h/ U& h

    • # z4 I4 r% ~4 c7 D& n3 k
        W6 s) q7 a  {& l+ a
         if(run!=NULL) /*如果运行指针不空*/  
      6 H1 l/ y7 ?* V# K3 L; u
      6 d" x3 E% [5 s% Y# z9 K
    •   Z8 h8 u' ?1 I

      $ z: |: i5 G- G$ n  I6 K      prt2(algo,run); /*输出当前正在运行的PCB*/  
      3 N6 z& f9 t# e+ h5 n
      # \0 q$ n3 k7 _% Z7 o, o# V* `0 ^9 u9 g

    • ) g4 s& K8 S3 C+ c4 K8 g: P2 n3 z

      4 m  M7 g. r: z7 `" U2 \: u8 ^   p=ready;  /*输出就绪队列PCB*/  
      / ?( J% N. {& q# B5 ^
      ! \- M, p- r+ v7 K; M9 I' U
    • # u; M/ G- K+ H

      3 Z  a7 n3 C) R, T3 @( Z  S   while(p!=NULL)  
      & N- ~% L. k7 U
      ' B  p" U, Q. u/ u5 m3 D

    • / \6 b- ?! x: V% w' N) t

      # ]$ Z' J4 X7 R   {  
      * `) T: J8 |" l8 S* B4 d
      ! A4 ?# s' Y" N3 s0 x
    • & e; M6 y* K7 s0 `0 t
      . n" j3 X( E5 y9 ]/ o
            prt2(algo,p);  
      ; m$ T9 P3 o. E& `' p# L

      2 X; G% }" j3 {; G0 c! p0 d

    • % M& j+ b8 E4 U8 |
      " r! ^# ?$ R2 q, L* H8 p/ D- \
            p=p->next;  
      # o* A. [8 K/ W9 W1 A- g  q  L4 I
      . U: V8 Q0 v3 J- ~
    • ! D; k4 B# N" u" U' h6 n  W# e
      $ f; Z& T1 d$ T2 X
         }  
      8 c# Z4 {/ X! D2 w: z
      5 z4 q: A) C" j7 E

    • 0 e; u7 B. _: w% H- _
      & [" k: F5 B+ B! A# {; H+ n
         p=finish;  /*输出完成队列的PCB*/  
      : q  r* k. Y& {$ f! m
      # |1 m7 F3 j3 L: D5 ?* ]" x

    • ( Q# \7 `) @! ~6 e& W' h# e

      2 K1 @1 [( z) |8 w0 i" j   while(p!=NULL)  
      ! t. u- U& O* I' |* v- J

      8 l0 S1 A- \3 h* t$ j
    • 1 w3 y# X' K1 M" t' r9 L' }
      ! _+ e) {" o. [& L/ J' |' W
         {  
      . I0 V1 a1 o8 h/ A4 X5 l. X( `) W

      & y( k& w1 ]! D- `- g' T1 b

    • $ g+ }& J, P2 Z4 y+ E2 Q5 T
      " s# O# E6 e+ O. l. c; L' C
            prt2(algo,p);  & I- z; j- J. ~4 P0 \
      + w2 c2 S4 r: S. f- m

    • ; g1 ]8 h& `% d" p! g, S9 D# w4 C

      : `7 e) j; k$ q( }( H/ M4 P      p=p->next;  ) w! f: |+ a' M1 l  W

      / U1 d2 q! L# P* \6 Q
    • % w, G0 P$ z5 T
      ) T$ c2 E) h9 M" ]8 ^! n3 h
         }  
      5 j% A7 T. x5 {$ V1 k. ~
      - y5 u  \# B/ l/ E( `) v  d

    • 6 Z( X) K" m- z' r! L

      : {" i& i3 D2 D' p! ~   getchar();  /*压任意键继续*/  
      % g& L! P9 Q4 R; O

      $ x! S& v# K$ B# X9 J2 V' ^- |, a

    • . _2 |# T" g5 A  o; B

      ! `; L5 g0 p3 P. r) f. j}  8 w& S! j- D" V

      , G8 Z" D; _+ m0 M6 o

    • 5 k3 x+ U" ^5 A* l5 m
      / H: P$ {/ C7 d! e
      /*优先数的插入算法*/  
      9 b7 L4 O& A9 |7 d

      1 h/ ^7 w9 F* N
    • # H* I8 D' H. `

      7 f: j; Z! K0 U3 z' H- ?; rinsert1(PCB *q)  
      9 f0 l5 f" `; {6 @3 b4 e' V
      , `9 U4 h; B, V% u, J0 z
    • 3 R1 j0 T# [5 p* s( g
      9 R+ V* y: f, O5 b  p' Y. N- u4 m
      {  : V7 A6 e1 D* q' X# n- B
      " v9 X3 b- y* o  l. d9 e" V% {
    • ' a% E- A$ k$ @3 S8 j! w! I! m
      / t; B8 g8 Y1 b$ c
         PCB *p1,*s,*r;  
      # |4 L) t' P# f5 C# {* {

      4 a) B2 V! o5 {" G
    • ( X2 u1 Z$ e, I+ g% H0 Z7 |$ J4 h& j
      0 D8 W0 N' M4 a  f! [: ]
         int b;  ( c% n! z5 {# D7 i# d8 t1 A

      4 a/ H( ?% I% @5 C
    • 5 Z9 v, Z% g$ \: i3 Q( c. q' A

        U6 |5 g6 d. p7 a8 H: F5 ?   s=q;  /*待插入的PCB指针*/  3 j# k1 G; S, i

      % `) T- Z% w* |$ h1 N' x) S/ l

    • & u& a0 b& `. Z6 `
      3 s# r/ c0 P" @
         p1=ready; /*就绪队列头指针*/  
      2 Y' C# v$ _$ F0 o# Y! h

      4 b/ u5 C: X3 l$ \5 Z

    • 0 O0 J' W9 j2 D, c0 S& W
      - M( s( \9 e, A: s; b- ]( ^& M
         r=p1; /*r做p1的前驱指针*/  3 ]: g- R5 p& a+ Y0 f3 h

      6 B: ^( t; q4 L2 P0 n

    • 6 t- {+ O* |! _. `3 U6 ^8 ]3 o" @
        |) F. x8 o* E6 j$ b0 Q3 p4 U
         b=1;  
      $ s5 I0 R. h5 \7 ~2 W

      ! L8 A% q; w6 h* g! I
    • / b2 E! t  O  t8 C

      & |; m; C' ^  j   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
      " d; E  A: S9 I( w& \0 ^, D

      - h% ?4 W% \* p$ K* F. \

    • # V7 W& J1 j9 z
      / I& M9 C6 j# W1 G3 |  p
            if(p1->prio>=s->prio)  $ J6 ]% [, P) f6 ]  @! w
      # H: p& g! K6 g

    • ( G3 b0 F& z6 m9 @" D8 ?

      4 Y0 f$ k0 l. L8 T4 s2 Z      {  2 k3 d( k6 l. y% [; y
      + H: ^6 o- u2 c( \

    • $ T+ y8 [% d  A

      , `% N& G$ ^( S7 c+ U- A+ n5 W' i     r=p1;  
      2 o! B- d7 G/ J* n( h7 ~) ?
      * m9 l6 K  v6 F& L$ [* f
    • ! m2 p: H1 G  U% P
      7 @& f4 L, j9 g3 ^: s
           p1=p1->next;  ( X7 Q8 K5 w7 J, b/ ~9 A; }' g
      # L( j: F6 {3 }) S

    • ( L) ^% g! u2 ]

      ; u7 A% Q/ I# U: e5 [      }  4 n) @5 |' [$ O" A( M" W

      ! B7 i# e( Y/ S2 V! L4 j

    • 5 E3 }! S+ N0 k- _+ Q
      + |' h4 H) B& k
            else  
      ( v+ ^+ t. r' V6 `$ Y8 a( d5 S

      + J1 ]# w9 @. V% x4 ]. H
    • 6 Z. ^( C8 w5 i3 S
      , |, s# g# O8 I% X
           b=0;  
      " `/ q9 `% J" W" I- e- Y$ ?, b
      " R- y& ~4 B! g9 _: _  x

    • % z' g, i1 r/ }$ _! ?- q
      0 g* Q: {2 \3 K: u! q* \
         if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  $ K. {6 o0 |; b& B

      7 c: L* n& J% t- f4 J; v
    • & Y; O5 n! K9 {/ h

      ' t+ l) T- W9 K. F   {  3 m% i- D* E, u0 e1 A+ L

      ; \- r+ j. T  D3 p5 @

    • 9 X% S( Y0 _4 p. C6 I

      7 h7 O; `" N9 N      r->next=s;  ; U( N% V) \" _" A2 z

      , U" M+ s( i* i0 i
    • / Z4 L  s5 [8 [! P1 @7 Z7 [
      & `' I( N9 d) k* _/ l5 Z4 o5 C- c1 `/ S
            s->next=p1;  
      * F/ R! ]9 n5 q
      9 n4 F# a$ w6 |1 `5 \

    • & D- I0 F6 B: w2 L

      ! [0 T( R$ p! Z+ o' y   }  
      0 b* L0 Y  C6 r8 u$ y

      7 U  r" q6 P3 B3 |9 ~

    • 1 s- @7 v' x; l& K- k
      & U, f$ v: }" h2 E7 y1 I* R
         else  + j, h1 r& H1 @+ Y5 W
      0 u2 s$ t: F  h- N/ j1 N

    • 5 ]# G" M* r4 [0 U
      ! }( H9 J$ J+ L; L
         {  
      3 e7 l; c3 y' o* W( `
      " C+ V- a0 c1 W9 `; T' Y

    • ! y9 E9 H, l: Z4 C: j, f
      , A) I( u$ r: U$ y; Q% u9 s
            s->next=p1;  /*否则插入在就绪队列的头*/  
      " d# o0 e$ |+ E  ^( A$ H
      9 a% x; b: u: f9 s) U

    • , v3 W0 x! s- S
      3 G% h3 p, ~1 R3 ?& ^( o' [
            ready=s;  
      1 \; M2 Z; m2 @6 I

      ! {: \  [& o6 y4 [  ~

    • ; a/ Q$ U  B; T

      # a  d3 O% n4 w   }  
      3 @6 |5 S  @  P+ s: G

      . W, j7 b6 x% R6 A4 k$ |

    • . O: }5 e: ?; e, ^

      % Q, ?' e. n! ]$ }+ ?6 ]}  
      ' x6 v' l# S* q8 Y- I
      5 l  {; D! o+ `: N  J) W) s
    • * D2 \, G6 |. N2 f3 k5 t& ^" T
      9 H. H8 Z- B4 ]% Q: I5 i, C4 C" q
      /*优先数创建初始PCB信息*/  
      $ G, k* t2 [& R' w* k

      1 N% D2 N6 a( t2 B% \

    • ! H) R$ i* q& o8 o  O! R$ B
      6 R: A* S1 y' W$ E9 g
      void create(char alg)  * e% a) H* V+ g( J

      % D  X5 M9 W2 C. B
    • - I5 l/ D' W8 [
      3 l7 Z+ ?; l- V' B0 _2 ?4 B& ]0 m
      {  
      9 d. o& k; U8 W, O% x3 t

      " X% p8 T; G( d
    • 6 A! e# h3 S* r+ o$ J  j0 E6 Z

      5 A6 m: O2 u4 ?4 Q9 Q   PCB *p;  
      5 z+ `( L& T7 b

      . }% a9 Z3 l2 n" f8 f9 i' K
    • , x+ J/ x; X7 U, Z4 G  u. c/ z- \
      2 C8 h' V1 y: g1 @6 D! Z" N- M
         int i,time;  
      : m# X3 O8 d9 b

      $ \: N' o/ J/ |$ z, }
    • 5 Q2 w. V5 m- m0 b2 h# F- g" a
      1 \( s5 h1 J- A, N4 `
         char na[10];  
      , U2 O6 e8 U1 z; G+ u7 W6 q
        R$ e2 L; R, ?+ U

    • + e2 F$ ~1 h, v# |

      ; s2 Z. H* J" d' G" [8 |# U3 o   ready=NULL; /*就绪队列头指针*/  
      . y, u% c$ ]5 {+ @3 N0 f- A3 _
      / k7 i" C, Z/ F* C( n0 z) \
    • 2 x+ y; l" k3 U( [

      $ N  X, u: j% e( x- X" ^   finish=NULL;  /*完成队列头指针*/  4 n+ x7 p, h1 q0 K( c2 m

      ( R( m; c1 P- W7 u1 c
    • ' I4 f! k6 C! G4 l

      , `3 x/ D* ]$ W# r( ]   run=NULL; /*运行队列指针*/  ' [7 w" y. ]* p+ e+ P5 R' x% ?$ Y2 t
      9 n) P5 l' W' r

    • 4 v5 A+ u$ S- O5 J1 Z" Y
      4 P0 v! I+ G# B' Q8 G5 a4 r
         printf("输入进程号和运行时间:\n"); /*输入进程标识和所需时间创建PCB*/  
      ; J3 J9 q# l" e  `

      2 a% V( L7 a5 s5 Q

    • . @, S8 D$ i3 ?' H2 Y4 g, H

      7 h2 R0 y) B) W9 q5 {3 G8 q   for(i=1;i<=N;i++)  
      - \( D' V7 e* V" q2 E

      6 I/ M' Z$ b) c  p+ R2 o
    • " {' ?8 h7 u9 t! i/ u" ]" k
      1 l5 y* h, u4 b
         {  
      # k- F3 a; X  j; }9 q5 p; N, d
      8 f1 K# p$ E: P3 {

    • & C* B* d/ O; X, S" U
      / m/ g  I) V; j" ~1 D  y
            p=(PCB *)malloc(sizeof(PCB));  ; O5 A3 R- x7 P# X5 A3 A
      " P& ?8 r; x) Z9 f8 f

    • 4 `5 m. m6 W( X: ^
      * w3 v; E+ H. }1 ]
            scanf("%s",na);  
      . M5 E: N( _8 l9 C. F1 }
      0 Z) a8 u0 B- Y& O
    • , Q3 j0 l" p0 I1 P  A( M8 d- O. T3 ?
      # X" {- {# B- D
            scanf("%d",&time);  6 j9 s% [1 s% z: b# _" l. M

      # n. r) C9 j+ e+ E4 ]& n2 c3 B  H/ R

    • 2 F0 d0 ~- R3 A8 O

      2 z6 B8 J/ L) v* G      strcpy(p->name,na);  4 S/ q- `2 G8 T  U/ |; P' y1 W
      5 T8 G: B; F3 X! M% z3 c
    • + Y* b* a! @! \9 G  g- M  {! `9 ^

      7 l3 Q4 x/ U6 g& z: N      p->cputime=0;  
      2 ^9 Y& m3 E: i' X, m" k

      # A+ q# T7 \+ E5 ~- z7 z" Q) R4 C7 ?2 S
    • 0 v  R& ]$ p2 D! x8 E
      . Z% z% A- A- r) b; j# E0 M
            p->needtime=time;  
      & j5 F4 Z3 j+ B. U8 }

      6 K# T2 C" j8 ~+ ~5 }1 K' |& m3 O

    • " i9 b! j7 v  e9 C" I6 {

      6 v* N, ~, G" ]      p->state='w';  
      * N8 {8 a3 F4 y; s8 G; n

      $ s" u' `; R9 ^' Z# i! L
    • 1 r1 z  Z5 B1 Q3 V7 m5 m9 k# v
      5 T  Z# v( M& [& i5 s' S
            p->prio=50-time;  8 m4 I4 t, x- l& j8 B9 i% m
      : L: I2 P* }) w

    • , p1 w4 r' C" ]  s7 w

      1 J9 w& _! p, S" S; ?      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
      , f9 l( ~0 N$ J6 k
      ; A7 ]; E7 v7 A' j

    • 6 E3 \* c8 C# k, P; l0 `
      5 l6 m) `) \: S; p
           insert1(p);  
      ' U1 Z9 p$ ]6 u/ ~* N5 T
      6 v2 R. K2 y' P2 {/ `

    • 7 C4 w5 [' _& T
      2 o. h/ J6 U9 c
            else  
      ( `2 K# I; Q- W6 L1 n1 I

      , Y+ \4 p( v; P8 F) X
    • ( Z5 d( _  y9 A2 |; Y; C
      & Q+ O( ~+ v( z! n
            {  
      8 ?9 ~+ l8 y5 _5 b) {8 s
      % I3 s, x6 b( S( a0 L' R

    • ! e/ Z. M3 J- x1 d

      5 K% D3 S9 ]6 U' J" @8 N% C     p->next=ready; /*创建就绪队列的第一个PCB*/  
        h7 }2 g& x7 h+ m
      * Y* y! g2 r4 M
    • 5 ?/ c1 p( g7 w8 D6 g+ ~0 m8 H4 v

      8 z) V' R. D" m% K# f     ready=p;  
      # D6 B7 E) T0 M' [
      0 k$ C6 Y+ N5 r7 ?' ~' x6 m

    • $ R2 }" ^* W+ c' \" C! \
      / ]. G: Q* y' p! s5 L
            }  , O4 |( N& S8 @7 C' p- C

      . H1 G. k6 H# w* A
    • ' q  d$ m7 H8 g) ~: a: ~$ a

      8 O% o7 `8 Z$ k* \! V   }  + Y2 a7 i# t9 l9 a' t9 W  `

      1 f+ O6 k$ c3 C/ q/ x

    • : f8 `2 J2 p( {* `7 A) `- b9 Z# P+ U- g

      . ~' U* v& m/ i+ F* b3 u) s   printf("          优先数算法输出信息:\n");  9 `% G: `- [- N0 @

      9 a4 a) J% o* W( s  l

    • % b+ O+ K0 W6 _" N- ~1 k
      6 B2 J  ^* E7 g
         printf("************************************************\n");  3 I# o& \7 G. B  Q& \
      % Y+ C( D- J! b  z4 J" O3 t
    • ! A! S9 S" s/ L  f/ X  g% a/ a8 m
      & `) q- T9 ]5 a
         prt(alg);  /*输出进程PCB信息*/  
      & y8 x5 r+ ]6 ~3 `7 S- S6 I' u1 w

      3 ^. z% {7 c* R( y# k
    • 0 N  Y& h9 R1 s5 m; K
      " W' i+ P0 [9 U2 z; J' Q
         run=ready; /*将就绪队列的第一个进程投入运行*/  8 T+ W* t( O8 z$ c

      % ?3 ?7 h1 _5 n

    • 9 Z+ h- b! A( s) N9 t+ D
      " s3 t9 y1 d2 ^1 E! k. M
         ready=ready->next;  / q1 ~; B' h+ `. n+ W+ ~, Y- W

      2 a  C. o1 d4 e: D+ G; N

    • 5 O# i& |' j; q* }
      ! b) [4 R# t+ Q5 _% p
         run->state='R';  
      ! O+ `& a, r( X, w/ I( u

      0 I% b: a) e7 C
    • / V& ]7 C$ H$ N; A) v1 c4 ?. L
      * r! {" V/ k1 }  z' Z- a
      }  
      5 Y; W; Z' h5 v4 }
      5 B2 f0 m4 C: \' @: q
    • + d0 u4 h3 I( h

      + h6 W! P/ ^9 M3 Y/*优先数调度算法*/  3 i( L+ _: U. N9 h" ?8 v
      # h* R8 q/ C* L7 G6 |5 ~

    • . u: T' O+ z4 m  ^: G5 [
      3 k# w, F1 {. x9 x
      priority(char alg)  2 j$ U; z6 O5 I& i
      , y/ a- B3 E* J* ?) A8 e
    • : L; q' B3 r( p$ |6 `
      ( V: I4 X( N8 w* J
      {  
      ' K/ r1 l8 K- a- \
      ; N# e) q. i7 E( f0 D% V& V# P
    • 5 F1 ~: L! k! ]' ]7 b5 x
      # ]& @# y% f! ]" m7 [2 V
         while(run!=NULL)  /*当运行队列不空时,有进程正在运行*/  
      ) l# r$ u+ `: Z3 i6 C9 o6 \/ y2 V
      . l  s; A5 C& s' ~& o

    • 6 [$ Y( R- L1 Q+ E2 J
      * K" u+ |9 W$ k$ n5 o
         {  
      % x! E! P" {  H; ?- m) F, h

      5 d1 `5 E" Y- n" g! Q2 Z

    • . U" q# n5 h4 _4 L9 I/ V4 K

        Z) V& M; H6 b4 W* X      run->cputime=run->cputime+1;  " g% e  u- g# H/ m9 w9 ]# y. q
      5 q) t+ f; I5 m- u2 Q4 u

    • $ g0 }" |3 {% \& V5 y8 K$ B- f
      " q: m( q9 B1 ~; Q6 z
            run->needtime=run->needtime-1;  8 V4 F' y( v4 j9 e4 j$ w. l1 {
      2 M- b) t' h$ U# x' F! g5 z" I, g9 G

    • ! t  A2 q8 M; ]2 Z' u7 o

      $ A' ]8 n1 ~3 q" u      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  " S: h4 R' ^- v9 O: z

      3 K9 I: F' Z: T. h( e
    • / k# x% ?) u0 w: P* g; L

      1 L5 Z0 p' D( Y1 j      PCB *p;
      + \0 n, w* F( Z6 E2 q' j
      2 T6 P2 b4 X4 y) w$ ^

    • 5 z4 I( O0 {% _7 r

      ' |/ O% @( Q. U7 R7 X      p=ready;
      $ K3 S# [) `% Q! ]
      9 q% K7 H0 p8 u- D" C4 S
    • . P0 c. K: ^. ^4 [, S/ Z  d
      3 H: G3 ]' m: R* N6 m
            while(p!=NULL)  5 T- u4 A9 c" c
      6 c9 ?3 O; t2 E& d

    • + D  z4 t5 `* p6 c
      / R9 c3 f/ E0 a' K
            {  , V) D* \0 E" Y: f  J& S' w& ~
      : R5 x$ N* c1 b/ M: \4 C0 q

    • ; y5 Y: \: c$ z# K: W
      3 u4 T0 [. [' S& X0 j+ H
                p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
      7 ^4 d4 C. F0 N; E, z1 D/ h
      + G& a) S$ E; \% h7 ^* |1 W

    • * t3 k2 s/ O' Q; h

      , }$ H7 |- q# P5 X, W          p=p->next;  
      # l, K# l, {2 q; B4 q0 |
      1 O8 X  v; y! X6 U1 k; r* @3 k

    • 9 G8 ^/ k4 z5 w0 a3 f' y
      % n! \9 O2 B$ u+ I/ g7 {/ F
            }  
        {& r1 m0 ^5 X. K0 v1 K9 m
      : I. u! k. I* b# E4 I# |" L
    • 5 X4 C5 ~: A  n/ Y' W

      + f  f. y. u3 Y, X' `; Z      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
      " e+ p* \6 L) t$ I( a. O7 X$ I
      ' f( T. y( b! x8 ?

    • $ N$ n' f! Z: |

      7 Z; p" q/ _7 j. Y6 I      {  
      $ F$ {( w& o* Y1 B$ a0 j5 p; p- r
      2 j& Y" ]; ]8 p( A" M5 e; h

    • ! C7 ^: W/ z- \! b3 M
      + ?5 B& A9 L* d: h6 d
               run->next=finish;  
      * c! q6 x* |& F8 ^8 h

      % i! L% t. }) [
    • % P& w( ~+ H  U( M
      7 x) g/ ]" T+ C* E1 @. f
               finish=run;  ) K# R  y: j9 k, J
      . W1 Q6 F: R7 E- }6 G
    • 5 q/ m& h' x6 ?  e" }- T0 ]8 v6 q

      . C. ^- t; Y; w# L         run->state='F';  /*置状态为完成态*/  
      ( ]3 p4 K+ F3 [( A( }" U0 D; F

      ; i0 i0 F4 y& H- j, I
    • ; e  U/ m- Z7 I3 e! k! u8 p
      * _! C; u, h+ [8 R
               run=NULL;  /*运行队列头指针为空*/  & u5 d- }- {4 M, @
        F( p$ N$ H. N% c, S

    • ' O8 l) m. l/ @% z. V0 Z8 _

      ' E# f* c) E9 [3 J" S) b  `         if(ready!=NULL) /*如就绪队列不空*/
      ! }9 C% J; I' m2 ^
      " l$ ?- ~9 `4 D! |

    • ) n! l! a! p9 q1 z7 j, L
      & o' X, Z8 e7 a" q) D
               {    Y  Y- A% T: M1 Q1 `) @

      9 p4 S$ P" w& ^- Y" y. }1 u
    • % N! q& q; e! ~  I2 l
      ( u% A4 t( A0 z  p* f# Y/ j9 }
                  firstin(); /*将就绪对列的第一个进程投入运行*/  
      6 j- O& o0 \  F& a8 M2 g# q

      " T- b/ ~0 V; f( ?1 E
    • 6 P( N: p/ d6 |6 Z6 V. e
      # D, U0 R. {2 C5 o" c2 ]2 D" v$ S
               }9 I: U% x- p% v2 B1 P
      1 H( c3 _0 @) A! T0 p4 b! y, x" B$ F' @
    • / W3 ^; ?6 }$ ^" _6 V2 T7 B' z, A; ^
      8 v- G5 ^* z/ ~* s/ q
            }  
      * U, R- y0 {1 y8 K2 m: h4 A8 Q

      8 `  M$ u% n; c) a9 Q, A, D# s

    • ! G8 q* I3 q1 C

      5 Q( A9 d6 V  r1 B( R; A# G( U# z      else /*没有运行完同时优先数不是最大,则将其变为就绪态插入到就绪队列*/  : U* D; X, s* c9 S( G% Q: W
      0 j6 x0 A9 a. u" i9 y7 L! b8 ]

    • / A. v$ _+ u3 `
      : ?4 @" b: r8 N) t/ r5 T% }
           if((ready!=NULL)&&(run->prio<ready->prio))  ( H* G, Y7 W% h5 U9 d2 m

      ' [1 S5 J9 ]" \" o  s" L1 p0 F# i* q0 J
    • " k' `% \& H, Y1 h. H( R4 p

      2 X* x. v% l9 r% m2 Q     {  
      . I) ~: [4 x' j' s" e
      3 g  g- K4 Q+ J
    • 5 O- s8 Z. G9 N4 h. x
      6 F  j$ J, G; t& U- f4 \2 v3 `
              run->state='W';  + ?( T* r3 l3 m  }4 B) R; I
      $ b; w* Q7 d) ^' [4 o; i6 [
    • ' }- I  a( a5 X8 ~. P
      % L. S/ |+ h7 A1 u( F. H. _- N* a  I
              insert1(run);  / S# Z* ?0 A4 F
      ! N# f8 k' R, r& H) o1 w8 g2 D
    • 7 E# w$ U* C2 J/ l. t

      ) J. D( S* W( a4 R1 g/ [        firstin(); /*将就绪队列的第一个进程投入运行*/  
      ' K% t, k, W; G# e0 h
      8 Y' q- L# L6 ^" R

    • * e6 y0 a" }+ r. b  o5 K

      2 U7 I) G( C3 X, L     }  $ H, W& ^- Q/ N* N. x# e

      % \  X3 n* m3 G2 z  r: @

    • 8 V8 P' I2 p+ U1 V6 t$ |

      & N! ~: ^1 q" c& s: X2 U# k3 \      prt(alg); /*输出进程PCB信息*/  
      & s% j* [' T  |
      ! ^# @+ s7 x) a( A# }* k3 i
    • ) D2 K  \- d: R' c1 h; c0 K% \* G& g$ k

      . P; A4 d: J8 t" l  ?9 W   }  ) Z1 @. W$ ^$ r" F  M  x
      9 z/ b" S$ P' r1 D
    • ; F7 w) z& y$ b

      / ^. T2 |/ W; S}  
      % e4 _& [1 |3 h$ X* k/ X- p$ L% n* S

      + H* d8 V5 G& `* [! J3 \
    • 0 o5 J9 @/ g) Z8 q3 q- O

      & L" E# w/ w1 t' j/*主函数*/  
      + b/ _8 s9 T3 ^8 m

      * M0 F( t2 `% A' f" e
    • " @4 c3 z4 t: ]6 t6 ^& q" y

      # j( T. n$ ]! C' P- L& i, omain()  
      & h7 C# o* K- e8 h7 q2 i3 ]
      # U3 A- ?5 A; T5 p, v/ n2 G+ F0 J

    • 1 |3 H) m* m' R& i
      . \9 ^% M: z5 U  X$ U) q
      {  4 N8 B  I' o5 W9 f  v
      & P0 v; m' U( Y: s5 @3 j' q

    • ! }- G% G- ]0 _
      , J, h' G8 e+ e
         char algo;  /*算法标记*/  , v# o0 M, S+ z4 G

      ; ~+ L+ w& f0 x/ {( Y/ @/ d$ m" b
    • " X% K" _  }& r

      . }5 Q* ~" P+ |   printf("输入P确定算法:优先数算法\n");  ! I( Y# V5 h9 x9 w" ]

        i7 P% [1 f; Z6 P9 Z& \
    •   E8 e/ j( U4 e9 S& T$ X
      # H* d, m4 C" W
         scanf("%c",&algo); /*输入字符确定算法*/  ( y2 o) e( B" j! O- T" Y

        i# {7 w" q# [( k: G* S' A  z% S
    • 2 E7 ~% F% @9 J4 q

      # {& }* Y% d1 \6 g- J7 V   printf("输入进程数:\n");  4 ^7 ~0 C1 A! r/ t

      / A0 [! {+ e. N0 [+ u

    • * }4 I( w- q- }3 k9 o" D3 j

      8 [' l. V  l3 ]) x5 a* z; Y8 u' `   scanf("%d",&N); /*输入进程数*/  $ P' o" r7 `/ ^2 ]# }

      7 u0 l  K. ^3 z. [2 c( Y1 U8 k2 r

    • : n- d/ n1 C  ~+ j
      4 W% g2 k5 b7 `
         if(algo=='P'||algo=='p')  & w& O9 l# [5 w4 o5 |6 X

      3 y" ]' L" P2 T
    •   E- T4 W, o! s. V; a6 R/ l$ R
      - e$ n+ x2 i( s8 w! q
         {  % X3 I7 }) M: x% b+ k3 |% s& ]9 [1 d
      1 Y4 @% {( ]# v- a, m
    • * B0 v4 f/ h2 p7 x( K: Y/ C  j/ T
      % y1 K* R  ~+ p/ l: B
            create(algo); /*优先数法*/  3 I8 |2 i2 ?3 e6 ]3 M' m. G$ `

      ) F0 U6 Z- c2 U3 T' \; i# [

    • - N9 j* B( Z* Q: |

      4 l  [! E$ }$ v( J9 c, y( k      priority(algo);  ; }: {, s+ G' N' m

      4 [" x( p" F9 j0 m
    • & C9 m/ j& ]4 E

      / @! r0 _8 q* B   } 1 ?; y8 @* I1 t# Q# F

      ) F: K8 m' T; b, J5 F$ Y2 m* H( f
    • & @( I8 |( Z, N( c: S
      0 R0 W: s9 [0 p$ [: V! B
      }: |) b4 O4 |& y2 z0 I. p; Q4 {

      7 w4 S6 E1 b% M$ p: G
        S  S9 C8 w1 A7 P' ^


    . E7 ~! u- D. N( g; s输出结果:
    9 }& p- d' f; I! O/ Q9 E


    & E& k$ ^% Z; ^3 m) k# ]原文:https://blog.csdn.net/weixin_40962955/article/details/80072769


    3 q6 H( x: L0 J& ^
    : ^) J' O% e1 ?$ F5 Z8 c% D
    zan
    转播转播0 分享淘帖0 分享分享0 收藏收藏0 支持支持0 反对反对0 微信微信
    您需要登录后才可以回帖 登录 | 注册地址

    qq
    收缩
    • 电话咨询

    • 04714969085
    fastpost

    关于我们| 联系我们| 诚征英才| 对外合作| 产品服务| QQ

    手机版|Archiver| |繁體中文 手机客户端  

    蒙公网安备 15010502000194号

    Powered by Discuz! X2.5   © 2001-2013 数学建模网-数学中国 ( 蒙ICP备14002410号-3 蒙BBS备-0002号 )     论坛法律顾问:王兆丰

    GMT+8, 2026-6-9 19:15 , Processed in 0.485466 second(s), 50 queries .

    回顶部