fork download
copy 
  1. #include <stdio.h>
  2.  
  3. #define MAX_PROCESS 5
  4. #define TIME_SLICE 1//时间片大小（单位时间）
  5. // 进程状态
  6. typedef enum {
  7.     RUNNING = 1,
  8.     READY = 0,
  9.     FINISHED = -1
  10. } State;
  11.  
  12. // 进程控制块结构体
  13. typedef struct {
  14.     int pid;            // 进程ID
  15.     int priority;       // 优先级
  16.     int need_time;      // 需要的运行时间
  17.     int arrival_time;   // 到达时间
  18.     int start_time;     // 开始时间
  19.     int finish_time;    // 完成时间
  20.     State state;        // 状态
  21. } PCB;
  22.  
  23. // 全局变量
  24. PCB processes[MAX_PROCESS];
  25. int current_time = 0;
  26.  
  27. // 初始化进程数据
  28. void init_processes() {
  29.     // 数据格式：{pid, priority, need_time, arrival_time, start_time, finish_time, state}
  30.     // 修正后：每个进程只保留7个数据
  31.     processes[0] = (PCB){1, 2, 3, 4, -1, 0, READY};
  32.     processes[1] = (PCB){2, 5, 2, 2, -1, 0, READY};
  33.     processes[2] = (PCB){3, 1, 4, 1, -1, 0, READY};
  34.     processes[3] = (PCB){4, 3, 3, 3, -1, 0, READY};
  35.     processes[4] = (PCB){5, 4, 1, 0, -1, 0, READY};
  36. }
  37.  
  38. // 检查是否所有进程都已完成
  39. int all_finished() {
  40.     for (int i = 0; i < MAX_PROCESS; i++) {
  41.         if (processes[i].state != FINISHED) {
  42.             return 0; // 还有未完成的
  43.         }
  44.     }
  45.     return 1; // 全部完成
  46. }
  47.  
  48. // 选择优先级最高的进程
  49. int select_highest_priority() {
  50.     int selected = -1;
  51.     int max_priority = -1;
  52.  
  53.     for (int i = 0; i < MAX_PROCESS; i++) {
  54.         // 检查进程是否已到达且处于就绪状态
  55.         if (processes[i].state == READY && processes[i].arrival_time <= current_time) {
  56.             if (processes[i].priority > max_priority) {
  57.                 max_priority = processes[i].priority;
  58.                 selected = i;
  59.             }
  60.             // 优先级相同时，比较 PID (或其他规则，这里保持原代码逻辑)
  61.             else if (processes[i].priority == max_priority) {
  62.                 if (selected != -1 && processes[i].pid < processes[selected].pid) {
  63.                     selected = i;
  64.                 }
  65.             }
  66.         }
  67.     }
  68.     return selected;
  69. }
  70.  
  71. int main() {
  72.     init_processes();
  73.  
  74.     printf("---进程调度模拟过程---\n");
  75.     printf("调度算法: 最高优先树优先(抢占式,动态优先级)\n");
  76.     printf("动态规则: 每获得一次CPU,优先数减1\n\n");
  77.  
  78.     int last_selected = -1;
  79.  
  80.     // 主调度循环
  81.     while (!all_finished()) {
  82.         int selected = select_highest_priority();
  83.  
  84.         // 如果没有进程可运行（可能是还没到达），时间前移
  85.         if (selected == -1) {
  86.             current_time++;
  87.             last_selected = -1; // 重置上一次选择
  88.             continue;
  89.         }
  90.  
  91.         // 记录开始时间
  92.         if (processes[selected].start_time == -1) {
  93.             processes[selected].start_time = current_time;
  94.         }
  95.  
  96.         // 进程切换提示
  97.         if (last_selected != selected) {
  98.             printf("->时刻%d: 选中进程P%d (优先级=%d, 剩余时间=%d)\n",
  99.                    current_time, processes[selected].pid, processes[selected].priority, processes[selected].need_time);
  100.         }
  101.  
  102.         // 执行进程 (运行一个时间单位)
  103.         processes[selected].state = RUNNING;
  104.         processes[selected].need_time--;
  105.         current_time++;
  106.  
  107.         // 动态优先级调整：运行一次后优先级减1
  108.         if (processes[selected].priority > 0) {
  109.             processes[selected].priority--;
  110.         }
  111.  
  112.         // 检查进程是否完成
  113.         if (processes[selected].need_time == 0) {
  114.             processes[selected].state = FINISHED;
  115.             processes[selected].finish_time = current_time;
  116.             printf("进程P%d已完成! (完成时刻=%d)\n", processes[selected].pid, current_time);
  117.         } else {
  118.             // 未完成则变回就绪状态
  119.             processes[selected].state = READY;
  120.         }
  121.  
  122.         last_selected = selected;
  123.     }
  124.  
  125.     // 统计与输出结果
  126.     printf("\n---调度完成---\n");
  127.     printf("进程\t到达时间\t开始时间\t总运行时间\t完成时间\t周转时间\n");
  128.  
  129.     int total_turnaround = 0;
  130.     for (int i = 0; i < MAX_PROCESS; i++) {
  131.         // 计算周转时间 = 完成时间 - 到达时间
  132.         int turnaround = processes[i].finish_time - processes[i].arrival_time;
  133.         total_turnaround += turnaround;
  134.  
  135.         // 原始总运行时间 = 需要时间 + (初始需要时间 - 剩余时间，这里简单用初始need_time推算)
  136.         // 注意：因为 need_time 在循环中被减为 0 了，这里为了演示，假设初始 need_time 已知或需额外字段存储
  137.         // 在本代码中，由于初始化数据是一样的，且被修改了，这里打印 finish - start 近似作为运行时间展示
  138.         int run_time = processes[i].finish_time - processes[i].start_time;
  139.  
  140.         printf("P%d\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n",
  141.                processes[i].pid,
  142.                processes[i].arrival_time,
  143.                processes[i].start_time,
  144.                run_time,
  145.                processes[i].finish_time,
  146.                turnaround);
  147.     }
  148.  
  149.     printf("\n平均周转时间: %.2f\n", (float)total_turnaround / MAX_PROCESS);
  150.  
  151.     return 0;
  152. }
