fork(2) download
copy 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. #define MAX_PROCESSES 10
  6.  
  7. // 进程状态枚举
  8. typedef enum {
  9.     READY,      // 就绪态
  10.     RUNNING,    // 运行态
  11.     FINISHED    // 完成态
  12. } ProcessState;
  13.  
  14. // 进程控制块 PCB
  15. typedef struct {
  16.     char name[20];          // 进程名
  17.     int priority;           // 优先数（数值越大优先级越高）
  18.     int needTime;           // 需要运行的时间
  19.     int runTime;            // 已运行时间
  20.     int waitTime;           // 等待时间
  21.     ProcessState state;     // 状态
  22.     int arrivalTime;        // 到达时间
  23. } PCB;
  24.  
  25. PCB processes[MAX_PROCESSES];
  26. int processCount = 0;
  27.  
  28. // 显示进程信息表头
  29. void printHeader() {
  30.     printf("----------------------------------------------------------------\n");
  31.     printf("| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |\n");
  32.     printf("----------------------------------------------------------------\n");
  33. }
  34.  
  35. // 显示单个进程信息
  36. void printProcess(PCB *p) {
  37.     char *stateStr;
  38.     switch(p->state) {
  39.         case READY:    stateStr = "就绪态"; break;
  40.         case RUNNING:  stateStr = "运行态"; break;
  41.         case FINISHED: stateStr = "完成态"; break;
  42.         default:       stateStr = "未知";   break;
  43.     }
  44.     printf("| %6s | %6d | %8d | %8d | %8d | %6s |\n",
  45.            p->name, p->priority, p->needTime, p->runTime, p->waitTime, stateStr);
  46. }
  47.  
  48. // 显示所有进程
  49. void printAllProcesses() {
  50.     printHeader();
  51.     for (int i = 0; i < processCount; i++) {
  52.         printProcess(&processes[i]);
  53.     }
  54.     printf("----------------------------------------------------------------\n");
  55. }
  56.  
  57. // 显示就绪队列
  58. void printReadyQueue() {
  59.     printf("\n【当前就绪队列状态】\n");
  60.     printf("就绪队列: ");
  61.     int hasReady = 0;
  62.     for (int i = 0; i < processCount; i++) {
  63.         if (processes[i].state == READY) {
  64.             if (hasReady) printf(" -> ");
  65.             printf("%s(优先级:%d)", processes[i].name, processes[i].priority);
  66.             hasReady = 1;
  67.         }
  68.     }
  69.     if (!hasReady) printf("空");
  70.     printf("\n");
  71. }
  72.  
  73. // 按优先级排序（冒泡排序，降序）
  74. void sortByPriority() {
  75.     for (int i = 0; i < processCount - 1; i++) {
  76.         for (int j = 0; j < processCount - i - 1; j++) {
  77.             // 只比较就绪态的进程，且按优先级降序排列
  78.             if (processes[j].state == READY && processes[j+1].state == READY) {
  79.                 if (processes[j].priority < processes[j+1].priority) {
  80.                     PCB temp = processes[j];
  81.                     processes[j] = processes[j+1];
  82.                     processes[j+1] = temp;
  83.                 }
  84.             }
  85.         }
  86.     }
  87. }
  88.  
  89. // 找到优先级最高的就绪进程
  90. int findHighestPriority() {
  91.     int maxPriority = -999;
  92.     int index = -1;
  93.     for (int i = 0; i < processCount; i++) {
  94.         if (processes[i].state == READY && processes[i].priority > maxPriority) {
  95.             maxPriority = processes[i].priority;
  96.             index = i;
  97.         }
  98.     }
  99.     return index;
  100. }
  101.  
  102. // 增加等待进程的等待时间和优先级（可选：等待过久提升优先级）
  103. void updateWaitingProcesses() {
  104.     for (int i = 0; i < processCount; i++) {
  105.         if (processes[i].state == READY) {
  106.             processes[i].waitTime++;
  107.             // 如果等待时间超过3个时间片，优先数加1（防止饥饿）
  108.             if (processes[i].waitTime > 3 && processes[i].priority < 10) {
  109.                 processes[i].priority++;
  110.                 printf("  >> %s 等待过久，优先级提升为 %d\n", 
  111.                        processes[i].name, processes[i].priority);
  112.             }
  113.         }
  114.     }
  115. }
  116.  
  117. // 调度一个时间片
  118. void scheduleOneSlice() {
  119.     int idx = findHighestPriority();
  120.  
  121.     if (idx == -1) {
  122.         printf("\n没有就绪的进程，调度结束！\n");
  123.         return;
  124.     }
  125.  
  126.     // 将选中的进程设为运行态
  127.     processes[idx].state = RUNNING;
  128.  
  129.     printf("\n========================================\n");
  130.     printf("【调度进程: %s】 优先级: %d, 还需时间: %d\n", 
  131.            processes[idx].name, processes[idx].priority, processes[idx].needTime);
  132.     printf("========================================\n");
  133.  
  134.     // 运行一个时间片
  135.     processes[idx].runTime++;
  136.     processes[idx].needTime--;
  137.  
  138.     // 显示运行中的状态
  139.     printAllProcesses();
  140.     printReadyQueue();
  141.  
  142.     // 动态优先数：运行后优先数减1
  143.     processes[idx].priority--;
  144.  
  145.     // 检查是否完成
  146.     if (processes[idx].needTime <= 0) {
  147.         processes[idx].state = FINISHED;
  148.         printf("\n>>> 进程 %s 运行完毕！\n", processes[idx].name);
  149.     } else {
  150.         // 未完成，回到就绪态
  151.         processes[idx].state = READY;
  152.         printf("\n>>> 进程 %s 时间片用完，回到就绪队列（优先级降为 %d）\n", 
  153.                processes[idx].name, processes[idx].priority);
  154.     }
  155.  
  156.     // 更新等待进程
  157.     updateWaitingProcesses();
  158. }
  159.  
  160. // 检查是否所有进程都已完成
  161. int allFinished() {
  162.     for (int i = 0; i < processCount; i++) {
  163.         if (processes[i].state != FINISHED) {
  164.             return 0;
  165.         }
  166.     }
  167.     return 1;
  168. }
  169.  
  170. // 初始化进程（直接写入程序中，无需输入）
  171. void initProcesses() {
  172.     // 进程1: aa
  173.     strcpy(processes[0].name, "aa");
  174.     processes[0].priority = 5;
  175.     processes[0].needTime = 8;
  176.     processes[0].runTime = 0;
  177.     processes[0].waitTime = 0;
  178.     processes[0].state = READY;
  179.     processes[0].arrivalTime = 0;
  180.  
  181.     // 进程2: bb
  182.     strcpy(processes[1].name, "bb");
  183.     processes[1].priority = 3;
  184.     processes[1].needTime = 6;
  185.     processes[1].runTime = 0;
  186.     processes[1].waitTime = 0;
  187.     processes[1].state = READY;
  188.     processes[1].arrivalTime = 0;
  189.  
  190.     // 进程3: cc
  191.     strcpy(processes[2].name, "cc");
  192.     processes[2].priority = 8;
  193.     processes[2].needTime = 10;
  194.     processes[2].runTime = 0;
  195.     processes[2].waitTime = 0;
  196.     processes[2].state = READY;
  197.     processes[2].arrivalTime = 0;
  198.  
  199.     processCount = 3;
  200. }
  201.  
  202. int main() {
  203.     printf("============================================================\n");
  204.     printf("        进程调度模拟程序 - 最高优先数优先算法\n");
  205.     printf("============================================================\n");
  206.     printf("\n【算法说明】\n");
  207.     printf("  - 采用动态优先数调度\n");
  208.     printf("  - 每次调度优先级最高的就绪进程\n");
  209.     printf("  - 运行一个时间片后优先数减1\n");
  210.     printf("  - 等待超3个时间片的进程优先级+1（防止饥饿）\n\n");
  211.  
  212.     // 初始化进程
  213.     initProcesses();
  214.  
  215.     printf("【初始进程信息】\n");
  216.     printAllProcesses();
  217.     printReadyQueue();
  218.  
  219.     // 开始调度
  220.     int slice = 1;
  221.     while (!allFinished()) {
  222.         printf("\n\n******************** 第 %d 次调度 ********************", slice++);
  223.         scheduleOneSlice();
  224.     }
  225.  
  226.     printf("\n============================================================\n");
  227.     printf("              所有进程调度完成！\n");
  228.     printf("============================================================\n");
  229.  
  230.     printf("\n【最终进程状态】\n");
  231.     printAllProcesses();
  232.  
  233.     return 0;
  234. }
