QQ登录

只需要一步,快速开始

 注册地址  找回密码
查看: 3175|回复: 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
    - Q: z* j# f, \1 d/ W
    优先级调度算法
    1 O, G! Y; p" j' W

    算法介绍4 h7 J8 u% O1 c5 \
    优先调度算法的类型(用于作业调度)4 K4 j) P( i. s( M# L1 `3 R
    1)非抢占式优先权调度算法
    ' \5 ~# T% G, ?6 V1 A5 F- G系统一旦把处理机分配给优先权最高的进程后,便一直执行下去,至完成。
    0 l0 u; J0 ?8 L4 i! h* l* {2)抢占式优先权调度算法
    ( Q( Q2 l* L8 C, \只要系统中出现一个新的就绪进程,就进行优先权比较 。若出现优先权更高的进程,则立即停止当前执行,并将处理机分配给新到的优先权最高的进程。

    优先权类型
    0 J8 u+ d  w' C2 @% g1)静态优先权 - h( e9 q! G8 x' y4 D% p
    静态优先权在创建进程时确定,且在进程的整个运行期间保持不变。
    ' v3 d: J# Z- ^# s, ]

    2)动态优先权 2 L! h" J$ g7 C: B0 s; j) e

    算法实现

    抢占式动态优先权:


    # ]+ H' z& t9 J+ X1 qPS:本人认为非抢占式静态优先权没有实际价值。


    • ) M2 P, G' H8 z7 ^3 Y

      ! G) z( U& o: k& w/ a7 o#include <stdio.h> # F7 \$ ^9 U1 Y- O' U

      9 n. W! x5 F; \1 r4 ?0 j  Y. E  f

    • 1 f. Q, D, E6 G' \5 l7 X8 s
      6 r& I1 k& N5 p( L
      #include <stdlib.h>  
      " v' j0 Z" `* L  z& j5 t

      $ m- v0 i2 z4 S; \# C' N
    • " K3 a/ z* Q1 k3 D+ ^& }3 ~

      " A" _+ O* Z' e) o6 X9 x! ]) [( c  D#include <string.h>  # {% e% |9 _" Q# \; m6 r$ }
        x" l8 L+ G0 F
    • 7 T8 h1 R1 ]! x* k) w
      5 _2 E2 X4 S7 z. F2 ]& J$ a" I
      typedef struct node  
      1 c) I/ \+ @' A% d4 Q% o) S* _
      ' f( J( h5 m- T- O/ O+ s7 F5 S

    • & V' z' L6 ^& ^' B/ _
      3 k# a, R1 r! U4 W% ~
      {  
      , Y+ b. h; g- o) A7 Y* ]' K
      6 c1 w. z; D+ B
    • 9 V0 V3 a8 V5 |* V5 `# V

      ( e7 J* {$ f4 f7 s( w   char name[10];  /*进程标识符*/  $ S' i' `; p/ d7 d( R) S

      4 W& c% a, [( K. r
    • ! G! W4 A# v  U; I" @- H
      % e2 k. ~: z! T0 Z0 J
         int prio;   /*进程优先数*/  % ~/ v9 Y  ^7 e: C, W) A
      $ o1 i  B$ T, r) z$ R/ L; q

    • ; ]  w0 @$ ~* G. p
      ! t7 [( m( P9 I% D
         int round;  /*进程时间轮转时间片*/  
      & U" U4 S8 |+ ]5 C+ D1 _# r

      ( J& f, B# y) V  C. O, m

    • + ?- E! i5 V4 P3 [0 O% y

      ) Z# p4 J9 s* g   int cputime; /*进程占用CPU时间*/  
      % ~' e  X) n. z1 n7 A% |
      % T* R- X9 z, }
    • " a% k& \5 n8 z, {$ \: n  g' z
      & Z) Q4 p, Q. Q
         int needtime; /*进程到完成还要的时间*/  
      , D$ R. _6 c/ }) d1 g( n3 V

      - J" o  @) C1 ^
    • 0 f4 Y- j- A" o2 |- n/ H
      ( I0 m& |2 ~% K/ \# d3 n( D# G$ \. f
         int count;  /*计数器*/  
      / b, x$ _5 f0 e/ m# k

      7 w- n) j) E+ U2 \

    • / G$ S/ o0 V+ ?! {) E3 @0 ^" J
        M' A* ?) A2 t2 J
         char state; /*进程的状态*/  4 ^- T6 n# v; R  o( G
      5 \8 b& S9 u4 x. U0 O# n
    • + ~+ \: u/ a' l6 G8 ^2 Q

      & J$ ]% a+ P% H' R# r) L# W   struct node *next; /*链指针*/  
      ; s6 G5 _$ |! V& d3 M
      9 }* a# ?" @3 k

    •   Z! L* q1 j- k( l% ?1 c
      # A$ t( _5 G' l& M) x8 a
      }PCB;  
      * K' `# ^5 v  K. |, z
      % r6 {2 U1 d! ~+ z  G

    • . d+ l5 _% J7 Q' u

      ' D/ ]5 K0 ]. O, M0 `) b0 VPCB *finish,*ready,*tail,*run; /*队列指针*/  
      ' B; D- s/ U' r2 u
      + [  l5 g7 G/ b* F3 W! b9 _0 g
    • ) H/ O! Y3 {' y3 v: G* M4 S
      / F; J- a" B8 {0 V- u0 E# K
      int N; /*进程数*/  ! y1 Y* l5 [/ I; E% b+ y

      " v; s8 `# v2 L7 |
    • 4 l7 i$ L8 [$ L% S/ `4 c# g

      : I) \! g7 w0 v* @( f$ [) j/*将就绪队列中的第一个进程投入运行*/  ! ]5 E* Q# f2 v! t+ Z. v1 H

      ' X: W1 G: @( e* M7 e

    • + a8 D" y0 }1 _% {8 K' y  s" J
      ' {) J$ j. \' U/ z& a
      firstin()  
      3 o+ I* n" k# }2 W& V; i$ K

      * M; u) E& J4 }7 ~! f  a* f# A! _
    • $ _2 H  f9 f1 M6 h% ~- M1 h+ t

      # a" o8 k" L* j* Z( ]9 N{  
      . T, T) d8 m* q' z5 d
      * ]' s( G- [  s9 ~/ a' s
    • : |1 ~8 b* ]( {

      / @4 [" B9 e5 A. n7 E4 N   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
      + ~' X* X) Y2 _9 R

      9 @$ _# s# |+ x3 y' J6 L  ?
    • 5 a: G+ t  P1 g' Q" E
      5 v. x) j9 X# v7 C" I
         run->state='R';   /*进程状态变为运行态*/  . l9 F9 K- n3 t6 L/ u, j

      # a) ^! t6 b3 N

    • & M" \. P! s3 t2 G# O4 c
      ; }7 k3 H8 d' B" u, ?8 q( f
         ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
      $ h& j5 j+ B) M1 C$ g8 D

      ( q7 b  \( r5 p+ W3 N- B" D4 D
    • 0 x* W) ~6 U) Y- s5 ]5 D" J

      ( `( w' P0 Z0 k}  
      $ T- E- P9 u0 j
      . t0 ]' u* l' [* I" G: I3 w* _

    • 2 ^7 }+ y" v2 f
      8 Y& D9 a4 L8 o* w# ?
      /*标题输出函数*/  
        q# Y& X$ O' ~
      / K* U- s) g% I* _1 Q: u8 i

    • / b, @* F6 p: [; q/ m" s3 R3 Z# O
      % ^- M8 ]( b' D: c8 I) {
      void prt1(char a)  5 B& e; j- P, F% U
      7 _# E) X" u4 g2 N# p5 Z
    • : {4 X& u* v5 f7 r! x
      , V8 H3 X$ y# B: ?6 l' H2 ^. Y
      {  ! y& L) v, `0 c- Z0 j9 B( P
      6 O# l6 v5 K; x3 Q& t

    • : @4 T2 B0 D. Z& y, f& ]; J
      6 V3 R4 i) B5 c* ?7 Y, K0 k+ b: g
         if(toupper(a)=='P') /*优先数法*/  
      1 G9 Q* T. I% e' |* q0 `, z* _
      5 q4 I: t" e# C, g. g3 i

    • # W# ~! `, X7 d7 H; e
      , R' h8 r4 |5 R! m) S* ~
            printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
      5 m, @  O5 d; S" m$ q+ i8 \: p2 ?
      - N# B: \0 q6 B

    • 4 x# u2 V8 v7 m

      ) H* Q2 Q& i& H7 _! v! t4 W   else  ; L+ r6 N. q5 t7 N

      $ Z" Z3 [* [7 A4 ]- N3 o4 L

    • , H# W6 V. l4 k3 X
      ! g9 z, a& |, d' F
            printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  + f0 @0 o9 w$ L$ o& ]; m; B4 [

      + w- p( O  T; d5 L3 W, F) x/ |- b
    • # }8 T9 `  x: R. \& G' d

      / K- g* X9 K  l! @}  , }$ a' j) l) T5 I: }) T# a

      6 A# I7 B7 E/ x* I4 v: [$ L

    • - m3 @7 K4 z7 [3 ]

      3 @: F( V& N2 C- u, A/*进程PCB输出*/  $ r6 K/ i- D( b& U
      0 X3 m& T$ [- \7 ]' _

    • ( ?. b) ~3 s5 X+ M: K& w4 m

      7 a5 r( Z2 u' s& @4 ~% U* qvoid prt2(char a,PCB *q)  + M0 R' M4 ^) P( V/ U6 \- q- ]
      ) u0 b, K& O' n) W% S! I
    • + W. F/ i9 Q9 ?- }9 S
      $ M: ?2 V; [4 w# C& y$ B) q& m
      {  
      4 h, ?" B+ |3 s, _  u2 D/ O
      0 p( N* f  b& E

    • 8 v, o, }1 _# R# G: O1 S, e/ B
      6 L8 W/ A# x3 j2 D" l
         if(toupper(a)=='P')  /*优先数法的输出*/  8 u. W2 K) y1 }9 K4 T1 O: g
      ) m3 ]4 {, b  g' e) H) a+ ^" T- x

    • . N- i% u/ x3 t0 b. f

      $ s, t, \6 @& b# U1 j1 s      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
      ( h. N' y( u' ?0 i' Z6 k7 ~

      # u4 x* G9 Q8 O8 m! B( C

    • + i/ c  F6 z7 B/ b* Q3 x1 B

      ! j8 D6 @7 O2 b       q->cputime,q->needtime,q->prio,q->state);  
      * K8 U* Y4 P5 u+ J5 O7 Q# h( m5 M: L
      2 Q* G: n0 h  G! a% M

    • $ `/ F- A: u: T
      1 |' Q# J4 V8 h- K$ Q4 ~6 n4 M
         else/*轮转法的输出*/  
      0 x" q/ `# l+ k5 C- I  j+ ^' a. c

      # D0 H5 b9 o8 \& h) E
    • 9 L3 v  K6 L9 s0 |$ O2 a
      - p1 W- d3 o! ^
            printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  ' R% C6 u8 g7 S7 Z
      / E  |9 W0 Q) i9 @* V8 ^+ E

    • : ^( O7 ]; c) c8 F& H
      * }) \' G0 f# _) a) U' Q
             q->cputime,q->needtime,q->count,q->round,q->state);  2 m- Q7 h" A! R5 c# c

      # N1 }6 c5 c) [1 J) }0 m

    • ! [! F0 G0 S) Q& |" p# I. `: p( P
      0 X# x1 F) I5 Y+ B4 W
      }  
      ! _2 X) W$ Y. R& U' A/ j0 v; d

      - \4 O2 l; D+ c2 R
    • ' M8 L, L0 ^% _7 u) I& J/ F0 O) f. i  o

      ' }% g  Q9 y8 H0 s: v/*输出函数*/    _+ t. E. l8 z, u
      * I# X2 C, r9 D$ k
    • 8 b; H7 Q" |- o$ s4 L
      ! m0 ^( z2 ~6 e+ a" h; m+ ~; I7 K
      void prt(char algo)  7 H' x! o  D% i/ n- o# O9 K2 F" B

      5 Z% t- z' m, w: M

    • - S: ~. B7 @7 I- a4 |' r1 ^
      0 ?0 |) V. W& I
      {  
      # [/ @* \9 {7 X2 s1 b" j7 b9 I. _
      2 q: ?: p! d2 o! @" J) ~# U

    • 0 r! T  f8 q) S# r7 L  Q- C

      & ]  j6 ~3 f' N4 w3 c) p( }( K   PCB *p;  6 O: B: }/ E, |) x4 a
      ! a5 h1 u% r7 j  M7 a# t" T7 ]

    • - q1 E' D$ @* Q7 d

      ; z" b4 ~& k; W* m   prt1(algo);  /*输出标题*/  
      1 D: k  C3 v! i  b6 J; `

      ' {; o/ H5 |% Z' b$ `, {# F
    • : A( p. |- f. l6 m9 E

      - K, `) ~, X9 T2 X3 J; |   if(run!=NULL) /*如果运行指针不空*/  
      ( e$ N0 L7 `. M, C& P" `9 Q

      ! K+ M" _  R. w; V+ h4 N2 S7 a

    • % u( P/ c  m% v3 l( G# Y

      " f: C) D% d0 T- a      prt2(algo,run); /*输出当前正在运行的PCB*/  
      * k* F1 c; i! M9 b% x
      ' r/ q& }, t  I  v7 f+ x% J, U

    • / z# J$ k  D; v$ b, \# A! }

      / P% `: Y: N( D   p=ready;  /*输出就绪队列PCB*/  
      ( e) z6 O2 G' n) t1 e

      3 }. u! ], a& L* R4 J" t3 U
    • * F9 r8 r. D9 z$ @2 V3 ~/ A) M

      0 W3 k4 Q- `! d2 I0 w/ L, c9 X   while(p!=NULL)  
      2 l$ Z+ {: W# q( [

      & c8 E6 \; ?: p0 t; s

    • 8 M% R. ?( ]: U% F& k

      & g" ?8 w  B; Q. r   {  
      % t8 s4 f7 I4 f/ s. `

      2 D8 V+ ]9 o9 ~1 Z9 w+ |% ?" N+ }3 S2 ]
    • " l3 D& n8 Q% G1 S
      ' X- z3 u0 G' {1 z, ]
            prt2(algo,p);  : k. Q) S4 A$ ^9 h

      # k! T; r  k7 B3 p- x& u+ G
    • * }( x2 e) O1 X0 `8 U
      $ e5 p& b9 L9 l' W. i
            p=p->next;  : k. Q7 [2 }3 O* S% H1 b, W' y

      6 @, g1 m, C' F
    • ' W) X% t# r  N3 O8 G/ |1 Y, z
      ( U! O, j' }0 |! l. z$ I- l' B+ k
         }  " s- ~7 `" k  g$ ]4 I4 B: B$ l6 A
      % f1 N7 F2 H) E- B+ f

    • ! I# v  J1 s' m) t' t0 c( e
      % T2 ]: w/ a& W% y& p
         p=finish;  /*输出完成队列的PCB*/  
      0 F5 I7 x  \. i' o
      8 h9 l! w+ x: |! i+ N

    • $ Z0 x) e9 k$ M7 {$ F
      + ?% c& q# M% @6 o7 u7 N# n" d
         while(p!=NULL)  . u0 O( s( e8 p6 Q- U
      ; x4 R9 K5 d3 t; P. [' _- U  n; f
    • # {  Z9 N- d! D! l! k
      ) z% d  L* ]; p' F2 w, o  z! a
         {  
      8 n3 q# i4 _. ?5 G! h  r; w% p

      . v8 c7 @$ R! }. x- f

    • 5 ?( Q( l6 b$ q: F
      & {9 p9 G5 S4 b  L$ _# y& i( f
            prt2(algo,p);  % G& `, D" a3 w5 T5 l  Z

      ; z  e9 L! u: M- e0 M- u
    •   F- Q  ^2 w( x$ a7 t/ {. Z
      5 I8 e* O  ]; R  V/ f; B
            p=p->next;  ' _" ^! |1 `( T  E

      0 s7 q. G5 V" X$ \3 j7 G' _
    • 5 b6 ?% B. D  k' o6 p$ ]
      , }. Q0 H, V1 B& S4 j- e
         }  5 ]( k7 U" i$ ^% [) W9 L

      ; u0 a, @0 @9 A# ~( S
    • 3 Q. ~6 l8 P! L  N4 k
      5 A# y. [- K/ n. m1 X  g
         getchar();  /*压任意键继续*/  9 r# c) ?2 o' f, L5 h
      - g  M! {5 W* F+ C& H
    • $ i5 R" N6 k/ ?, y# P+ k

        Y# z. g7 q! G* q, A" V}  
      2 Z2 q' J! Z: k* J0 o2 V$ T

      7 L. h3 T2 c/ X

    • $ ?. p% G: |& H  |1 q, l

      . i* t2 a& j/ y: @3 V( B9 }/*优先数的插入算法*/  
      9 i2 u: Y2 |$ ]3 U2 k

      ( K5 u1 \; e+ c$ o2 V5 g! K2 Y# f6 W

    • 8 Y; {# o/ E# r+ L9 P- ^* |
      2 f- M7 Y# ~6 r/ R5 o0 o4 P
      insert1(PCB *q)  
      : r& n( o1 S; K2 {( b, L  i

      , J$ F# B* H5 t4 H/ h/ B

    • ' @6 W' m$ b- v6 [0 n! I' {& P
      & w! f! y. a- w' L
      {  
      # P) s! l0 ?! F2 r- s, p0 ^

      2 p. A7 R9 [: G
    • % _& w  `) R+ J- k0 Z4 ~* }+ I
      9 r+ o9 t7 d& W+ H4 u, r- q
         PCB *p1,*s,*r;  
      8 w: j* f2 `, N& H/ l
      ! m9 N6 A1 O2 `2 W! x9 T
    • ' W$ j2 Y/ `: s4 h+ z6 A5 S% P

      ; J, W( Q: b- g7 `( J& {" L   int b;  
      3 T; h( L* |4 n5 @% q$ x. P
      % s  g5 w7 R! D- u8 d

    • * {0 ?7 W" E" t, E3 x( }
      1 G: \$ o5 a2 T6 H4 k2 |0 G4 X
         s=q;  /*待插入的PCB指针*/  
      ) r2 ~6 ]  A$ g( q5 l1 }7 V

      0 E* q/ P" Z4 X7 `0 e
    • $ `' ^: Y- w7 N3 a7 n) e5 Z. {

      " G# D" x  B  o2 T+ N  J+ D   p1=ready; /*就绪队列头指针*/  " X5 |  L, x) |2 k0 S! U, X

        V- _4 _: R- A5 j. K! c
    • ) x4 g4 j( ~  A6 e5 X

      7 w, [) H) U3 D) b' ]   r=p1; /*r做p1的前驱指针*/  
      : A; o& n4 {, t  w4 E

      . E2 v1 o' x6 z7 b; Z
    • ) [# I9 V' q! o# G

      . i8 z6 j" Z4 q. b' ]4 K( ?   b=1;    E9 h$ M  S' o3 f
      ; I& j* d9 V& ]  Y; @: ~

    • 1 z" |1 ?& W5 p5 r# ~6 `* f
      ' d- K! b6 c7 J* ]  ~5 f! Q
         while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  / \  |$ ?$ Z& f* s+ S/ x, T# J

      5 h2 t  a$ m8 c7 \
    • 0 B; M; Y; h9 K0 Y

      ) u4 @% x! p9 v" g8 Y      if(p1->prio>=s->prio)  
      " h" e( l9 [, `5 G* m5 [; r
      : f4 l+ h% f3 s4 J; f# `: N

    • # z( N! C( C7 p; R" D
      4 J" a/ E  H. G6 p. P
            {  
      % ]% X: k' S% p8 x
      ( E( [: e: ^# L7 e. }- p) E4 L- P/ a
    • % n  n. q' p# L: Y2 X

      ' Y# O8 V! X# ?% @: i; @+ b     r=p1;  
      , b- j+ A3 g# r+ K* G
      0 T. E3 Q: {# I8 I. u, A  K! I/ w
    • 6 ]9 i/ P$ p% p" G2 j: e- L
      0 F( ]" j% |- d0 q# i) s7 e. g
           p1=p1->next;  ( [# c3 Z& r: E, X/ P4 i; ^
      1 S9 O2 _0 ^8 Y0 z9 b

    • 3 g* ~3 q" u) l+ k" O9 y) _2 L
      - y4 @2 z9 W( Q- |, ]
            }  8 o# ~' r1 a* T
      $ U6 n1 h; `. V. o

    • 0 a- P7 w  p# c9 B, \
        W$ y8 t2 I* s5 V3 K$ V* j
            else  
      / n6 n- t% I5 {7 Q

        O, e; k4 |& F6 t, n( U+ K
    • * O; M" L! A3 j4 E4 A1 U, h+ D

      % b# D2 k4 w. D" O     b=0;  
      : N6 o3 S7 r' h6 S3 m" X/ U" _
      & W/ f1 U0 o0 K' \, @# l

    • & S( Q; F% L7 A/ p# u" U
      : L1 W! v& V& d9 b
         if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
      8 p) s9 B& }3 @
      - ~9 J7 m& L; B1 k

    • # ~8 O* E4 h8 j% R" [% i3 @
      6 `! E* T4 A+ P, r- d3 e  h% V
         {  , z( V+ Z2 Z+ ^5 O/ [& o
      , E" F% t7 n2 B8 d3 u
    • ' S9 y4 c' L$ }5 _' o. n- v, t! i- T9 {

      7 r  ~2 @, P' K- I" c: j  ~- d      r->next=s;  
      5 a9 H) _/ C* [0 l5 a  n
      & E- Z# \, p8 b
    • 3 C) ]6 Q: n5 g( U/ J

      1 W: G! ]3 X! `) [2 q6 b* S2 P      s->next=p1;  
      , r* \2 \+ O( v2 L8 E" Y

      ! \  ?- L$ f/ Q4 H9 _( O/ c

    • ' r! F+ Y. M  m( w2 |0 w
      + w% ^: H% m. k" E2 ]* W4 ~. Q, o
         }  ; d/ Y9 r% r# J# a9 g0 R" T+ e* F

      $ r0 E3 B$ w' [6 k( B
    • + S. ~8 F, U1 d' C( Z; b9 ~+ f( p% R

      # |5 I& E% m9 D   else  " ~6 {7 Z! d8 j4 H- |& s/ l

      ( {' ]' A& j7 m8 m9 z% l
    • + r9 a9 X9 b. D, T9 X

      & |) I7 X4 I5 o& C8 f5 [   {  
      2 |. P% A( Q$ F6 F- [$ b" H

      ) `; m6 k9 y3 N( D* T, g

    • : c! I6 Y: J  m1 ^, g# ?$ e
      3 J9 }4 ~& |1 o9 f4 ?
            s->next=p1;  /*否则插入在就绪队列的头*/  
      7 r7 u5 _, v+ E8 n8 g5 H

      0 q8 }/ P; M& ~: B

    • * U4 z+ o' u, X4 h, l1 }$ S8 s; g
      * _# ]. k. Y: C$ X
            ready=s;  
      + O0 o+ x9 V! d0 s

      $ i3 D3 |7 o9 |) g0 I* K, @+ k" r2 n
    • 9 d* I  ?% p$ f. N- L3 y" t
      / I: l0 W5 `9 g8 R
         }  
      ( R( m- E( I4 T. x: Y& W" K9 ?, i4 [

      ( o. ]8 l( R& m9 \4 T6 c3 z
    • . l3 x7 Z. z% Q
      8 P3 r* E$ E7 _9 l$ T* A
      }  7 ^- f% ^9 B3 P. i; \- |

        _& H8 S/ ^3 Z  A7 O/ a, M
    • 4 a& _# v- B/ M( n. ~
      ! \, W! ~- n* N  n5 K" g
      /*优先数创建初始PCB信息*/  
      9 g  d2 Q5 N: ^! |

      3 n8 X! [# V! \+ j0 V2 w+ m

    • ; i( }0 I" h9 D' ~& \

      % _4 H3 r7 F# w( ~% u! b8 Nvoid create(char alg)  
      2 ~) |& ]. z: l

      , E6 H# f& b: N$ K
    • 7 F6 }- e" ]5 i0 }8 u6 e" u/ z
      3 |' @: P' Y9 y5 S/ v
      {  
      7 P- c7 x# v6 t+ F# V+ y( j9 K
      & N6 W& o; D5 T+ f

    • 5 p# K* q0 ?4 V9 b/ j
      4 @8 G' w; D# H$ p* W; j
         PCB *p;  
      ' ?7 A( p* b1 b; v" p! k3 W

      * u  }% G! |; w
    • : }% H+ v' ~4 }' i
      - E7 T" x8 ?4 B4 |' P  f; y
         int i,time;  $ m! ]$ {2 u4 f: t% l! s' X* ~
      : p; o5 h3 X0 _5 t: b1 f2 N% q+ o

    • 5 j4 u6 n& u! d/ |
      % l. G. ~* r" P  N
         char na[10];  9 T8 k3 n  x/ `, F# G5 Y! _
      ( _# n+ v8 e1 R& m0 V, E

    •   K. O  d, Y5 J: Y
      5 b0 U4 R' H' {. o$ J
         ready=NULL; /*就绪队列头指针*/  
      , b; G  `9 Z8 ~9 o4 P6 f( }, a& G

      1 h; ]2 m5 U; J9 \( E* T

    • * h0 H5 X8 r9 B

      1 `6 J0 r: f! C; v' S& B5 ^4 H9 `9 Z   finish=NULL;  /*完成队列头指针*/  
      0 ?8 g* v( J. Z7 S

      * d6 Q8 G- ]: [  E* Z6 ~! c
    • 8 `1 Y4 H. g6 |- O* n, K! Q. H

      , C2 _7 ]- O6 o/ [5 C$ ^/ u   run=NULL; /*运行队列指针*/  
      % w# W$ a$ g( R# S' C( c
        m4 z% O7 l' i8 |, p9 o
    • 6 W4 }( ~4 ]% g0 h% ?1 `

      , t2 j' i# R6 {& U5 o& i   printf("输入进程号和运行时间:\n"); /*输入进程标识和所需时间创建PCB*/  
      # r# q5 t3 z2 K4 H) j
      ) X0 @1 |/ n& X5 k6 t
    • # P1 g2 }& G5 u# R% w: T6 m
      # [5 J9 l( \( E2 ~$ D
         for(i=1;i<=N;i++)  
      5 b+ w- l; ^+ S  C# w
      1 B/ i" k, a6 Z# H" p4 N6 {, ?' l; D

    • 5 N; N! F) ~- g/ H. l

      $ I8 A( O. A) I5 G, |   {  ' a0 _' N4 N. q
      7 l" }8 Q" K# I$ y3 J$ |

    • 5 o; F' O. t" i) k3 N" C

      6 @3 f6 u, v2 D2 _: Z4 c& O0 c      p=(PCB *)malloc(sizeof(PCB));  
      ; w! o3 s$ s7 R  F7 B
      * O0 s* t; H" l1 y/ A$ E' D3 B

    • 7 @8 l9 H" @# V
      5 ]* I( T# D/ c: ]$ y2 W* U; C$ U
            scanf("%s",na);  
        O+ {3 ~. Y" v( H9 ~% k

      # G( J9 f3 O. ^

    • , T9 h  v) h* w

      . v7 Z* K4 v6 E8 Q5 ]8 m      scanf("%d",&time);  $ n: [0 d2 [* e, J# S$ ^$ z

      , F  \5 M! c, ~6 Q% a6 j& ], }

    • 7 Z' Y% p& o0 ?. i! t2 J/ W' K# {

      4 e4 q6 Z% L; t6 u" i      strcpy(p->name,na);  
      ) n( m" v) S9 [# `. g, ?& n

      1 Y6 X" H' _# Q) F
    • 4 O( N' W5 @* `' ~5 {! h
        x% F9 o4 b$ X; t1 \
            p->cputime=0;  8 y0 W, `9 j4 E+ F) ^
      ) }8 m0 [+ O7 Y, m/ ?

    • 3 \! p" i3 l! @4 m$ b

      & C. J% }1 [2 C: Q      p->needtime=time;  & H) {: w& [+ o; n8 B
      3 j/ x3 z$ C7 q, G4 Q! O% W6 i

    • 1 I; _. {; Z- K1 L2 e1 O$ D
      ( ]5 I. U6 A8 c- A% i1 d2 F
            p->state='w';  2 }* A/ @  h+ b% I
      * A) ^& h; @; ]! o: e3 M* N( E
    • 7 f; G- e. e8 I! l) ]' z

      3 ?$ n: K# B6 o- q4 E2 n. r& F      p->prio=50-time;  + C1 k5 T2 E; y. U4 x& p2 z

      : F$ S# a# F9 N
    • + r) w$ |3 N! y7 x: E

      7 w7 x2 J6 k2 w2 x% K. d& f2 _# j      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
      # |" m9 a' c: ~: W6 _4 B6 t
      2 e+ O2 p0 |  `. g/ x

    • - v: l/ H, Y, M% p

      + W# W# ~- |9 m1 v     insert1(p);  1 [7 F/ [- Y; [* K' |+ m5 ^3 E
      7 L% p7 b( c7 W& `' `( @

    • 7 ?: O* Z" c  W* F( t/ h9 z

      + ?+ q: m; _6 v  F6 \8 h      else  ) ~5 V0 w2 J  c# ?
      ; f) P1 e5 V( T. f( `% P/ d- q

    • . ?% ^; ^  @/ c, {8 v) [* w9 r& S
      0 c0 |' ]; Q3 [  ~, Y+ q) K, p$ @
            {  # p, u  u& J7 R/ D

      + ?. {8 n- [) m, r) q0 t

    • 6 F/ ^! `" |5 w. [. A  O

      0 [5 A: q  r( N" u9 e  _     p->next=ready; /*创建就绪队列的第一个PCB*/  
      ! R7 r/ ^+ s# J) C

      / e6 \7 e! O3 ~" V! M

    • 4 p8 b! s  R4 |; ^  W' Q% x
      ' |* i/ D. P4 T1 ~# S
           ready=p;  
      2 b- M6 n5 a5 l, ^

      - Y! Y% P# b7 l8 Z: \

    • 5 R' z) R- j; K4 b; s9 B
      * ^; ]8 ^' ~* B$ g5 |
            }  ! D2 A8 e% m1 e) v: r% Y$ v
      + Y  f8 f: D5 r8 q% Z) @

    • . q  E) I5 X1 y2 r

      ( s3 `$ g8 P. f* P3 n   }  
      ; ?" x! t- D3 G; t( n" w
      8 o0 _+ O. ?/ {6 d& |' H, |4 U
    • 1 G3 D8 _! \+ \- @5 `# N

      ; a# T# a0 h+ s   printf("          优先数算法输出信息:\n");  ( b3 z% \  S% I8 d7 K4 ?; `
      1 b+ `- V2 C, H# ^- D( W$ X, v' D" K

    • + m& x9 b- R4 i6 I! Q) I" C
      3 ^+ U# T' c0 M6 j$ l' r
         printf("************************************************\n");  
      ' x" B. ^/ o$ V4 k6 Q+ Q
      ( u9 d7 f6 S' d: z4 c# Q8 W1 n
    • ' ^. ^' u) ?( n1 D! I# p7 U5 G2 \
      # l' P+ l. S  `( v5 Z
         prt(alg);  /*输出进程PCB信息*/  
      & w0 D8 E# L, E. u
      * j1 O, p4 x2 g# I. u% p
    • 6 k. O% F) b6 B+ S

      + H0 ~4 `! ?' h7 \) \& \   run=ready; /*将就绪队列的第一个进程投入运行*/  
      4 P$ I# N4 b$ H; \7 Q, o
      % A4 E1 Q/ a9 a) Y0 f

    • . f3 i, e4 m3 P" [5 P" D' x1 c

      ( Q# [% w4 ]; {1 |5 u   ready=ready->next;    ^5 `1 s9 @3 f, ^) g

      1 R; q, m4 I! y( P( _

    • 6 d+ g6 h6 m* O: n: a

      ; ?; ?% b+ `. c0 c$ V% h1 Y+ c. e0 v   run->state='R';  
      4 B9 M. g+ q  P" F: Q
      % v' c( _* K) w9 m2 i/ r
    • # J( X+ D6 U& J+ E

      / u9 s9 ]. [9 Z% Q& ~0 N- u! h' j- R}  ! ]0 y7 x' e1 z0 o4 ~  J
      ! L/ S9 N5 q3 _

    • / r' }3 ]" ^3 ]4 g3 G, q1 ^
      9 |- ]3 Q$ z1 y5 @
      /*优先数调度算法*/  . m+ Z0 i" k6 y

      " l- G2 v: C* x
    • / b& Q, ?% s  R! U" `5 i* d
      # J8 g; F% Z- |8 V& r- v
      priority(char alg)  
      1 E$ t# w3 G/ @3 a

      5 w! h8 J/ P) q( k' b4 ?. B. U
    • * y) d9 r, h/ t2 o

      / ~2 F* N: w' d) Z1 f% n( m4 @1 u{  
      $ Z+ y3 @- p% U+ p! I

      ! Q/ L1 y# i% s$ A' B1 Q. x0 O( q
    • * I1 T, K) \! c

      , h' I  o5 {% K. J   while(run!=NULL)  /*当运行队列不空时,有进程正在运行*/  % z$ b7 S4 }; M: F

      - i2 ?( y$ C0 X; X1 d8 [
    • & v- d4 B( ?$ d0 Z( v

      ; _% t7 S/ q2 z' J. W. y% I# P! z   {  * _: G; I" Y5 ]

      % P+ N- e* Y% r6 w8 C: k8 a
    • % ?: F" m! E3 G" R! E

      ; S8 I: l( o$ E1 `      run->cputime=run->cputime+1;  
      , v5 ^9 p. [  o0 c$ f% r
      " P6 g9 K: \0 O6 L6 d; }

    • 2 i! B& A, J# Q& {$ D# Y$ z& D1 b1 H; F
      9 c$ z  s* `4 G# P5 ^
            run->needtime=run->needtime-1;  3 g: b, t) N2 i( b9 t; J
      % j. I: Z! ?- ?1 {

    • ( I( j8 A) B9 t- T
      : t4 n7 D8 J5 Q& y/ \. {
            run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  8 j  T& y2 x9 _& l. l

      9 X* d0 D  i' ?

    • & A& i7 Q2 w# z
      5 _* J( \$ r& I/ _6 r/ P, Q) ~$ l
            PCB *p;
      - ^# |" S) z, W9 H5 C

      $ O. y# J2 u7 C$ N* I6 \# P2 j; G
    •   Y3 d3 I- ^. A, k$ N. ~  _
      + I  F2 B" E( V4 i+ C8 j" [
            p=ready;; S% m4 r; _; L0 q+ Y! J' W9 B

        O- N: s5 `+ ~: Q9 c. x. O  T3 F

    • $ S0 m9 W# W" {; e1 X

      + a( ^2 r. l0 ~8 O4 I& q" d      while(p!=NULL)  2 }' ^$ v1 J$ q6 I+ f. I3 O

      : l3 |8 K$ p' B1 a
    • 8 X6 q) V' N1 \4 G5 }
      ; Q# G! V/ B# H/ X
            {  + @, P$ A. O8 v- u

      2 Z) j& T# b: i
    • 8 o9 r% a  ~2 `/ d2 C0 b: ?% ~% T
      / ]/ e, @0 x; Q6 @1 I
                p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/    8 c) q" M0 T; O3 K; O; B1 i, \
      0 N1 r- z# Q! D4 h

    • 7 ?6 m1 c' H5 K+ ]" W

      ; B" X. A7 N* g: E! B! L5 D7 _: q          p=p->next;    H7 a; R; V5 j( I

      3 c1 g( g" o* O4 ?

    • * \. j- }9 X) F& `  f+ {- g: ^
      ! v* G9 g7 X% s! x, |5 @, F
            }  / O# R2 \7 y7 m5 j

      & ^( j5 y5 M; ]8 A# I* l
    • : v( ^0 Y3 N0 h# G6 W' G) ]3 `% B

      " z. f  j' s4 F# i* A0 u/ s      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  2 ]. x3 P% h3 t) y, K5 S
      8 I3 ]) |0 C2 ~  N1 o

    • ! ?/ i$ e! v5 O# [. n

      2 r9 I; A- G) k# \9 C      {  7 ~1 Q# Z8 t0 o9 O

        ?0 e2 e/ z. V

    • ! M- e7 j  B+ r+ U8 @% W7 K2 O1 U0 q. |
      $ P7 M+ X, A- \/ M& R
               run->next=finish;  " R' U# @- I, z% }% b" N& [- M9 C+ f* m

      7 v2 W. ^7 G/ v
    • ; B8 }0 U: _7 l5 H" }2 _. B# i( K

      3 K( v6 S0 |5 ?% ?0 e+ ^8 g         finish=run;  
      & u0 S4 v4 b7 E% f

      . m, }7 K# K# x6 D  Q) r: o

    • + o* `+ ~* `+ q! b) U1 I+ y
      & l* ?7 ], [) Y) ~2 h% C7 j1 A
               run->state='F';  /*置状态为完成态*/  
      , U8 s; l( V4 \

      ( _% C% m/ N6 A0 d- t- u

    • . X4 E# q5 U/ d7 J6 f2 }$ i

      0 m$ J8 Q6 E( ~2 k         run=NULL;  /*运行队列头指针为空*/  4 ]4 S: x) p3 ?* j: E0 T. m

      * O7 l3 h4 O# A: {! V/ m

    •   B: @6 Y5 n  ^* j. Q9 M" ^

      & X) C- V: _) }- e$ Q         if(ready!=NULL) /*如就绪队列不空*/ ( p! H! X% f7 S

      5 Z9 G9 ~: O4 {- R% C, w1 z! R

    • 0 b$ X6 b3 {  }0 u# [3 n
      * b% j% s+ Z' }; S
               {  ; ^) x3 y$ z* i$ E0 C: A7 ^% \
      1 J8 V3 }& P# ~' s7 c% l3 O2 F. [

    • 5 O& Z2 o2 a5 V: b
      + }1 o/ x* t$ c. u3 ~0 }
                  firstin(); /*将就绪对列的第一个进程投入运行*/  - n4 X7 p# T3 P" x$ y' x/ o
      & T9 X+ h1 x+ [  s# o4 P+ T% Y) A

    • & [% a# H  ^, k

      9 B; P% Z! T; A7 Z' I8 b* C         }
      ; \  e; p' T; k: |' q
      ' [  V% c" Q% D( t$ p0 H
    • : K0 E/ t6 h- U( |" {( t0 F4 b: ^4 B

      3 g2 K! G! I$ {6 t8 g- G      }  9 G0 c: _: }1 w$ S$ J( Y9 ]3 H% Z

      6 t! B  [: k4 N& K* R( r4 N( u
    • ) k- |9 i' s8 N% v+ ^( q
      # i2 E& I: N9 c# a8 `  Q, G
            else /*没有运行完同时优先数不是最大,则将其变为就绪态插入到就绪队列*/  
      # ~6 q& i  _+ f+ M  O' b- o7 ~& g

      3 w, A0 K6 D: C1 i* `" t* J

    • 6 u! k, J/ R6 [/ u) v4 s. @( v

      - r! ^; P& c4 N2 A3 u     if((ready!=NULL)&&(run->prio<ready->prio))  
      ' y! C/ m: a; [' d3 X, {
      * N/ E* U) e( @. ~) J1 E

    • 3 ^  G& e0 h, P! a! p9 y/ g

      / \. Y; ]& Q5 Z     {  , b2 V4 t4 f& ]5 ?) q

      0 z7 ~+ @$ N- R' c4 d% i

    • 8 _1 T; @$ r. O8 o

      2 `+ z  t' g; b  Q) V9 W& y        run->state='W';  
      , @: i4 J- P1 F% b- V/ M

      7 s7 g3 L9 `# k( C/ a

    • 4 W$ D8 i& J, _- k4 Q- F5 p% m# @& ^5 H

      * \/ f, `7 W% A- \' [2 d+ e        insert1(run);  
      $ G' h# J2 N  K" S9 [
      2 D# g. ^) d4 O7 q% ^" {. z8 l4 d
    • & \, L7 V9 i  B2 b* ~! ^

      7 `& x  g5 b, @+ s, c# [: y        firstin(); /*将就绪队列的第一个进程投入运行*/  2 Y. V% Z6 p8 L3 Y5 q% y

        J; z; n& v, H/ X
    • / g1 b& k5 ?3 _" y6 m
      - l' v. N! j( y+ e  g; z4 E4 s1 \
           }  : N# S' N) C- h$ G, h! z

      3 Z/ n' [- e) [# M2 l
    • ( @# v3 g, P% Z# n! x
      , a0 B9 m; c2 h/ p0 S8 L3 Z
            prt(alg); /*输出进程PCB信息*/  
      # f2 ~2 ]  g; G. R/ H

      & e) \6 H! j+ M' \5 G, R

    • 3 j; t7 p0 T) `1 [& Z8 ?
      ) R4 a8 H5 ^4 J) Z0 V  q0 A4 `7 S
         }  1 t5 k0 s; }) T5 s

      8 }7 ?1 S8 F6 \: h# y' V: M1 a( N
    • ) |1 |' X* M$ d  r# I

      7 _/ q& Z! {$ G( W& _}  5 ^4 Q3 J" w. k

      $ g; `& l6 }- \

    • 0 H3 f4 L) x: E8 J6 u; `! b

      ' c/ F! l  h; n. F$ m# m8 U$ [; n/*主函数*/  
      % r5 P' R1 N1 Q9 V3 E! r3 y: e

      # c; ?4 Q& e% l" Q8 Z8 U
    • 7 t( k+ V& A4 y1 t$ X3 [' k% B( ]
      2 i9 s5 `/ s6 o; ]
      main()  , V8 W7 U2 U6 p( N- i

      ! @- J& F# \8 A
    • 3 J7 G) n0 L/ ?! c: x, o/ }! K8 ]
      , R1 y+ C6 m. _. x4 k+ [
      {  ; |% C& H' v2 k' c3 _
        O* M' K: f# E% U
    • , {8 g( x1 R2 O& P3 \2 l( E
      + a- h7 C9 j/ Z" U! E  }
         char algo;  /*算法标记*/  & c6 O1 r, f" O
      - I# L. K* K" v) h6 I' f) F

    • 9 w) `& ^8 C/ Y. I9 \

      $ h! {* S+ T: ~% _: t* _   printf("输入P确定算法:优先数算法\n");  / @0 H4 q  t; n: N: t, E# M3 k
      # _. |4 M7 m+ A7 w5 c$ f

    • ; f, ?* A6 P, b7 e" P

      ' y3 t; \; X6 ?   scanf("%c",&algo); /*输入字符确定算法*/  
      " |2 H, Z2 J2 h! f
      9 Z' r: R' k+ b8 q
    • ) d+ Q$ Z/ q( J$ P4 B! f4 q& L
      0 L2 S+ g  O' G
         printf("输入进程数:\n");  $ {; @8 ]8 Q. h6 q4 u
      / a% i5 S  J2 W( t

    • 7 M1 f. Z6 G0 X# {

      ( z# L& i6 F5 r. s  H" }   scanf("%d",&N); /*输入进程数*/  
      2 @' K& \9 c! \

        S% c( v/ N" w8 e

    • 2 l' ]& \% o. \: h6 ?) v* u6 F

      4 U- P$ R' d6 O/ a1 r2 @- Z   if(algo=='P'||algo=='p')  ' B3 I8 W# l% n- ]; v( L  m8 f+ n

      7 o& Q6 q: Z9 p$ c; N8 k* C4 j- N
    • 5 H1 p" r- U/ K0 d1 H" {) L, v* e8 Z

      / s5 U6 j# v6 {2 V; E   {  
      ) `  {* k3 ]: w! ?: Q
      1 w/ P$ E, S" x* g

    • ( c6 J  M# S- G
      # F8 y  d5 y8 q
            create(algo); /*优先数法*/  6 O3 l6 E" j8 _9 {

      6 M7 _+ Q/ E6 j) Q9 O
    •   h0 t3 z5 F6 K/ |  D

      3 o5 c- B% p5 n- ?9 ^! N      priority(algo);  & ]' z& P$ i. H9 ^+ C/ X
      . w2 F7 w$ J1 ^3 S8 r$ L
    • 2 G; \) K, j1 R1 L2 b/ ^

      1 X# \6 n- [( H/ ]+ b   }
      1 N; Y. Y5 Z$ B4 Q9 Z0 z

      & d) e$ A( g. I4 [8 H

    • 8 k( Q5 d9 E: g5 V% I& m

      & T" h! d: }1 }& [1 q}7 M- J7 W, ~# V

      - D9 N0 w2 q& W3 x. r7 {1 p8 l6 K1 q3 S: Q

    * M; ?' t9 o* O
    输出结果:* Z2 O# T2 n& R0 X- X1 g1 r

    ! H3 o6 c$ g, T% H* l( K, W/ B+ O' o
    原文:https://blog.csdn.net/weixin_40962955/article/details/80072769


    0 y0 n, U( I$ f! ~; h
    5 z8 F! o- c( M! h2 Y: `
    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 23:30 , Processed in 0.383129 second(s), 50 queries .

    回顶部