Success #stdin #stdout 0s 5288KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
---进程调度模拟过程---
调度算法: 最高优先树优先(抢占式,动态优先级)
动态规则: 每获得一次CPU,优先数减1

->时刻0: 选中进程P5 (优先级=4, 剩余时间=1)
进程P5已完成! (完成时刻=1)
->时刻1: 选中进程P3 (优先级=1, 剩余时间=4)
->时刻2: 选中进程P2 (优先级=5, 剩余时间=2)
进程P2已完成! (完成时刻=4)
->时刻4: 选中进程P4 (优先级=3, 剩余时间=3)
->时刻5: 选中进程P1 (优先级=2, 剩余时间=3)
->时刻6: 选中进程P4 (优先级=2, 剩余时间=2)
->时刻7: 选中进程P1 (优先级=1, 剩余时间=2)
->时刻8: 选中进程P4 (优先级=1, 剩余时间=1)
进程P4已完成! (完成时刻=9)
->时刻9: 选中进程P1 (优先级=0, 剩余时间=1)
进程P1已完成! (完成时刻=10)
->时刻10: 选中进程P3 (优先级=0, 剩余时间=3)
进程P3已完成! (完成时刻=13)

---调度完成---
进程	到达时间	开始时间	总运行时间	完成时间	周转时间
P1	4		5		5		10		6
P2	2		2		2		4		2
P3	1		1		12		13		12
P4	3		4		5		9		6
P5	0		0		1		1		1

平均周转时间: 5.40
https://ideone.com/YkWCoF
language:
C (gcc 8.3)
created:
1 day ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!