Success #stdin #stdout 0s 5316KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
============================================================
        进程调度模拟程序 - 最高优先数优先算法
============================================================

【算法说明】
  - 采用动态优先数调度
  - 每次调度优先级最高的就绪进程
  - 运行一个时间片后优先数减1
  - 等待超3个时间片的进程优先级+1（防止饥饿）

【初始进程信息】
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      5 |        8 |        0 |        0 | 就绪态 |
|     bb |      3 |        6 |        0 |        0 | 就绪态 |
|     cc |      8 |       10 |        0 |        0 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: aa(优先级:5) -> bb(优先级:3) -> cc(优先级:8)


******************** 第 1 次调度 ********************
========================================
【调度进程: cc】 优先级: 8, 还需时间: 10
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      5 |        8 |        0 |        0 | 就绪态 |
|     bb |      3 |        6 |        0 |        0 | 就绪态 |
|     cc |      8 |        9 |        1 |        0 | 运行态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: aa(优先级:5) -> bb(优先级:3)

>>> 进程 cc 时间片用完，回到就绪队列（优先级降为 7）


******************** 第 2 次调度 ********************
========================================
【调度进程: cc】 优先级: 7, 还需时间: 9
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      5 |        8 |        0 |        1 | 就绪态 |
|     bb |      3 |        6 |        0 |        1 | 就绪态 |
|     cc |      7 |        8 |        2 |        1 | 运行态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: aa(优先级:5) -> bb(优先级:3)

