【操作系统】调度算法

周转时间=完成时间-到达时间

带权周转时间=周转时间/运行时间

等待时间=周转时间-运行时间

响应比=(等待时间+要求服务时间)/   要求服务时间

先来先服务(FCFS)

       按到达时间顺序。

       非抢占式算法。

       优点:公平、算法实现简单;

       缺点:对长作业有利,对短作业不利(在排长作业后的带权周转时间大)。

       不会导致饥饿(进程/作业长期得不到服务)。

短作业优先(SJF)/短进程优先(SPF)

       选当前已经到达且运行时间最短的作业;

       SJF、SPF非抢占式,最短剩余时间优先(SRTN)抢占式。

       优点:"最短的"平均等待时间、平均周转时间;

       缺点:对短作业有利,对长作业不利。

       可能导致饥饿。

高响应比优先(HRRN)

       计算作业/进程的响应比,选择响应比最高的作业/进程。

       非抢占式

       避免了长作业饥饿

时间片轮转(RR)

       轮流执行一个时间片

       用于进程调度

       抢占式(时钟中断)

       优点:公平,响应快,适用于分时操作系统;

       缺点:不区分任务紧急程度,时间片太大——FCFS,时间片太小——进程切换开销大。

      不会导致饥饿。

优先级调度算法

      每个进程都有自己的优先级,先运行优先级高的。

      抢占式、非抢占式都有。

      静态优先级:创建进程时确定,之后一只不变

      动态优先级:创建进程时有初始值,之后根据情况动态的调整。

      通常:

              系统进程优先级>用户进程

               前台进程>后台进程

               操作系统更偏好I/O型进程

       灵活,会发生饥饿。

多级反馈队列调度算法

       多级就绪队列,各级队列优先级从高到低,时间片从小到大,逐级分配时间片,新进程先进入第一级队列FCFS,时间片用完还未结束到下一级,最下一级放末尾。

       抢占式。

       有FCFS、RR、SPF的优点,不必实现估计进程的运行时间(避免用户作假),可灵活地调整对各类进程的偏好程度(CPU密集型、I/O密集型)

多级队列调度算法

      系统中按进程类型设置多个队列,进程创建成功后插入某个队列,如:

40a8ac3d6c0146cbbeb2b33503175305.png

 

 

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
以下是一个基于动态优先权调度算法的C语言代码示例: ``` #include <stdio.h> #include <stdlib.h> #define MAX_PROCESS 10 typedef struct process { int pid; // 进程ID int arrival_time; // 到达时间 int burst_time; // 执行时间 int priority; // 优先级 int waiting_time; // 等待时间 int turnaround_time; // 周转时间 } process; int main() { int n, i, j, time = 0, total_waiting_time = 0, total_turnaround_time = 0; float avg_waiting_time, avg_turnaround_time; process p[MAX_PROCESS], temp; printf("Enter the number of processes: "); scanf("%d", &n); printf("Enter the arrival time, burst time and priority for each process:\n"); for (i = 0; i < n; i++) { p[i].pid = i + 1; scanf("%d %d %d", &p[i].arrival_time, &p[i].burst_time, &p[i].priority); } // Sort the processes based on their arrival time for (i = 0; i < n - 1; i++) { for (j = i + 1; j < n; j++) { if (p[i].arrival_time > p[j].arrival_time) { temp = p[i]; p[i] = p[j]; p[j] = temp; } } } // Execute the processes in order of their priority for (i = 0; i < n; i++) { // Find the process with the highest priority that has arrived int highest_priority_index = -1; for (j = 0; j < n; j++) { if (p[j].arrival_time <= time && p[j].burst_time > 0) { if (highest_priority_index == -1 || p[j].priority < p[highest_priority_index].priority) { highest_priority_index = j; } } } // Execute the process p[highest_priority_index].burst_time--; time++; // Update waiting and turnaround time for all processes for (j = 0; j < n; j++) { if (p[j].arrival_time <= time && p[j].burst_time > 0) { if (j != highest_priority_index) { p[j].waiting_time++; } p[j].turnaround_time++; } } } // Calculate waiting and turnaround time for each process for (i = 0; i < n; i++) { total_waiting_time += p[i].waiting_time; total_turnaround_time += p[i].turnaround_time; } avg_waiting_time = (float)total_waiting_time / n; avg_turnaround_time = (float)total_turnaround_time / n; // Print the results printf("Process\tArrival Time\tBurst Time\tPriority\tWaiting Time\tTurnaround Time\n"); for (i = 0; i < n; i++) { printf("%d\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n", p[i].pid, p[i].arrival_time, p[i].burst_time + 1, p[i].priority, p[i].waiting_time, p[i].turnaround_time + 1); } printf("Average waiting time: %f\n", avg_waiting_time); printf("Average turnaround time: %f\n", avg_turnaround_time); return 0; } ``` 该代码实现了动态优先权调度算法,并计算每个进程的等待时间和周转时间,以及所有进程的平均等待时间和平均周转时间。在执行过程中,它会按照进程的到达时间排序,然后执行具有最高优先级的进程。每次执行完一个时间片后,它会更新每个进程的等待时间和周转时间。最后,它会输出每个进程的详细信息和平均等待时间和平均周转时间。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

曦樂~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值