用java语言,模拟实现操作系统的进程调度算法,先来先服务,高优先级、高响应比、时间片轮转和短作业

构思算法的实现过程。

①先来先服务算法
一开始我从最简单的先来先服务开始想,既然要排序进程链表的执行顺序,肯定要将链表的头head作为参数传入到方法中。其次为了之后方便一次性检验多种算法,传入进来的head链表我不会对它进行任何改变。所以创建一个新链表head2用CreateHead方法将链表进行复制,这样我就可以拿head2这个复制品随便搞,也不会影响之后调用其他算法,因为head没变。
当我拿到复制链表head2之后,要对他进行先来先服务算法排序,肯定要比较所有进程的到达时间,从到达时间最小的进程先开始执行,需要注意的是将某个进程执行完毕之后,要将它从链表中移除,以确保下一次查找的正确性。所以我用一个大循环,循环次数是链表的结点数,每一次循环都找到本次循环到达时间最小的那个结点,然后将这个结点的所有进程信息进行更新,包括完成时间,周转时间,带权周转时间,打印所有的信息到控制台。并且更新一下总时间线start(一开始为0,每次运行一个进程,它的值都加上这个进程的运行时间,相当于总时间线)。最后将这个结点从链表中删除,再次循环从剩余的节点中找到达时间最小的结点,直到所有结点都被删除了。那么所有结点的执行顺序也已经全部被打印到控制台上了。每次循环都记录周转时间和带权周转时间。最后循环结束计算一下平均值。下面是算法流程图:
在这里插入图片描述
②短作业优先算法
短作业优先自然要选择运行时间最短的进程先执行,和上面的算法流程图大体一致,就是要找出链表中运行时间最短的节点。并且要注意的是如果最短运行时间的进程的到达时间很迟,而有一个运行时间较长的进程先到达了,就不能让CPU等着。应该先执行到达的进程,等到这个进程执行完毕之后,再次找运行时间最短的进程。直到程序退出。
③高优先级优先算法
高优先级和前两种也类似,主要是找到最高优先级的进程先运行,而且也要和第二种算法一样注意进程的到达时间。
④高响应比优先算法
此算法和前三种稍有不同,虽然大体流程相同,但是响应比有自己的计算公式,响应比 = (等待时间+要求服务时间)/ 要求服务时间。
我封装了一个方法专门求响应比,所以也可以和上面三种程序一样先找到响应比最高的进程运行。需要注意的是,每一个进程运行完毕之后响应比都会发生变化。
⑤时间片轮转算法
这个算法我想它大体是个先来先服务一样的,所以我将所有进程一开始按到达时间排序,因为每次时间片执行完毕进程不一定结束,所以给进程的节点中添加两个新属性int newarrival和int newruntime用来保存更新之后的到达时间和运行时间,每次时间片执行完毕,这个进程的到达时间就是此刻,然后将它的到达时间和链表中所有的进程的到达时间进行比较,插入它比它小和比它大的到达时间之间,如果遇到相等的到达时间就插入到本来存在节点的后面。然后本次时间片结束,头指针向后移动运行下一个排队的进程节点。

源代码如下

import java.util.Scanner;
class Node{
   
    String name;
    int priority;
    int runtime;
    int arrivaltime;
    int starttime;
    int endtime;
    int turntime;  //周转时间
    double dturntime;  //带权周转时间
    Node nextnode;
    int statu;
    int newarrival;
    int newruntime;

    public Node(String name,int priority,int runtime,int arrivaltime, int starttime, int endtime, int turntime, double dturntime){
   
        this.name = name;
        this.priority = priority;
        this.runtime = runtime;
        this.arrivaltime = arrivaltime;
        this.nextnode = null;
        this.starttime = starttime;
        this.endtime = endtime;
        this.turntime = turntime;
        this.dturntime = dturntime;
        this.newarrival = arrivaltime;
        this.newruntime = runtime;
    }

}

class Create{
   
    public Node createNode(Node head, String name, int priority, int runtime, int arrivaltime, int starttime, int endtime, int turntime, double dturntime){
   

        if(head == null){
   
            Node node = new Node(name,priority,runtime,arrivaltime,starttime,endtime,turntime,dturntime);
            head = node;
            return head;
        }
        Node cur = head;
        while(cur.nextnode!=null){
   
            cur = cur.nextnode;
        }
        Node node = new Node(name,priority,runtime,arrivaltime,starttime,endtime,turntime,dturntime);
        cur.nextnode = node;
        return head;
    }

    public void check(Node head){
   
        if(head == null){
   
            System.out.println("当前没有节点信息");
            return;
        }
        Node cur = head;
        while(cur!=null){
   
            System.out.println("名字:"+cur.name+"、优先级:"+cur.priority+"、运行时间:"+cur.runtime+"、到达时间"+cur.arrivaltime);
            cur = cur.nextnode;
        }
    }
}