>>> 进程 cc 时间片用完，回到就绪队列（优先级降为 6）


******************** 第 3 次调度 ********************
========================================
【调度进程: cc】 优先级: 6, 还需时间: 8
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      5 |        8 |        0 |        2 | 就绪态 |
|     bb |      3 |        6 |        0 |        2 | 就绪态 |
|     cc |      6 |        7 |        3 |        2 | 运行态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: aa(优先级:5) -> bb(优先级:3)

>>> 进程 cc 时间片用完，回到就绪队列（优先级降为 5）


******************** 第 4 次调度 ********************
========================================
【调度进程: aa】 优先级: 5, 还需时间: 8
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      5 |        7 |        1 |        3 | 运行态 |
|     bb |      3 |        6 |        0 |        3 | 就绪态 |
|     cc |      5 |        7 |        3 |        3 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: bb(优先级:3) -> cc(优先级:5)

>>> 进程 aa 时间片用完，回到就绪队列（优先级降为 4）
  >> aa 等待过久，优先级提升为 5
  >> bb 等待过久，优先级提升为 4
  >> cc 等待过久，优先级提升为 6


******************** 第 5 次调度 ********************
========================================
【调度进程: cc】 优先级: 6, 还需时间: 7
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      5 |        7 |        1 |        4 | 就绪态 |
|     bb |      4 |        6 |        0 |        4 | 就绪态 |
|     cc |      6 |        6 |        4 |        4 | 运行态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: aa(优先级:5) -> bb(优先级:4)

>>> 进程 cc 时间片用完，回到就绪队列（优先级降为 5）
  >> aa 等待过久，优先级提升为 6
  >> bb 等待过久，优先级提升为 5
  >> cc 等待过久，优先级提升为 6


******************** 第 6 次调度 ********************
========================================
【调度进程: aa】 优先级: 6, 还需时间: 7
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      6 |        6 |        2 |        5 | 运行态 |
|     bb |      5 |        6 |        0 |        5 | 就绪态 |
|     cc |      6 |        6 |        4 |        5 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: bb(优先级:5) -> cc(优先级:6)

>>> 进程 aa 时间片用完，回到就绪队列（优先级降为 5）
  >> aa 等待过久，优先级提升为 6
  >> bb 等待过久，优先级提升为 6
  >> cc 等待过久，优先级提升为 7


******************** 第 7 次调度 ********************
========================================
【调度进程: cc】 优先级: 7, 还需时间: 6
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      6 |        6 |        2 |        6 | 就绪态 |
|     bb |      6 |        6 |        0 |        6 | 就绪态 |
|     cc |      7 |        5 |        5 |        6 | 运行态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: aa(优先级:6) -> bb(优先级:6)

>>> 进程 cc 时间片用完，回到就绪队列（优先级降为 6）
  >> aa 等待过久，优先级提升为 7
  >> bb 等待过久，优先级提升为 7
  >> cc 等待过久，优先级提升为 7


