QQ登录

只需要一步,快速开始

 注册地址  找回密码
查看: 3174|回复: 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

    7 b+ c' ^, ^6 x- i( P优先级调度算法
    ; K& O& ?! o2 f$ O

    算法介绍: n! ?: J5 u# f- V& a
    优先调度算法的类型(用于作业调度)
    1 B' }- s, g0 o3 b/ i1)非抢占式优先权调度算法
    % [5 b; p' G" |: ~系统一旦把处理机分配给优先权最高的进程后,便一直执行下去,至完成。 0 ]) i  c  J3 H2 G
    2)抢占式优先权调度算法 : H& J- H9 r0 G8 k0 h
    只要系统中出现一个新的就绪进程,就进行优先权比较 。若出现优先权更高的进程,则立即停止当前执行,并将处理机分配给新到的优先权最高的进程。

    优先权类型( c; q* j* p1 P. A" p2 K
    1)静态优先权 7 F- v+ @" Y7 Q" p& U
    静态优先权在创建进程时确定,且在进程的整个运行期间保持不变。
    . P" A7 B. T5 j  g. ?

    2)动态优先权
    5 [% o2 o$ I" M' l

    算法实现

    抢占式动态优先权:

    3 P, {! N. k$ G" i
    PS:本人认为非抢占式静态优先权没有实际价值。

    • * P  X% `6 t+ G/ e) B% a

      * y/ }. N# r9 a1 e8 p) `3 @#include <stdio.h> ) h# M( }! h3 S' a  i

      . B' A" J9 G& O6 D; r

    • ' f4 \  @/ e5 a/ B
      7 ~! E1 P) i/ x& v! z  x
      #include <stdlib.h>  * x' L, I6 u6 ^
      ' A8 J2 I) W+ N* x' I9 N% h
    • ' F7 w" ]# i! m2 B3 @
      9 g/ |% s6 H3 L
      #include <string.h>  3 i5 Y" d% ~- s& o0 G' \

      # y( i6 q# H3 T  R

    • $ A5 Q, r+ V, ]1 ~" e& x8 Q

      3 ~. F4 S4 j, V! \6 ?4 ^typedef struct node  
      7 w6 b; @9 ]& ~9 l3 p$ f
      ; o& [+ V3 y8 e! s0 ^6 E, \

    • / F$ [4 N% N" V

      6 Z6 ?0 M& d" Z' I{  
      ! W$ c2 x* X$ f6 p' ^; \3 U

      ' z5 d  J, f0 K4 b+ j

    • 5 j8 `- s% r9 N* Z3 I4 |
      0 a$ d  n: w9 a0 ~: V; C8 r
         char name[10];  /*进程标识符*/  5 h1 \* j. k; L) I

      ) ]: E8 h4 j; J8 B: y# \

    • 2 _; l0 B: w- c! N! g. s
      6 ~' i) a+ d6 p1 m; C
         int prio;   /*进程优先数*/  
      & f; D3 q, a$ {9 M
      , D4 i0 E7 f2 h8 r0 ?

    • 8 d1 W; g! G3 a9 C- V
      3 b: \" O* l  Q% q2 x2 x7 O
         int round;  /*进程时间轮转时间片*/  
      " d. k0 R, J6 O! Z% }- n* F) v
      " q- L2 U; X( i. M6 _1 {
    • 7 i  V5 r5 Y! d; X# a3 T2 V
      6 B- s! m0 L; z) z! K1 U
         int cputime; /*进程占用CPU时间*/  
      9 u3 }$ Z  ^' M5 v9 f/ Y. [1 Z/ ^
      * x9 i+ N* W4 K0 ?

    • " c7 c/ U7 \3 x9 {3 {& O

      # U7 u$ T( n, H2 E$ D! D- X1 {. R   int needtime; /*进程到完成还要的时间*/  
      + o) f6 n0 B3 S* G2 `7 _% M6 Z( \

      1 f# c; {$ W% E8 j, S! r

    • # x- h5 T  O6 f9 X
      3 T& E; r+ v9 U! |6 A
         int count;  /*计数器*/  
      + I" _8 [4 ]8 F8 n
      ) T. A  N/ I6 b) o; X) M

    • & N4 S; [- ]# h$ n' E

      ) I' Y, w( i( @6 }' p& B! \" z1 K* Z; R   char state; /*进程的状态*/  5 n0 \9 c& j: p7 m4 `6 a

      . c; @( z7 F# t+ d8 B

    • 1 u3 n: p1 }: k( q1 t( C5 |
      # Y. ~8 b# m' G* Q
         struct node *next; /*链指针*/  * X* r9 r3 Y8 S( c' G5 F; ^7 O& f4 ?

      5 p: F: g1 j* C

    • 8 j3 R% p& l$ {* _

      0 F: A/ b1 H+ x# M0 A8 `" f* L# E}PCB;  4 r5 u/ S/ }6 \# D* p$ f

      4 N) d8 U, y; y6 w4 A2 |
    •   a( Z- k; I" y, B" ]' a

      9 m0 C- Q; R) QPCB *finish,*ready,*tail,*run; /*队列指针*/  
      ) U5 v0 M* c, {# @* n4 x
      5 H7 @+ A/ a  ^% m  G! D

    • ) R0 \2 b! k( A+ n
      ! z1 o6 ~5 z- t/ h( R) L
      int N; /*进程数*/  
      6 Q6 {( ?) Q0 i; U: v0 M3 Q
      + }5 W, l# p! v" S/ @5 ^% @

    •   p5 i+ c- i8 D* X% U
      & y0 B/ \8 O2 p/ L
      /*将就绪队列中的第一个进程投入运行*/  5 U8 G! p& S' E! C3 y2 F; o
      . @8 g4 v! A2 F* H

    • 9 |8 q4 t; P' j4 }7 @

      " u4 y2 ~' `* C" n* I+ H2 Hfirstin()  
        w0 l! Q' m; [7 {
      9 z/ p% D: u( r1 j

    • . @( [# b" q+ i: a% j! j; h
      : a, Z1 ]1 m0 @% ~, v" M
      {  + C! I7 Q$ a3 ~" i

      ' c1 g4 D0 j# e/ ?5 g6 O
    • 9 y% f2 |, n8 V0 L
      9 y  X9 e) n; W! G( r( v: G! _+ g+ a
         run=ready;   /*就绪队列头指针赋值给运行头指针*/  
      & C7 N6 Z- S$ E" D, p7 b1 u

      % J' `3 b' T( A5 }0 Y0 }) j8 |' w, i

    • - W% W' ?3 ?) d, E" a

      " D, o/ s% C4 g: A; H   run->state='R';   /*进程状态变为运行态*/  6 I2 s) L+ g3 n6 ^+ S
      6 V  ?2 b8 E2 ~. b5 C* Y- S
    • 1 V' k" R& t* a/ X! O" Y% B2 X' v

      5 s7 i- p8 s! z$ F' B   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
      4 c$ B! f: a* m! Z" P
      # d5 n: o- R4 H( c: ?& r
    • ( f) X$ H' @; w1 ]
      ' K+ ?# C% `% ]' o% g$ ^5 Y
      }    g; E5 S$ R! `  c  @, V6 R

      7 \/ E; Z: |; ~4 Y) A. ~/ w

    • 7 ~, W+ p, F! d/ h, X

      9 G: y2 I# u' L/ V) P/*标题输出函数*/  # B4 s6 |- S  _7 o7 ^

      ' j$ [! N, M3 z

    • 5 |8 y; M1 z' p, h
      8 F% M2 Y& _' I) K) ^, T
      void prt1(char a)  
        q, i! g9 d3 \7 C# O# p' `4 w

      2 ^6 \! q; h% u4 G/ C3 i

    • ; k% }8 j) r: P/ ~( c) I+ K
      0 r5 _* f' Y, n% f* |8 h) `) H
      {  
      ' A2 j, k; W1 m" d5 _
      # f2 ^  z- S. p! B. r

    • 8 A0 |1 C( L% z. z" k5 \
      ! s. q- _6 x* m. c
         if(toupper(a)=='P') /*优先数法*/  
      & e/ `$ z& W0 m
      $ V/ M! R+ ~2 [, `3 @9 D: D
    • : `% [4 L$ P& U
      7 f% I/ |4 h% @; D" u
            printf("  进程号   cpu时间  所需时间  优先数    状态\n");  5 E5 o  \* x3 w/ _) Z

      : {, q$ _$ I+ Q4 m; h
    • ! d9 h" R( z2 u

      ; k8 @: _! V1 o( u8 K; d2 I   else  
      / |* Z9 ?9 E: M0 C0 n* G
      : |1 {' t/ ^, o$ g
    • % w3 C7 c# z4 o$ K: ?& U' R
      : n& W% ^* L: O; X! F+ Y& h, l
            printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  0 J; Q+ ]! r. p
      5 w- X7 j  s0 Z! E1 h3 U

    • ) N6 }. T! |6 \6 m% A

      : E: e, D$ v3 y5 k0 v% d/ s}  
      ' }$ C' f  a0 Y9 E) P7 ?

      1 v- r# g; Q0 I& R% J/ }

    • 9 i# C( m$ U" c; ?: _: a

      " Y% u  X7 r, \$ {( ?; k* E, S% c1 [- P/*进程PCB输出*/  # q( i6 \% p- a6 u$ K- P

      , {, h( o3 `3 w8 w

    • * N! E' \3 c& |

      3 ]0 j& k# o& E$ t" @6 k9 f0 ]void prt2(char a,PCB *q)  ; l+ _/ s6 {& n8 o+ U* m0 D* h

      ( e" a7 W& f! r. B- L: ~

    • 4 m& r9 D& F' U0 }. k: i
      2 z* X1 x# B8 J" O  u- Q
      {  
      ' S, s2 N$ y7 m$ |0 P

      ; x3 t9 A3 b. L

    • * O1 a5 d) m, g6 W9 |
      5 x5 H3 V% |! Z
         if(toupper(a)=='P')  /*优先数法的输出*/  
      * M( c! c( p: |/ p7 m
        F3 z" v! H* r! s# w

    • . \0 l3 t+ G# Y1 L* y, V2 }, g7 V

      / u7 P$ n  v3 J4 I% U      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
      ( f2 M9 m) P2 v, B' _

      3 V! K* A* G" i3 E
    • 3 ?/ `3 W9 O" H6 X
      " E2 k# o5 Y( A! l6 M  m
             q->cputime,q->needtime,q->prio,q->state);  4 t( K* T: Q0 C- g7 L/ Y

      0 I7 d+ a# K0 ?0 n
    • & x7 ]2 h" J! R
      ; Y: L& o9 B6 ~; ?
         else/*轮转法的输出*/  
      + `  H; i- m( ]. N. d. j( V

      $ u$ ~1 w: D* ]% Z2 l( X+ S! D: g; I
    • 5 k1 Q  U0 R0 R' m: G! a/ V# {
      6 `: t& E/ D6 `9 z7 n" e
            printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  6 }- f% }" x0 w1 u; W5 n" K

      6 h3 h( R- S, Y8 a( l, c1 y
    • ! L; @# Z. h# E5 X4 T
      ; w8 }' w, @0 ~! E0 @5 ~* X( W" u5 \
             q->cputime,q->needtime,q->count,q->round,q->state);  - N: {% B+ I7 p- y6 L, N

      " e  h7 h$ U, ^! k5 [, e4 T( M

    • & D; S- O/ E+ R) E. ^; T' N' G9 r& Q

      1 O+ D* u3 b: D2 C+ A}  
      ; P* }- b0 G- [* m$ {
      6 c  ~, T$ p, Q6 s, u0 h! U
    • - x, Z! B1 x7 X5 V; o, `+ D

      / m& O! h( E9 Q5 ^, ?: S: m/*输出函数*/  , F. ^4 _! T( k* f) c1 F  l0 \! g

      % g0 K) E+ ~# T2 D
    • / o& w  ]/ T  H1 M# n4 {

      7 B) j. Y0 d- p+ y0 n& e  O. vvoid prt(char algo)  # S- L- ^$ @) F8 t

      4 J  r* E1 m- J! x
    • $ ^. Z9 S; d0 Q$ I

      ; J6 H% e5 t+ r: S{  
      # V7 ?6 J! E( P$ ?& u

      6 p9 P6 V+ ^9 m) s  x1 }4 Z4 V
    • 0 b& ^% b4 ]  Z0 d& V

      0 {- ^& U7 ^9 d4 E4 @3 G   PCB *p;  # W! Y6 q- }  T! o" S1 [

      " r+ E) n3 o) J, X
    • ; u5 ]8 b6 M+ ]) ?# V& c6 {/ f2 a) L
      1 [( ^" B+ F7 O( z7 D
         prt1(algo);  /*输出标题*/  7 Q0 g1 ?! N. f# p

      ; r7 F* k' a% Z( [7 w$ f
    • ) L# G/ e8 R6 N6 q! z8 k
      8 x& a$ E6 b. {5 @) I
         if(run!=NULL) /*如果运行指针不空*/  ' E' R* q& q6 L* C

      3 P$ P% L/ Q5 p0 c/ F

    • 9 G0 F  m/ d) T/ S2 D7 r

      1 d- [2 q7 G- f- B; h      prt2(algo,run); /*输出当前正在运行的PCB*/  
      ( B  L) ]+ R/ T9 N  E( v! P6 i  n

      ) F% R/ B7 D' k  V3 \

    • # S8 L/ o+ ]7 S; @& D

      ) F2 P: L& U! `- _6 q   p=ready;  /*输出就绪队列PCB*/  6 a  h; I( y: |8 Y& _' {4 v' c/ }
      + l, {! O7 D4 Y7 ~0 t% Z& b! T
    • 0 o; K  N; C1 x9 p+ b- `
      9 ]7 Z5 P% r' ~) Q4 K  {0 N( O
         while(p!=NULL)  $ q2 M# g8 W% t# r2 N' c

      9 W* n! V7 w2 z% u8 y
    • 0 G* J/ \# x! B
      7 T5 i5 \6 q9 f& a  B0 F/ e% f) [; u
         {  
      # s  `3 i6 p& a  o

      7 d" Q, ~6 ?1 H6 R+ S$ e" P
    • 9 [: f' h& @6 k! X
      . L9 H  i) \4 A4 X
            prt2(algo,p);  
      : V8 g% D1 I' ~& l- ?
      , M3 X6 c" r, j) z( p% R
    • 7 E' e( G3 w7 G4 U! O

        k5 @' t; V2 L" x3 c6 }      p=p->next;  1 S% [; S( ]/ d3 |% I

      0 |2 c4 b$ B4 C+ }! [1 t
    • 1 o/ d. h/ s7 o8 d1 B

      4 J- _2 N# ?1 R$ G$ s* Q! H* [   }  
      ' \; r/ }0 u9 R& W! S* f

      9 D, Q: ]. j8 k0 L' i

    • , g% v- G. Q. ?6 c

      6 i" h! ?" [, V+ K   p=finish;  /*输出完成队列的PCB*/  
      " r- E% |* P$ Q& j# W
      1 c2 x" A  i( v! i7 c9 n

    • 2 u; N' u  D; h! D$ H
      4 h2 y7 u1 Y' z  v4 N
         while(p!=NULL)  
      7 P8 }: V- L" y2 V1 s$ B4 V" T/ X

      * W0 E- L/ q  l9 G3 X, h! s
    • * K! S- Q9 @2 r: X+ R

      9 [. v* i  H5 l* [- @  u$ J   {  ) y$ R; ]+ u: {! q2 T" T( ?! N9 q
      . b2 A7 b, a( [+ I$ ]  _" H

    • ; x/ z( C: e9 K8 S( _

      1 L% x; j4 J4 o, |' B' N) a- o- y      prt2(algo,p);  
      # b6 v' {$ r% B  T( e$ K5 V0 f

      ! ^! Q2 l. Y. O. M  E; e

    • ; W( ?6 m3 d; o$ e# q& ^/ L
      5 A- f: ?$ W9 @, ^) U/ K2 I# p0 C
            p=p->next;  0 x3 n3 y) F9 o8 V# Z+ p

      * t5 }( t' l' m3 m1 V
    • : M4 d) o) ?: \3 H' r" t6 J
      9 p1 f1 @2 V- U3 I* B6 q
         }  ; q: s& |' x8 U8 [' I% ]
      " m( F4 H7 Z0 |9 s/ P+ t
    •   `0 H  D* b5 @" z& B

      4 m0 B& U2 C  v! n$ i# P   getchar();  /*压任意键继续*/  
      , Z) V/ Q6 c  t# z* k) H: U% b! l

      % e5 h% I7 i0 E3 [6 V1 \5 z
    • 2 N8 O9 h4 H0 n; C0 ~! O& e

      4 i) R6 Y: V# F* c; \  x2 _- }. |6 n}  / A1 H; ^7 s4 e& C' f5 \0 Q

      9 U0 Q' v, s( h  V! V! j+ n- z

    • ' O- a1 G8 m) P8 H: ]' t
      ; ~" m9 e) V* D& m; P% I
      /*优先数的插入算法*/  
      0 h6 O$ `( N. o

      - {+ ~) A& D! |- {6 Z0 `( z

    • ' ?: \$ e. k# F

      1 {- A6 e% F# {! r# einsert1(PCB *q)  $ u' H# t$ \* ~

      & f( @2 m1 v6 i7 f

    • ! I- n# I# n4 j: G* n$ n% {

      ' b6 S9 f1 Y! C- o{  
      7 [' U3 ~8 l/ l8 i" T+ K
      * e8 i- w8 X+ T7 N4 y

    • - m4 S. S' r, J; V0 l2 r. R
      2 b1 ~9 E! {* x+ q) z
         PCB *p1,*s,*r;  6 y' }: |3 p2 F, \
      & ~+ w6 t9 A( U

    • ! F, x1 \6 V2 C' ^  D

      , ?# }1 N. I% C1 O   int b;    W7 I2 S' |! j; C. E" `# Y

      6 s) `( z2 J; {: _

    • * D/ o, A+ y; P& }, o9 Z

      " B9 w! Q+ z/ s* x; \   s=q;  /*待插入的PCB指针*/  
      7 Q/ T: N+ V: T- K8 W

      + [$ F3 q$ n# k) f
    • ) O3 E5 O! v) N; g! K! V1 M
      9 c4 q7 n$ N$ h& U
         p1=ready; /*就绪队列头指针*/  9 X' _- j- G0 B$ ?" v: W! {
      0 a) u! q/ C7 D! R& h; O  ?+ a7 y

    • ( @7 S; }4 ~4 h$ F, ~4 Y. ?
      ( o, j( S2 o7 h- T& s( M
         r=p1; /*r做p1的前驱指针*/  " ~! [) s% n- A7 _9 R2 Q$ C  `
      % R* x) j# o" s% R) ^) z

    • : W1 k! ]2 v( @. A

      ; P* p/ s1 l. f( f   b=1;  
      . v! @4 r3 G" n! p; b
      ( q; e9 A6 m( x

    • 9 A2 j  ^$ h5 ^6 n1 r$ a

      . f, e4 ~  z( z9 b% H/ G4 t5 j( e& L   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
      * l8 m" Z2 K# `
      # b' }) p; ~6 r7 s! ?  b
    • * R, j( \8 q  F4 p, g3 H6 R1 D2 ^

      9 P1 ]" ^+ ~: ]# x" O6 _: ~      if(p1->prio>=s->prio)  " e" p' E1 |+ x# U

      7 B1 T. }! ], f% U/ s8 ~

    • " J2 w8 v+ D, W$ q4 Q
      4 m4 o0 c' O5 H9 b) b: n
            {  
      / k! g0 R$ u+ n
      ; f, m3 a/ d6 h4 J" t4 |/ q

    • ! Z) Y2 z4 X  B1 }4 l/ W2 D
      4 {, \( H& d0 s, U
           r=p1;  
      6 @& o- `6 g. C1 B4 Z- S. [
      ; p. G( J" w- I' W

    • ! n( {# H2 z1 p
      ) i( j1 M% O+ x: s1 v+ F# C
           p1=p1->next;  4 \6 @/ u  X$ Y0 l
      * y' d8 F5 P! W3 Z$ h( {

    • ( b/ g  M' g8 a6 ~0 u8 Q- R
      * U4 |: ^$ q1 N; r5 j4 T$ t
            }  
      5 j! w0 `$ a$ I5 F" t( V
      5 H9 t3 Y+ [4 ]  J
    •   ^# d( t2 @  W- X
      " O% X1 z) N0 h1 y" j) h2 f9 @4 k, Y
            else  
      % p% e; ~6 R7 {! G$ a/ X% A* @
        U# w0 B( o4 p, m; [) H

    • & P/ v3 _/ ^+ ?- d# Z  W; s  S

      " q1 R; q; C; V* V5 ?- _     b=0;  
      & @2 X) s: F; `' P1 S$ h
      ' l7 U, n0 i8 u2 e. \! N

    • , z3 |* h: y4 x8 Y( M9 d% _
      : R- G5 d& {, m4 U" u
         if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
      , a. _( q9 `9 t( X  c0 z& v
      ; V0 Y) h9 ^  e8 c4 i0 x  z
    • ( c9 T' o- X; L& s3 I, w* P- ?% z- j
      2 q8 e' z) G7 f1 V. i
         {  
      8 T  P& }2 V. ]9 R4 Y
        A: l0 t: {$ Y

    •   u! N9 l; m7 p) o, j( n

      . J1 d5 w  T+ E( S  a  H6 N      r->next=s;  ; S6 H' Z% M- _' B. ~3 B  i. I: _+ z
      ' e8 C1 x( N3 _; X

    • 5 b$ Y2 i" c4 I. N

      * {- x( @4 M- B1 m! \      s->next=p1;  
      ( ^$ {: o2 E* I0 e9 D5 p

      & n" `2 S. N2 I4 K
    • 8 P: L4 g  k9 ?
      ( r% v' R) L- m. Z9 t
         }  5 L5 p. [6 Y0 L' d! B

      # U/ I6 j; V0 v$ X

    • + w) n1 [* d2 ?! c
      * k+ s: K6 P  A8 |% I' r0 z' {
         else  # x8 V6 V) L6 t3 D9 ~# x

      ' t9 J  S$ `( e2 \' C* I
    • ' \. T4 P+ x- D/ X1 t5 E# h% _

      ( I/ z. y; }) ^0 ~   {  
      4 l3 j" d! x: v+ Q1 g+ M& Y
      % G. h6 m; S3 W/ [9 I+ \+ \
    • . R0 a* E9 D- y5 h# j
      0 u& t+ Z7 I8 {  J$ {
            s->next=p1;  /*否则插入在就绪队列的头*/  , a* j" B% z5 P" u) V0 i

      $ s/ D1 k  w% f6 z5 v# {! V
    • 2 g. e$ x  y9 P7 |/ `
      . I% W$ r! U: l
            ready=s;  1 M2 h( f& [8 k, z2 }. ?/ S5 h# D
      ' ^5 d; X& |: L5 E, p6 d* f
    • 1 E* U0 f& Y* Q+ x
      + h6 j1 V1 T: X  b9 v
         }  6 D7 w8 R3 a' I# h" z7 R0 _7 a
      & h- I; D1 _& b. c, P0 I
    • 5 D2 x! W; F0 C. F

      7 t1 |# F: m1 E# i2 n; s% R# p; D' q}  
      , f( d0 b/ P2 g1 L4 l

      8 M% t2 i  F' ?  P# k/ N# l

    • % N8 K! D. h- A$ L$ F2 d2 B5 c
      7 ]! H6 L/ @% ]7 j% A
      /*优先数创建初始PCB信息*/  
      # G9 j# b* _) f

      % U) A6 I! _+ t9 Y6 a# ]1 W

    • 0 I/ i' q: l; e1 ?- T
      , z; R* G3 |7 F6 t
      void create(char alg)  
      9 C( f# e3 V# f; c+ b9 K

      " C( h3 r7 ^  D
    • , T4 t; t5 ^4 z+ P6 T7 f
      $ ^2 a, N: |# l2 I( [
      {  $ l3 p+ T8 B1 T) Z9 y" _6 F1 m& b) T/ P

      / M# A) U2 H6 v  [* e# `
    •   G$ p. f: Z/ l5 ?, M' Z: T

      ) a+ ]( ]- b" s   PCB *p;  
      ! q- |9 m. K; b9 R! ?4 F/ r# A, |2 V) @0 C

        @6 M1 B7 I' a1 {" Q9 Z% h

    • 0 S# D- d9 C7 [! V- @, N+ O# S* X3 [
      * V/ E" T5 I- G7 D
         int i,time;  : U) q2 j+ A/ w! c1 w

      2 l/ z, A6 {" ?) I

    • / Y6 g: P( G1 Z" _
      5 P) j: @: n3 |. w! Z4 i
         char na[10];  
      : B2 S" C$ _; [$ `5 s/ G" h+ n
      2 h: U9 [3 C2 `( b1 K" R. w/ H
    • / q2 R( W) s* b( D; c" D7 R: _7 Q
      5 k, K* P( f, X
         ready=NULL; /*就绪队列头指针*/  
        r; x7 u+ L" q: J

      3 [4 A2 G& G" m# b
    • 4 {' |7 G+ X) ]: s" o
      # m9 b2 R- R' w5 h- K+ ]0 W3 u
         finish=NULL;  /*完成队列头指针*/  
      * C# x9 Q+ ]# j* Y9 I& e( ?% x

      7 X% W+ b+ V0 d  c

    • ( W2 l, ~& w+ }* {" ~5 j# z

      ) q" T. {: E6 K8 {   run=NULL; /*运行队列指针*/  
      3 i7 q# l/ M$ U" M$ n& ^4 f

      2 k' f, W+ X8 Q# I2 x; c$ P5 m
    • & F/ Z: ?: f3 o6 a$ B/ D
      2 U( ]. K5 g5 C+ W' a2 D% w
         printf("输入进程号和运行时间:\n"); /*输入进程标识和所需时间创建PCB*/  
      - S* ~; c0 t  h, P  K. e) N* j" q4 A" Z

      $ X0 t- S  o  b3 T6 r: m/ B. s9 H7 o
    • * O7 h! X  E7 l6 P7 ^$ @5 I! k
      ! _8 I# z0 L6 {# v
         for(i=1;i<=N;i++)  5 @5 g6 T% R$ q

      ( k2 Z4 S0 B4 W* @5 t) _
    • * P" O0 a  ?3 K! e, j

      # k; h! g/ j+ U   {  
      ! @. X6 \4 Q5 J" z( k
      9 b' j% i3 Z" o7 H- }
    • 2 ^$ \' _4 {; X

      & O( u& E" O! B- y& |      p=(PCB *)malloc(sizeof(PCB));  
        @$ @1 m8 m' Q. t
      ' Z, X( [% R+ o+ r" f6 J

    • * ~3 T4 B5 K7 h+ t
      5 W! n4 u% H( g) m7 s) z- A. R- n
            scanf("%s",na);  & V% G- M  A4 [, @! k; i* `

      2 }- N$ @  B2 g% C( g. D- P: W$ `
    • 2 I/ q( Y3 T: O. z& T" s

      ( t7 u/ Q+ @5 S      scanf("%d",&time);  
      " t' J2 e' p. H9 _* e
      9 l$ X9 L/ K7 j3 |+ I9 e8 K

    • 9 ^9 ~& I, d$ |8 X

      ( b) S: p  x4 M8 e! V" T2 w      strcpy(p->name,na);  
      ! R5 A) d1 X( w& o. T. q

      1 X+ y! _+ H/ T% R5 J( {
    • 3 h- d% G( q6 A$ ~

      ( a1 v- N5 x$ D  d      p->cputime=0;  - Q5 u4 |9 v/ Q: i+ x+ X
      - u3 y+ {9 e: w7 W$ x$ _
    • / _( s2 n2 m9 z+ V, O
      . `% T. C3 b& W" @# j' c
            p->needtime=time;  
      4 l4 u: Z8 d, M/ n

      * c, {4 }) u% p# ^1 G/ E
    • 0 s4 s% {- [( f: Q

      ( L3 R8 J+ f2 |/ Q. m      p->state='w';  
      % W+ ]; d# ~" F6 O& g  h
      0 F" c! I8 m' q# h( N5 o! }
    •   q6 p. ^" A) m$ T6 i8 t
      + P* ?# u$ h. f! X- a) u8 `) M
            p->prio=50-time;  : h: j- h1 K$ x+ n: t: r  e  z

      " q3 O6 _' Q4 _8 V
    • ) e5 Q1 E0 y' \

      8 ^1 J/ t+ u/ O2 u      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
      6 h9 c/ P! _5 H0 l& K5 _% K

      6 T5 ]) l/ F# B& |" f, r
    • % f5 g' p; w# b. B
      " x8 {, T2 P0 S, Y
           insert1(p);  
      ( j9 \& N( T! e0 @7 [. }; Z

      3 z4 ^2 j2 P, Z; Q( R( G8 w
    • $ o  Q5 h9 T6 Y' [. ^

      0 B0 l9 c; N9 R6 b& D      else  : e. Y/ P2 O6 T+ B+ o  G

      9 K) |, K! h- K* I  [

    • ; J- [8 ]/ b9 p* R% R3 S+ K. U" s: g

      ' ~4 a8 Y% H' ?; R2 N5 ~; N) i      {  
      6 N# \( \, D9 \& o  D5 X

      * x6 d; t( _( {  k

    • ( {, K7 s3 ^3 P) I

      . G6 E8 e# {& X) t     p->next=ready; /*创建就绪队列的第一个PCB*/  
      , N' M) ^1 ]$ b6 r5 s% ?
      # m# B$ d; Z2 I* e( \) `

    • ! b7 \3 t7 q2 o+ \* n$ w4 o" |% q( `
      ( u1 D3 l. Q8 \% [1 C3 c" t/ e
           ready=p;  
      5 N4 p* j. x. ?. a& D5 `
      8 M: k8 F- M$ k) {# N
    • 1 ~9 J, v; e: D9 E( O
      + z* `: f, ]7 B; h7 {6 u
            }  
      2 d6 A) A- _2 V) n+ u  W9 J' @
      ' a- F% t3 h4 A% s0 X! Z

    • 0 I! I2 ~5 N: d8 J& o8 Z( p

      ' {& u( z2 {9 `8 ]   }  
      4 a3 k: v/ ]: a+ r9 R- y  I7 H
      ! g  }) `0 O1 D
    • ! _3 o0 u) y2 H) P9 ?4 K
      * Q% @) o: E9 B2 n6 N: O& X6 \" y
         printf("          优先数算法输出信息:\n");  
      + @+ F! A! ?. i1 m6 G. q( \/ C' f
      : e. v, f: s: C, s3 x. N- W
    • 3 m0 S0 ]7 O0 o/ Q0 ]. \! @
      : I6 k, S1 q* m6 }+ g( i$ _
         printf("************************************************\n");  % W  k. |$ o3 L' y; S- x
      3 }$ @! P/ p# O/ P3 f! P/ O4 N

    • 2 `0 k& W: k! i! t. ^
      5 W( L! D4 o/ Z
         prt(alg);  /*输出进程PCB信息*/  
      & |% M& [/ g: \" {8 Q7 b
      2 a+ H0 }! x* [5 m

    • + A1 L# n6 Z' p& E" Q1 l
      * D- ], [" L9 a$ F
         run=ready; /*将就绪队列的第一个进程投入运行*/  + x- U# j" Z$ @5 t4 y4 Y  ], i
      - ]3 E7 H* T1 T1 p7 W/ o) v
    • , P8 h+ Z( A0 Q# n5 h

      8 I- c& S& m" T+ ]% N   ready=ready->next;  
      5 K4 ]5 A6 P# q4 i4 s* V& y- M
      2 L" T) G7 M6 d3 Q  z* f( c) J
    • ! A, O- U$ g* u1 a6 [2 c4 S
        m! [  l9 T4 I' |& J" x
         run->state='R';  + K9 }6 b! q4 _8 n! r! P5 P& o

      ! ~2 G8 r7 J! v4 v: R! }4 H4 n
    • * d1 w" m* r5 m0 w
      9 f6 Y! V% Q4 T4 C
      }  ( `4 a  l- Y) F* S/ s8 E

      8 w5 p! A# M5 s5 ]) }

    • + f2 O3 T5 W: e+ Q9 ~3 Z

      6 J! p# B2 ?) X% s5 y/*优先数调度算法*/  5 A+ X6 b8 `# K  {
      7 Z# \. \4 S, m& F: `7 x6 ~
    • 3 ?/ @! L; t5 D) U9 [7 i  _

      ) O, j  _5 ]" ~9 F2 u2 lpriority(char alg)  $ w, E7 i) }# C$ t1 X+ \3 S8 ^

      " s& J2 }# Z1 H  w* ]2 Z
    • . A$ \/ E( j7 v6 \0 F$ f) N
      ) e4 H1 [: b2 L/ F$ j3 ]% k
      {  
      ! R  c4 e& H/ a2 ?8 L
      ! Q: [# U- x2 E; O
    • 8 n8 \, P& P9 \7 }

      * z; a2 ~- j9 d5 k( Y& q. V   while(run!=NULL)  /*当运行队列不空时,有进程正在运行*/  ) V1 c0 }+ t/ n0 _: q) z& z

        s7 |4 y" `: k5 \, `. u

    • 1 I" a: s+ I- R% a' J: _

      + U7 N' P2 b) q# ?9 `   {  
      3 @2 g! l1 g) j  i
      , v5 j2 W$ |7 P1 ]: q9 f
    • 5 R. S/ p% J" P! A8 j0 P

      2 I" v4 q! o7 W' b      run->cputime=run->cputime+1;  
      ' u0 _& q, x2 {; i3 f5 Q$ O
      4 C5 B( N: c' ~" u

    • + H; X7 A  e  V0 Y6 S
      , i( B! k: w! E7 s9 J7 a  \, Q
            run->needtime=run->needtime-1;  ( D4 [7 E7 m% y! O& Y& h

      1 M7 L% H9 y# B8 d

    • . e: I+ w, m( v2 w
      - U1 h8 b: U4 E! |8 Q( H
            run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
      $ w1 O/ E5 p0 P2 v& b5 V& f3 _

      9 h: T. E- y# S* w2 ^4 L' }

    • 0 P% E$ X" Z  i7 R. P

      3 X% k0 l8 n9 {" ]" r% {* _      PCB *p;
      2 ~; j/ U; [# L5 D$ r

      , j3 p% y* j% ~+ w& [% V' C4 ?
    • # H) v- `7 Z. B

      7 }/ F$ }/ X/ N1 Z# c      p=ready;
      ! j9 t+ U; L' `: r
      / z. Y  ~" U9 i  C, d9 f
    • 0 d4 v) q' e5 V7 K  @7 K

      $ |) Q7 b1 w* T3 f1 m" U      while(p!=NULL)  ( ^4 X7 \! n! M+ Y, q
      # `' p9 w0 {1 T* h8 m0 y+ F* |

    • $ y/ L/ l6 S' T! t+ a/ j

      " c; a; r, y$ m9 Z      {  
      - ?; I- \# Z- [; P. S$ O7 ?

      0 t# O$ `% g+ ], p) z  K/ P
    • 4 J% ^7 z- W( `% I# f0 i5 N/ M' ]! f
      ; P' Y+ a+ B* t# Z
                p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/    6 I( s5 t* d# h8 P: S; x9 o
      0 Z% P2 X% V6 u& `; ^
    • + m# Y& U( n6 }5 l! r
      * v8 X! U# V5 c, m8 z
                p=p->next;  . w9 ^1 w7 ^# G% V

      ; k5 M, {' I: O2 h9 Y3 P/ x
    • * @2 l/ o# i- ^( p1 C9 w
      ' m. B( D  j3 g4 }* ?
            }  + T9 @9 l% W1 ]+ L  f$ u( |

      4 _# m4 i0 [2 Y' p: C: o

    • 9 V0 ^- V" f: f/ G" r

      # q, h5 a( I  H# I1 p; {7 _      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
      2 d. S! x$ G# h2 G- c1 r

      + ^3 ^5 Z, e1 t+ O7 \& ~
    • + K! q  d) `# L
      . S/ j; w1 I0 C3 y
            {  
      1 T; w" {6 G6 D
      0 D6 \: e* e" r: U" d& }4 s$ u

    • & B! t2 J, s9 ]( c$ g

      1 T! Q1 F7 ^- Y2 K7 t: A; n         run->next=finish;  
      2 R# \. r. ?. V2 U
      2 ^: y: L* V% H

    • ! H( N4 A/ q# r/ L  W

      4 [" W& p7 M, j* `% K& v: y6 b9 x0 t         finish=run;  6 _+ a  M( k" s7 k9 x1 J  S

      1 e6 Y( s1 w. @

    • / a) O5 {, M* Y4 h6 U+ O# T$ b+ D) ?
      7 p: X6 q1 ^3 M+ k- o& t% u/ z
               run->state='F';  /*置状态为完成态*/  
      % z6 N+ w% l0 |, i4 U

      3 o$ m) Y! _$ A9 S, d+ |
    • 0 \" y6 E6 p, z1 D! c9 ^* X6 u( U; a

      : c; c3 H. q  w3 q         run=NULL;  /*运行队列头指针为空*/  
      ; A3 i9 z* s- @0 O& X/ Z
      6 ^+ D3 L5 a3 H1 h/ ^) X
    • 9 R' z! q1 [6 @

      . c2 b; r  I3 h( w8 U! l         if(ready!=NULL) /*如就绪队列不空*/
      1 |9 z7 e4 I5 j5 u

      9 Z  r* ^. ]6 a% A3 S/ R3 J
    • . b7 y) {& K/ i: z( x/ Q

        z" E% |' y2 K7 e! m3 Q         {  
      2 _" p! }5 H" M) a

      ; F  C9 C' o% e( I, W

    • : [* k3 j' _; ^$ ?6 F; v8 A/ `0 K
        X( l. x' x6 X. \. L4 a, z
                  firstin(); /*将就绪对列的第一个进程投入运行*/  5 B* Z6 I+ y1 C% Q( p  B' K" {
      5 Y5 a/ Z9 q; y- T. a/ k
    • , ?* d) L0 _! x8 v

      6 v( I* [) A8 T9 d" l* x' V         }
      9 S/ J) ?7 E1 [- ?: A. [" N0 w
      2 O+ ?; d0 i% x/ n- p2 r
    • + |9 n; p' i% A

      ' y8 T% X0 g+ o$ e$ b" t      }  3 ^6 l( q% F/ v- u! {

      # T: k8 H: Q0 I; m5 Z
    • 7 b9 a5 \+ z) U& r. D& Z. c1 ]# L
      # L7 C% [. m# B2 W, s: U6 V
            else /*没有运行完同时优先数不是最大,则将其变为就绪态插入到就绪队列*/  ! c7 }$ k5 u* O" U
        X6 y' f7 Q) z1 B' q  m- C, y

    • ; M  {1 h) X1 I% K3 b

      ' x  R( _4 ^4 ]8 ]$ Y. z' x     if((ready!=NULL)&&(run->prio<ready->prio))  
      0 Z2 D8 _( o1 g' [( z, M7 B

      4 T5 I) J! s* z. b7 Z

    • 0 l1 b. k5 \& F% V% H- t6 o

      : P2 p* Y/ z" @0 f2 O     {  
      1 ?  p+ K$ Y# N; ~2 t7 E- c0 k

      % d: L0 y0 D& B+ V( D- [

    • 0 V$ V% r( _0 p, d
      ' _) p/ C6 q7 N* I, D
              run->state='W';  ) {# k0 J6 |; x% l

      ' o4 _: f3 J! d) b; t; ~

    • % n! |" w& x' p1 p, g' _
      6 W7 E( S/ _5 V' P) z2 E9 U# V( n
              insert1(run);  6 g- ^4 @, l; ?  U/ ]  N
      7 y$ r! Q3 B0 d; f1 L; }
    • ; ~) w- h, J( _, y8 m5 c  s

      ( L& z! m4 s. r4 I- a        firstin(); /*将就绪队列的第一个进程投入运行*/  7 `8 S6 V( I$ j# C: I
      7 C3 ~. E" ~& t7 S9 y8 T

    • 7 U: X) g, P" x9 m

      2 l- S+ d4 n/ q- e4 D     }  
      9 R8 ~2 d5 T3 g" N) F& ?5 L

      ( D( ]# D: D0 I6 u0 Q# `
    • . a: g( L" M1 G! ?+ T# M

      / a  z/ l$ Z0 ?1 N  L      prt(alg); /*输出进程PCB信息*/  
        \, H( ~8 q" l) Z( V  w# @

      7 y  x4 v5 c* A  X
    • 9 d0 {3 v  j8 k% A6 {, F

      + h2 ^# Q7 B  j' [, [   }  - k% w2 O5 n+ P. g. I0 i' t

      - T* t- L% y8 Z8 R. ~2 `) f4 S8 _

    • . |9 V7 y7 U2 N, O. C

      - o7 o6 e! b8 w( L( x) u+ `0 O4 N}  ) h' Q% U& [% R; B5 K- n
      ' X& u7 x3 A8 u% G: J6 ~: P+ g
    • : q% q1 y: w9 A: y4 O, _- F
      ! j, y. y. l, r6 a
      /*主函数*/  5 Z& ?7 ~- P% f+ x# i: t

      7 o8 ?, s* R' g& @0 z
    • 9 }8 ?& J  Y" g9 A! ?
      0 A2 ?: b( K# f5 s+ U0 ~! n
      main()  
      3 U# k' Z( Q; F

      0 m% ~, G0 j6 L6 c3 f% Y0 g9 N- q( i

    • 1 j% W. S' Q5 |9 M2 J7 G5 ^' i

      ) S2 r) ^/ n3 r{  : j4 j8 |+ A' o! H7 \8 R( Q
      5 `- u$ z! J  f7 `3 N
    • 5 X! ?, h9 j/ `8 ~% k- a  S

      4 m& X. k& k; R- {   char algo;  /*算法标记*/  
      . G% W/ ~) X5 @$ @: s2 W  v
      , O1 v$ z9 R9 c+ E* f" J5 H

    • , p0 n5 q- c5 c

      + b; p  e- ^! x( N5 G   printf("输入P确定算法:优先数算法\n");  , E8 U3 f  ?% ^# x% \$ f; b2 K

      . q' q8 v% [0 m1 j

    • # _- k: U3 A& \+ ]; k

      $ Y5 x) H4 P. {# Y   scanf("%c",&algo); /*输入字符确定算法*/  / C* o- G0 E7 H3 K0 S; \
      . y" h  W7 m( E  ^: d8 l1 W- W6 g

    • # h3 M2 j8 J( H. \' B! k

      ) X  k' l; I; ~   printf("输入进程数:\n");  
      & g0 t+ J, Y0 \/ L( V1 z$ Q) {
      6 w" S: ~1 b/ _" J

    • & M) m: e; `/ |8 \
      0 d0 I4 Z+ O0 c, M& Q- Q: A
         scanf("%d",&N); /*输入进程数*/  
      5 j7 }  c' F3 U+ P$ T

      2 K1 a! U/ R% Y$ }/ G! ?8 R) ~- O

    • ( ]4 q* P& `# U2 i# i

      ; e/ L9 m4 E3 P7 h) Y7 `7 ?- Q   if(algo=='P'||algo=='p')  
      ' o; g  w- X/ O/ y/ {& i8 o1 V
      2 n0 H: Q; C; _& h  y, v

    • 8 u1 C' n( ]% v

      : f8 A" b; l, k% e; `   {  * L- N3 l( [9 j1 ]* ]3 r

      7 d9 K/ S% q7 i& B( \0 Y2 o# g  L# e
    • ( u, _" ~* h( _4 M3 g$ y
      6 D8 e6 o" _& e9 x6 `+ J+ `: x
            create(algo); /*优先数法*/  
      : |* i# Z$ b0 x: t. h  c
      ' i$ f6 R! s- V0 ^
    • / z$ O/ i: ^" N( M4 B

      $ a# e: y# O: p2 P/ ?      priority(algo);  
      # G8 F( N- \( X7 {8 a0 x: o
      . [9 H% q6 K5 R+ v9 }0 L
    • 3 f% b. ?; u4 C" c/ ]
      9 M( g% V+ Z) G7 b. X# f6 g6 W
         } ; J3 Q* b4 N7 C7 T
      " T7 C9 U+ c) Q$ ^
    • ( l- G# ]" i/ h, \

      . D; l& Z& s& h; Y) l}
      ! D) F; t1 _& x4 `

      / O( T1 j. T" n4 R! j! T& ?2 W
      & G7 V# t( ^- o: K9 h


    $ w+ a2 J. M9 O( H% @# H输出结果:
    % i2 q9 \% B+ f$ v3 p

    8 m7 S, O& Y6 A2 p
    原文:https://blog.csdn.net/weixin_40962955/article/details/80072769

    ! {" \* C$ D, ^7 e
    ; `8 `/ f) w0 c% @# N$ ]: W% L& f6 U
    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:51 , Processed in 0.404707 second(s), 51 queries .

    回顶部