模拟进程调度算法四种（Java）

最新推荐文章于 2022-08-08 15:40:07 发布

泽僮

最新推荐文章于 2022-08-08 15:40:07 发布

阅读量1.3k

点赞数 2

文章标签： java 算法操作系统

本文链接：https://blog.csdn.net/weixin_47162521/article/details/111087863

版权

本文介绍了模拟操作系统中四种进程调度算法的Java实现，包括先来先服务(FCFS)、时间片轮转(RR)、非抢占式优先级调度(SJF)和高响应比优先算法。详细阐述了每种算法的工作原理，并提供了相应的代码实现。

摘要由CSDN通过智能技术生成

在这里插入代码片@TOC

模拟进程调度算法四种（Java）

这是大三上学期操作系统的模拟进程调度的实验，一开始其实都不知道该怎么写去表示进程调度的过程，后来翻阅了许多博客并加以总结才知道，可能有错误之处，希望大家能多多指出错误，一起进步一起学习。

算法一：先来先服务（FCFS）

按照进程进入就绪队列的先后顺序调度并分配处理机执行。先来先服务调度算法是一种非抢占式的算法，先进入就绪队列的进程，先分配处理机运行。一旦一个进程占有了处理机，它就一直运行下去，直到该进程完成工作或者因为等待某事件发生而不能继续运行时才释放处理机：

系统只要有按FIFO规则建立的后备作业队列或就绪进程队列即可，就是一个作业控制块JCB或进程控制块PCB加入队列时加在相应队列末尾。
调度退出队列时从相应队列首开始顺序扫描，将相关的JCB或PCB调度移出相应队列。

算法二：时间片轮转（RR）

时间片轮转调度是一种最古老，最简单，最公平且使用最广的算法。每个进程被分配一时间段，称作它的时间片，即该进程允许运行的时间。

在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片.时间片的大小从几ms到几百ms。
当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片.这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间.

算法三：优先级调度（SJF）

非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

算法四：高响应比优先（）

高响应比优先调度算法的基本思想是把CPU分配给就绪队列中响应比最高的进程。
高响应比优先调度算法既考虑作业的执行时间也考虑作业的等待时间，综合了先来先服务和最短作业优先两种算法的特点。
该算法中的响应比是指作业等待时间与运行比值，响应比公式定义如下：
响应比 =（等待时间+要求服务时间）/ 要求服务时间,即RR=（w+s）/s=1+w/s，因此响应比一定是大于等于1的。

完整代码

package 模拟进程调度;

public class PCB {
   
    int name;//进程名
    int level;//优先级
    int arriveTime;//到达时间
    int runTime;//需要运行时间
    int CPUTime=0;//已用CPU时间
    String state;//进程状态
    float r;//响应比

    public PCB(int name, int arriveTime, int runTime) {
   
        this.name = name;
        this.arriveTime = arriveTime;
        this.runTime = runTime;
    }

    public PCB(int name, int level, int arriveTime, int runTime) {
   
        this.name = name;
        this.level = level;
        this.arriveTime = arriveTime;
        this.runTime = runTime;
    }

    public int getName() {
   
        return name;
    }

    public void setName(int name) {
   
        this.name = name;
    }

    public int getLevel() {
   
        return level;
    }

    public void setLevel(int level) {
   
        this.level = level;
    }

    public int getArriveTime() {
   
        return arriveTime;
    }

    public void setArriveTime(int arriveTime) {
   
        this.arriveTime = arriveTime;
    }

    public int getRunTime() {
   
        return runTime;
    }

    public void setRunTime(int runTime) {
   
        this.runTime = runTime;
    }

    public int getCPUTime() {
   
        return CPUTime;
    }

    public void setCPUTime(int CPUTime) {
   
        this.CPUTime = CPUTime;
    }

    public String getState() {
   
        return state;
    }

    public void setState(String state) {
   
        this.state = state;
    }
}

package 模拟进程调度;

import java.util.*;

public class ProcessMenu {
   

    LinkedList<PCB> BlockList;//阻塞队列
    LinkedList<PCB> ReadyList;//就绪队列
    LinkedList<PCB> FinishList;//完成队列
    LinkedList<PCB> RunningList;//完成队列;//当前正在运行的进程

    //初始化
    public void init() {
   
        RunningList = new LinkedList<>();
        ReadyList = new LinkedList<>();
        FinishList = new LinkedList<>();
        BlockList = new LinkedList<>();
    }

    //先来先服务
    public void FCFS() {
   
        int p_num;//进程数
        int nowtime = 0;//当前时间
        int judge;
        int judge_num=0;
        Scanner reader = new Scanner(System.in);
        System.out.println("请输入进程数：");
        p_num = reader.nextInt();
        int max = 9;//随机数最大值
        Random random = new Random();
        for (int i = 0; i < p_num; i++) {
   //随机生成进程信息

            ReadyList.add(new PCB(random.nextInt(max) + 1, random.nextInt(max) + 1, random.nextInt(max) + 1, random.nextInt(max) + 1));
        }
        Collections.sort(ReadyList, new compareAT());//将就绪队列排序
        nowtime = ReadyList.getFirst().arriveTime;
        while (FinishList.size()!=p_num+judge_num) {
   
            Collections.sort(ReadyList, new compareAT());//将就绪队列排序
            System.out.println("当前时间为：" + nowtime);
            printProcess();
            if (!ReadyList.isEmpty()) {
   
                if (nowtime >= ReadyList.getFirst().arriveTime && RunningList.isEmpty()) {
   
                    RunningList.add(ReadyList.getFirst());
                    ReadyList.remove();
                    System.out.println("是否添加或阻塞进程：1.添加 2.阻塞 3.否");
                    judge=reader.nextInt();
                    if (judge==1){
   
                        System.out.println("请输入要添加的进程个数：");
                        judge_num=reader.nextInt();
                        for (int i = 0; i < judge_num; i++) {
   //随机生成进程信息
                            ReadyList.add(new PCB(random.nextInt(max) + 1, random.nextInt(max) + 1, random.nextInt(max) + 1, random.nextInt(max) + 1));
                        }
                        Collections.sort(ReadyList, new compareAT());//将就绪队列排序
                    }
                    if(judge==2){
   
                        BlockList.add(RunningList.getFirst());
                        RunningList.remove();
                    }
                }
            }
            if (!RunningList.isEmpty(