class Algorithm{
   
    private Node pre = null;
    private Node prev = null;
    private Node min = null;
    private int num = 0;
    private int start = 0;
    private double nums = 0.0;
    private int count = 0;
    private static Create create = new Create();
    private static Node CreateHead(Node head){
   
        Node head2 = null;
        Node cur = head;
        while(cur!=null){
   
            head2 = create.createNode(head2,cur.name,cur.priority,cur.runtime,cur.arrivaltime,cur.starttime,cur.endtime,cu
  • 10
    点赞
  • 68
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
好的,我可以为您提供一个基本的Java代码示例来模拟实现操作系统进程调度算法,包括先来先服务优先级时间片轮转。 首先,我们需要定义一个进程类Process,其中包含进程的ID、优先级、到达时间、服务时间、剩余服务时间和完成时间等属性。代码如下: ```java class Process { int id; // 进程ID int priority; // 进程优先级 int arriveTime; // 到达时间 int serviceTime; // 服务时间 int remainingTime; // 剩余服务时间 int finishTime; // 完成时间 public Process(int id, int priority, int arriveTime, int serviceTime) { this.id = id; this.priority = priority; this.arriveTime = arriveTime; this.serviceTime = serviceTime; this.remainingTime = serviceTime; this.finishTime = -1; } } ``` 接下来,我们定义一个进程调度类Scheduler,其中包含了三种不同的进程调度算法先来先服务优先级时间片轮转。代码如下: ```java import java.util.ArrayList; import java.util.Comparator; import java.util.LinkedList; import java.util.Queue; class Scheduler { ArrayList<Process> processes; // 进程列表 public Scheduler(ArrayList<Process> processes) { this.processes = processes; } // 先来先服务 public void FCFS() { int currentTime = 0; int n = processes.size(); for (int i = 0; i < n; i++) { Process p = processes.get(i); if (p.arriveTime > currentTime) { currentTime = p.arriveTime; } p.finishTime = currentTime + p.serviceTime; currentTime = p.finishTime; } } // 优先级 public void HPF() { int currentTime = 0; int n = processes.size(); ArrayList<Process> queue = new ArrayList<Process>(); for (int i = 0; i < n; i++) { Process p = processes.get(i); if (p.arriveTime <= currentTime) { queue.add(p); } } queue.sort(new Comparator<Process>() { @Override public int compare(Process p1, Process p2) { return p2.priority - p1.priority; } }); while (!queue.isEmpty()) { Process p = queue.remove(0); p.finishTime = currentTime + p.serviceTime; currentTime = p.finishTime; for (int i = 0; i < n; i++) { Process q = processes.get(i); if (q.arriveTime > currentTime) { break; } if (!queue.contains(q) && q != p) { queue.add(q); } } queue.sort(new Comparator<Process>() { @Override public int compare(Process p1, Process p2) { return p2.priority - p1.priority; } }); } } // 时间片轮转 public void RR(int quantum) { int currentTime = 0; int n = processes.size(); Queue<Process> queue = new LinkedList<Process>(); for (int i = 0; i < n; i++) { Process p = processes.get(i); if (p.arriveTime <= currentTime) { queue.add(p); } } while (!queue.isEmpty()) { Process p = queue.remove(); if (p.remainingTime > quantum) { p.remainingTime -= quantum; currentTime += quantum; for (int i = 0; i < n; i++) { Process q = processes.get(i); if (q.arriveTime <= currentTime && !queue.contains(q) && q != p) { queue.add(q); } } queue.add(p); } else { currentTime += p.remainingTime; p.remainingTime = 0; p.finishTime = currentTime; for (int i = 0; i < n; i++) { Process q = processes.get(i); if (q.arriveTime <= currentTime && !queue.contains(q) && q != p) { queue.add(q); } } } } } } ``` 在主函数中,我们可以创建一些进程利用上述三种算法进行调度。代码如下: ```java public class Main { public static void main(String[] args) { ArrayList<Process> processes = new ArrayList<Process>(); processes.add(new Process(1, 2, 0, 10)); processes.add(new Process(2, 1, 0, 5)); processes.add(new Process(3, 3, 2, 7)); processes.add(new Process(4, 4, 3, 2)); Scheduler scheduler = new Scheduler(processes); scheduler.FCFS(); //scheduler.HPF(); //scheduler.RR(2); for (int i = 0; i < processes.size(); i++) { Process p = processes.get(i); System.out.println("Process " + p.id + ": finish time = " + p.finishTime); } } } ``` 注释:在主函数中,我们创建了四个进程,并调用Scheduler类的FCFS()、HPF()和RR(2)方法进行调度。在调度结束后,我们可以输出每个进程的完成时间。请注意,由于我们在进程类中定义了finishTime属性,因此调度算法可以直接修改该属性以记录每个进程的完成时间。
评论 9
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值