******************** 第 8 次调度 ********************
========================================
【调度进程: aa】 优先级: 7, 还需时间: 6
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      7 |        5 |        3 |        7 | 运行态 |
|     bb |      7 |        6 |        0 |        7 | 就绪态 |
|     cc |      7 |        5 |        5 |        7 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: bb(优先级:7) -> cc(优先级:7)

>>> 进程 aa 时间片用完，回到就绪队列（优先级降为 6）
  >> aa 等待过久，优先级提升为 7
  >> bb 等待过久，优先级提升为 8
  >> cc 等待过久，优先级提升为 8


******************** 第 9 次调度 ********************
========================================
【调度进程: bb】 优先级: 8, 还需时间: 6
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      7 |        5 |        3 |        8 | 就绪态 |
|     bb |      8 |        5 |        1 |        8 | 运行态 |
|     cc |      8 |        5 |        5 |        8 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: aa(优先级:7) -> cc(优先级:8)

>>> 进程 bb 时间片用完，回到就绪队列（优先级降为 7）
  >> aa 等待过久，优先级提升为 8
  >> bb 等待过久，优先级提升为 8
  >> cc 等待过久，优先级提升为 9


******************** 第 10 次调度 ********************
========================================
【调度进程: cc】 优先级: 9, 还需时间: 5
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      8 |        5 |        3 |        9 | 就绪态 |
|     bb |      8 |        5 |        1 |        9 | 就绪态 |
|     cc |      9 |        4 |        6 |        9 | 运行态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: aa(优先级:8) -> bb(优先级:8)

>>> 进程 cc 时间片用完，回到就绪队列（优先级降为 8）
  >> aa 等待过久，优先级提升为 9
  >> bb 等待过久，优先级提升为 9
  >> cc 等待过久，优先级提升为 9


******************** 第 11 次调度 ********************
========================================
【调度进程: aa】 优先级: 9, 还需时间: 5
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      9 |        4 |        4 |       10 | 运行态 |
|     bb |      9 |        5 |        1 |       10 | 就绪态 |
|     cc |      9 |        4 |        6 |       10 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: bb(优先级:9) -> cc(优先级:9)

>>> 进程 aa 时间片用完，回到就绪队列（优先级降为 8）
  >> aa 等待过久，优先级提升为 9
  >> bb 等待过久，优先级提升为 10
  >> cc 等待过久，优先级提升为 10


******************** 第 12 次调度 ********************
========================================
【调度进程: bb】 优先级: 10, 还需时间: 5
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      9 |        4 |        4 |       11 | 就绪态 |
|     bb |     10 |        4 |        2 |       11 | 运行态 |
|     cc |     10 |        4 |        6 |       11 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: aa(优先级:9) -> cc(优先级:10)

>>> 进程 bb 时间片用完，回到就绪队列（优先级降为 9）
  >> aa 等待过久，优先级提升为 10
  >> bb 等待过久，优先级提升为 10


******************** 第 13 次调度 ********************
========================================
【调度进程: aa】 优先级: 10, 还需时间: 4
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |     10 |        3 |        5 |       12 | 运行态 |
|     bb |     10 |        4 |        2 |       12 | 就绪态 |
|     cc |     10 |        4 |        6 |       12 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: bb(优先级:10) -> cc(优先级:10)

>>> 进程 aa 时间片用完，回到就绪队列（优先级降为 9）
  >> aa 等待过久，优先级提升为 10


******************** 第 14 次调度 ********************
========================================
【调度进程: aa】 优先级: 10, 还需时间: 3
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |     10 |        2 |        6 |       13 | 运行态 |
|     bb |     10 |        4 |        2 |       13 | 就绪态 |
|     cc |     10 |        4 |        6 |       13 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: bb(优先级:10) -> cc(优先级:10)

>>> 进程 aa 时间片用完，回到就绪队列（优先级降为 9）
  >> aa 等待过久，优先级提升为 10


******************** 第 15 次调度 ********************
========================================
【调度进程: aa】 优先级: 10, 还需时间: 2
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |     10 |        1 |        7 |       14 | 运行态 |
|     bb |     10 |        4 |        2 |       14 | 就绪态 |
|     cc |     10 |        4 |        6 |       14 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: bb(优先级:10) -> cc(优先级:10)

>>> 进程 aa 时间片用完，回到就绪队列（优先级降为 9）
  >> aa 等待过久，优先级提升为 10


******************** 第 16 次调度 ********************
========================================
【调度进程: aa】 优先级: 10, 还需时间: 1
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |     10 |        0 |        8 |       15 | 运行态 |
|     bb |     10 |        4 |        2 |       15 | 就绪态 |
|     cc |     10 |        4 |        6 |       15 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: bb(优先级:10) -> cc(优先级:10)

>>> 进程 aa 运行完毕！


******************** 第 17 次调度 ********************
========================================
【调度进程: bb】 优先级: 10, 还需时间: 4
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      9 |        0 |        8 |       15 | 完成态 |
|     bb |     10 |        3 |        3 |       16 | 运行态 |
|     cc |     10 |        4 |        6 |       16 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: cc(优先级:10)

>>> 进程 bb 时间片用完，回到就绪队列（优先级降为 9）
  >> bb 等待过久，优先级提升为 10


******************** 第 18 次调度 ********************
========================================
【调度进程: bb】 优先级: 10, 还需时间: 3
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      9 |        0 |        8 |       15 | 完成态 |
|     bb |     10 |        2 |        4 |       17 | 运行态 |
|     cc |     10 |        4 |        6 |       17 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: cc(优先级:10)

>>> 进程 bb 时间片用完，回到就绪队列（优先级降为 9）
  >> bb 等待过久，优先级提升为 10


******************** 第 19 次调度 ********************
========================================
【调度进程: bb】 优先级: 10, 还需时间: 2
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      9 |        0 |        8 |       15 | 完成态 |
|     bb |     10 |        1 |        5 |       18 | 运行态 |
|     cc |     10 |        4 |        6 |       18 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: cc(优先级:10)

>>> 进程 bb 时间片用完，回到就绪队列（优先级降为 9）
  >> bb 等待过久，优先级提升为 10


******************** 第 20 次调度 ********************
========================================
【调度进程: bb】 优先级: 10, 还需时间: 1
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      9 |        0 |        8 |       15 | 完成态 |
|     bb |     10 |        0 |        6 |       19 | 运行态 |
|     cc |     10 |        4 |        6 |       19 | 就绪态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: cc(优先级:10)

>>> 进程 bb 运行完毕！


******************** 第 21 次调度 ********************
========================================
【调度进程: cc】 优先级: 10, 还需时间: 4
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      9 |        0 |        8 |       15 | 完成态 |
|     bb |      9 |        0 |        6 |       19 | 完成态 |
|     cc |     10 |        3 |        7 |       20 | 运行态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: 空

>>> 进程 cc 时间片用完，回到就绪队列（优先级降为 9）
  >> cc 等待过久，优先级提升为 10


******************** 第 22 次调度 ********************
========================================
【调度进程: cc】 优先级: 10, 还需时间: 3
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      9 |        0 |        8 |       15 | 完成态 |
|     bb |      9 |        0 |        6 |       19 | 完成态 |
|     cc |     10 |        2 |        8 |       21 | 运行态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: 空

>>> 进程 cc 时间片用完，回到就绪队列（优先级降为 9）
  >> cc 等待过久，优先级提升为 10


******************** 第 23 次调度 ********************
========================================
【调度进程: cc】 优先级: 10, 还需时间: 2
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      9 |        0 |        8 |       15 | 完成态 |
|     bb |      9 |        0 |        6 |       19 | 完成态 |
|     cc |     10 |        1 |        9 |       22 | 运行态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: 空

>>> 进程 cc 时间片用完，回到就绪队列（优先级降为 9）
  >> cc 等待过久，优先级提升为 10


******************** 第 24 次调度 ********************
========================================
【调度进程: cc】 优先级: 10, 还需时间: 1
========================================
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      9 |        0 |        8 |       15 | 完成态 |
|     bb |      9 |        0 |        6 |       19 | 完成态 |
|     cc |     10 |        0 |       10 |       23 | 运行态 |
----------------------------------------------------------------

【当前就绪队列状态】
就绪队列: 空

>>> 进程 cc 运行完毕！

============================================================
              所有进程调度完成！
============================================================

【最终进程状态】
----------------------------------------------------------------
| 进程名 | 优先数 | 需要时间 | 已用时间 | 等待时间 |  状态    |
----------------------------------------------------------------
|     aa |      9 |        0 |        8 |       15 | 完成态 |
|     bb |      9 |        0 |        6 |       19 | 完成态 |
|     cc |      9 |        0 |       10 |       23 | 完成态 |
----------------------------------------------------------------
https://ideone.com/zOJEOH
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!