精华内容
下载资源
问答
  • java进程调度算法

    2013-01-03 23:52:08
    java写的进程调度算法。有时间片轮转法、先来先服务、最短运行时间优先调度算法、优先权调度算法、多级反馈队列算法。代码结构简洁,逻辑缜密。
  • 银行家算法--进程调度算法--内存分配算法java实现
  • java 进程调度算法,看看有用不,大家交流下,当年大学留下来的,可以用的,大家放心下。。。。现在的资源分数真高
  • 使用Java描述进程的调度。有图形界面显示。在这里只写了RR和SPF这两种算法,不过我看了下,除了反馈调度算法这个程序难以实现外,其他算法都可以轻易实现。
  • 华北科技学院计算机系综合性实验报告 操作系统 实验题目 进程调度算法模拟 一实验目的 通过对进程调度算法的模拟进一步理解进程的基本概念加深对进程运行状态和进程调度 过程调度算法的理解 二设备与环境 1硬件设备 ...
  • java模拟进程调度算法时间片,本源代码必须在有java环境的电脑上运行才行的
  • Java操作系统进程调度算法——优先级调度(HPF)算法 文章目录Java操作系统进程调度算法——优先级调度(HPF)算法前言一、算法思想二、数据结构1.定义(PCB)进程控制块2.实现思路三、流程图四、完整代码运行结果1、输入...

    Java操作系统进程调度算法——优先级调度(HPF)算法


    前言

    为了使紧迫型进程获得优先处理,引入了优先权调度算法。它从就绪队列中选择一个优先级最高的进程,让其获得处理器并执行。一般的,又进一步把该算法分为两种方式:

    一、算法思想

    (1)非抢占式优先级调度算法:在这种方式下,系统一旦把处理器分配给就绪队列中优先权最高的进程后,该进程就占有处理器一直运行下去,直到该进程完成或因发生事件而阻塞,才退出处理器。系统这时才能将处理器分配给另一个优先权高的进程。这种方式实际上是每次将处理器分配给当前就绪队列中优先级最高的进程。它常用于批处理系统中,也可用于某些对时间要求不严格的实时系统中。

    (2)抢占式优先权调度算法:在这种方式下,系统同样把处理器分配给当前就绪队列中优先级最高的进程,使之执行。但在其执行期间,仍然会不断有新的就绪进程进入就绪队列,如果出现某个进程,其优先级比当前正在执行的进程的优先权还高时,进程调度程序就会立即暂停当前进程的执行,将处理器收回,并将处理器分配给新出现的优先级更高的进程,让其执行。这种方式实际上永远都是系统中优先级最高的进程占用处理器执行。因此,它能更好地满足紧迫进程的要求, 故常用于要求比较严格的实时系统中,以及对性能要求较高的批处理和分时系统中。

    对于优先权调度算法,其关键在于是采用静态优先权,还是动态优先权,以及如何确定 进程的优先权。

    (1) 静态优先权:静态优先权是在创建进程时确定的,并且规定它在进程的整个运行期间保持不变。一般来说,优先权是利用某个范围内的一个整数来表示的,如 0~7,或 0~255 中的某个整数, 所以又称为优先数。在使用时,有的系统用“0”表示最高优先权,数值越大优先权越小, 而有的系统则恰恰相反。

    (2) 动态优先权:动态优先权要配合抢占调度方式使用,它是指在创建进程时所赋予的优先权,可以随着进程的推进而发生改变,以便获得更好的调度性能。在就绪队列中等待调度的进程,可以随 着其等待时间的增加,其优先权也以某个速率增加。因此,对于优先权初值很低的进程,在 等待足够长的时间后,其优先权也可能升为最高,从而获得调度,占用处理器并执行。同样 规定正在执行的进程,其优先权将随着执行时间的增加而逐渐降低,使其优先权可能不再是 最高,从而暂停其执行,将处理器回收并分配给其他优先权更高的进程。这种方式能防止一 个长进程长期占用处理器的现象。

    二、数据结构

    1.定义(PCB)进程控制块

    String name;
    int level;
    double arrivetime;  //进程到达时间
    double servicetime;  // 进程执行时间长度(服务时间)
    double starttime; //进程开始执行时间
    double finishtime; //进程执行完成时间
    double zztime; //周转时间
    double dqzztime; //带权周转时间
    

    2.实现思路

    (1)初始化进程块。
    (2)对进程进行优先级排序(此实验采用的是冒泡排序)。
    (3)判断队列是否为空;不为空,则开始调用优先级最高的进程。
    (4)进程运行时间到,则置为就绪状态。
    (5)输出进程调度结果。

    三、流程图

    在这里插入图片描述

    四、完整代码

    
    import java.util.Scanner;
    
    public class HPF {
        String name;
        int level;
        double arrivetime;  //进程到达时间
        double servicetime;  // 进程执行时间长度(服务时间)
        double starttime; //进程开始执行时间
        double finishtime; //进程执行完成时间
        double zztime; //周转时间
        double dqzztime; //带权周转时间
        public HPF(){ }
        public HPF(String name, double arrivetime, double servicetime,int level) {
            this.name = name;
            this.arrivetime = arrivetime;
            this.servicetime = servicetime;
            this.level=level;
    
        }
    
    
    
        //主方法
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("=================优先级调度算法========================");
            System.out.println("输入进程数目: ");
            int num = scanner.nextInt();
    
            //创建进程数组对象
            HPF[] p = new HPF[num];
            System.out.println("请创建进程对象, 输入进程名称  到达时间  服务时间  优先级");
            System.out.println("请输入进程的信息: ");
            for (int i= 0; i<p.length; i++){
                
                p[i] = new HPF(scanner.next(), scanner.nextDouble(),scanner.nextDouble(),scanner.nextInt());
            }
            OS_HPF(p); //调用进程优先级算法
            scanner.close();
        }
    
    
        //进程优先级算法
        private static void OS_HPF(HPF[] p) {
            sort(p); //排序
            run(p); //执行该进程
            print(p); //显示界面
    
            double Attime=0 ,AQttime = 0;
            for (int k=0; k<p.length;k++){
                Attime += p[k].zztime;
                AQttime += p[k].dqzztime;
            }
            Attime = Attime/p.length;
            AQttime = AQttime/p.length;
    
            System.out.println("调用进程优先级的平均周转时间为: "+Attime);
            //  System.out.printf("%.3f\n",AQttime);
            System.out.println("调用进程优先级的平均带权周转时间为: "+AQttime);
        }
    
        //排序算法(冒泡排序法)
        public static void sort(HPF[] p) {
            /************按照优先级进行排序**************/
    
            //  1.对HPF型数组中的元素进行一个简单的排序,找到优先级最高的进程,并且把其他进程进行简单排序,方便后续工作
            
            //冒泡排序:N次循环,每次找到从 i到n-1中优先级最好的进程,放到p[i]
            for (int i = 0; i < p.length; i++) {
                for (int j = i + 1; j < p.length; j++) {
                    if (p[i].arrivetime > p[j].arrivetime) {
                       HPF temp;
                        temp = p[i];
                        p[i] = p[j];
                        p[j] = temp;
                    }
                }
            }
            // 2.每个进程运行完成之后,找到当前时刻已经到达的优先级最大进程
            for (int m = 0; m < p.length; m++) {
                if (m == 0)  //p[0]的优先级最高
                    p[m].finishtime = p[m].arrivetime + p[m].servicetime;
                else
                    p[m].finishtime = p[m - 1].finishtime + p[m].servicetime;
    
    
                /********* 查找当前进程执行过程中进入系统的进程 ***********/
                        // 2.1 找到p[m].finishtime时刻哪些进程已经到达,从下一个进程p[m+1]开始寻找
                int i = 0;
                for (int n = m + 1; n < p.length; n++) {
                    if (p[n].arrivetime <= p[m].finishtime) {
                        i++;
                    }
                       //2.2 找到p[m].finishtime时刻已经到达的最短进程
                    int next = m + 1;
                    double min = p[m + 1].servicetime; //next进程服务时间为p[m+1].servicetime
                    //在 p[m+1]~p[m+i-1]这 i个已经到达的进程中找到最短进程
                    for (int k = m + 2; k <= m + i; k++) {
                        if (p[k].servicetime < min) {
                            min = p[k].servicetime;
                            next = k;
    						
    				//2.3 把最短的进程 放在p[m+1]进程处
                    HPF temp;
                    temp = p[m + 1];
                    p[m + 1] = p[next];
                    p[next] = temp;
                        }
    
                    }           
                }
            }
        }
    
        //进程执行
        private static void run(HPF[] p) {
            for(int k=0; k<p.length;k++){
                if (k==0){
                    p[k].starttime = p[k].arrivetime;
                    p[k].finishtime = p[k].arrivetime+p[k].servicetime;
                }else{
                    p[k].starttime = p[k-1].finishtime;
                    p[k].finishtime = p[k-1].finishtime+p[k].servicetime;
                }
            }
            for (int k=0; k<p.length;k++){
                p[k].zztime = p[k].finishtime-p[k].arrivetime;  //计算该进程周转时间
                p[k].dqzztime=p[k].zztime/p[k].servicetime;  //计算该进程带权周转时间
            }
        }
    
    
        //结果回显
        private static void print(HPF[] p) {
            //System.out.println("调用进程优先级算法后 进程运行的顺序是: ");
            //System.out.println(p[0].name);
            //for (int k=1;k<p.length;k++){
             //   System.out.print("-->"+p[k].name);
           // }
            System.out.println("");
            System.out.println("具体的调度信息: ");
            System.out.println("进程名  优先级  到达时间  执行时间   开始时间   结束时间   周转时间  带权周转时间");
            for(int k =0;k<p.length;k++){
                System.out.printf("%4s",p[k].name);
                System.out.printf("%4d",p[k].level);
                System.out.printf("%10.3f",p[k].arrivetime);
                System.out.printf("%10.3f",p[k].servicetime);
                System.out.printf("%10.3f",p[k].starttime);
                System.out.printf("%10.3f",p[k].finishtime);
                System.out.printf("%10.3f",p[k].zztime);
                System.out.printf("%10.3f\n",p[k].dqzztime);
            }
        }
    }
    

    运行结果

    1、输入示例

    p1  9.40     20   1
    p4  10.10    10   4
    p5  10.05    30   3
    p2  9.55     15   3
    p3  9.45     25   2
    

    2、结果截图

    在这里插入图片描述

    展开全文
  • Java开发环境下,模拟进程调度算法,其中该算法所需要的具体功能为:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法(将用户作业和就绪进程按提交顺序或变为就绪状态的先后...

    一、需求分析

    在Java开发环境下,模拟进程调度算法,其中该算法所需要的具体功能为:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法(将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列,并按照先来先服务的方式进行调度处理)。

    算法的具体描述为:每个进程有一个进程控制块( PCB)表示。进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。进程的优先数、需要的运行时间及到达时间可以事先人为地指定(也可以由随机数产生)。进程的运行时间以时间片为单位进行计算。每个进程的状态可以是就绪 W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。 如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB,以便进行检查。 重复以上过程,直到所要进程都完成为止。

    二、概要设计

    为了符合题目需求,该工程主要有三个实现类:

    Process(进程类),主要用来实例化各个不同的进程

    ProcessBlock(进程控制块类),用来为每个进程分配PCB,该类实例化后为进程类的类成员变量

    ProcessControl(进程控制类),为主类,用来调度进程。

    其中,在进程调度中,声明了三个队列,分别为待插入进程队列(按到达时间从小到大排序),就绪队列(按优先级从大到小排序,按照到达时间先后进行排序),完成队列。都ArrayList<Process>类型变量。

    调度算法描述:

    程序开始时随机为初始化5个进程(程序太多不容易观察运行结果)

    声明时间变量t,while循环下调度程序一直运行,每运行一次,t++

    然后循环判断待插入队列队首进程是否到达,若到达,则将该进程插入到就绪队列中,并从待插入队列删除该进程;若没有到达,则从该循环中跳出

    然后从就绪队列中取出队首进程并分配时间片。当该进程时间片用完后,判断该进程是否已经完成,若完成,则将该进程插入到完成队列;若没有完成,则将该进程的优先级减一并重新插入到就绪队列中

    一直重复该循环,一直到待插入队列和就绪队列都为空为止

    参考文档和完整的文档和源码下载地址:

    https://www.write-bug.com/article/1363.html

    转载于:https://my.oschina.net/u/4188109/blog/3090344

    展开全文
  • 在操作系统课上的一点小感想,基于java进程调度算法,分享出来和大家一起学习。 该工程主要有三个实现类: Process(进程类),主要用来实例化各个不同的进程 ProcessBlock(进程控制块类),用来为每个进程...

    在操作系统课上的一点小感想,基于java的进程调度算法,分享出来和大家一起学习。

    该工程主要有三个实现类:

    1. Process(进程类),主要用来实例化各个不同的进程
    2. ProcessBlock(进程控制块类),用来为每个进程分配PCB,该类实例化后为进程类的类成员变量
    3. ProcessControl(进程控制类),为主类,用来调度进程。
    4. 其中,在进程调度中,声明了三个队列,分别为待插入进程队列(按到达时间从小到大排序),就绪队列(按优先级从大到小排序,按照到达时间先后进行排序),完成队列。都ArrayList<Process>类型变量。

    调度算法描述:

    1. 程序开始时随机为初始化5个进程(程序太多不容易观察运行结果)
    2. 声明时间变量twhile循环下调度程序一直运行,每运行一次,t++
    3. 然后循环判断待插入队列队首进程是否到达,若到达,则将该进程插入到就绪队列中,并从待插入队列删除该进程;若没有到达,则从该循环中跳出
    4. 然后从就绪队列中取出队首进程并分配时间片。当该进程时间片用完后,判断该进程是否已经完成,若完成,则将该进程插入到完成队列;若没有完成,则将该进程的优先级减一并重新插入到就绪队列中
    5. 一直重复该循环,一直到待插入队列和就绪队列都为空为止

    点击此处下载文档和源码

     

     

    展开全文
  • 文章目录什么是作业调度什么是进程调度FCFS(先来先服务调度算法)SJF(短作业优先调度算法)HRRN(高响应比优先调度算法)优先级调度算法RR(时间片轮转调度算法)多级反馈队列调度算法代码分析节点代码创建与检查节点...

    什么是作业调度

    根据JCB中的信息,检查系统中的资源是否能满足作业对资源的需求,以及按照一定的调度算法,从外存的后备队列中选取某些作业调入内存,并为他们创建进程,分配必要的资源,然后再将新创建的进程排在就绪队列上等待调度。因此,也把作业调度称为接纳调度。

    什么是进程调度

    当计算机系统处于就绪状态的用户进程数多于CPU数时,就会产生多个进程或线程同时竞争CPU的结果。假设现在只有一个CPU可用,那么操作系统就必须选择一个进程运行,并把处理机分配给该进程。

    FCFS(先来先服务调度算法)

    算法思想 算法规则 适用调度类型 是否可以抢占 优点 缺点 是否会饥饿
    主要从公平的角度考虑 按照作业/进程到达的先后顺序进行调度,即:优先考虑在系统中等待时间最长的作业 进程调度和作业调度 非抢占式算法 满足公平原则,且算法容易实现,比较利于长作业进程 排在长进程后的短进程的等待时间大,而且带权周转时间大,不利于短作业进程 不会

    SJF(短作业优先调度算法)

    算法思想 算法规则 适用调度类型 是否可以抢占 优点 缺点 是否会饥饿
    实际上,短进程作业在实际情况中占有很大比例,为了使得它们优先执行,追求最少的平均等待时间、平均周转时间、平均带权周转事件 要求服务时间最短的作业进程优先得到服务 进程调度和作业调度 非抢占式算法 可以得到最少的平均等待时间,平均周转时间,平均带权周转时间 不公平,对长作业不友好,对短作业友好 会,短作业优先可能导致长作业一直得不到处理

    HRRN(高响应比优先调度算法)

    算法思想 算法规则 适用调度类型 是否可以抢占 优点 缺点 是否会饥饿
    综合考虑等待时间和运行时间 在每次调度时,先计算各个作业进程的优先权:优先权=响应比=(等待时间+要求服务时间)/要求服务时间=响应时间/要求服务时间 进程调度和作业调度 非抢占式算法 综合考虑了等待时间和要求服务时间,在等待时间相同时,要求服务的时间越短,其优先权越高,拥有SJF算法的优点,在要求服务时间相同时,作业的优先权决定于其等待时间,等待时间越长,其优先权越高,拥有FCFS算法的优点 需要计算优先权,增加了系统的开销 不会

    优先级调度算法

    算法思想 算法规则 适用调度类型 是否可以抢占 优点 缺点 是否会饥饿
    根据任务的紧急程度进行调度 调度时选择优先级最高的作业/进程,为其分配处理机 进程调度、作业调度、I/O调度 抢占式算法和非抢占式算法 用优先级区分任务的紧急程度,适用于实时操作系统。 如果有源源不断的高优先级进程到来,那么低优先级的进程可能会饥饿

    1、优先级是利用某一范围内的整数来表示的,又把该整数称为优先数(优先数的大小并不一定和优先级成正比)。确定优先级大小的依据如下;

    • 进程类型
    • 进程对资源的需求
    • 用户要求

    2、优先级的类型有两种:

    • 静态优先级:在创建进程时确定的,在进程的整个运行期间保持不变。虽然静态优先级简单易行,系统开销小,但是不够精确,可能会出现优先级低的进程长期没有被调度的情况。
    • 动态优先级:在创建程序之初,先赋予其一个优先级,然后其值随进程的推进或者等待时间的增加而改变,以获得更好的调度性能。

    RR(时间片轮转调度算法)

    算法思想 算法规则 适用调度类型 是否可以抢占 优点 缺点 是否会饥饿
    公平的、轮流的为各个进程服务,让每个进程在一定时间间隔内都可以得到响应 系统根据FCFS策略,将所有的就绪进程排成一个就绪队列。轮流让各个进程执行一个时间片的,若进程未在一个时间片内执行完,则被剥夺处理机,将进程放到就绪队列队尾重新排队。 进程调度 抢占式算法 公平、响应快,适用于分时操作系统 由于高频率的进程切换,增加了开销,并且它不区分任务的紧急程度 不会
    • 时间片过小:有利于短作业,因为它能在该时间片内完成,但是,意味着频繁的执行进程调度和进程上下文的切换,增加系统的开销。即:退化为短作业优先算法 。
    • 时间片过大:每个进程都能在一个时间片内完成,即退化为FCFS算法。

    多级反馈队列调度算法

    算法思想 算法规则 适用调度类型 是否可以抢占 优点 缺点 是否会饥饿
    对以上调度算法的权衡和弥补 1、设置多个就绪队列,各级队列的优先级由高到低,时间片从小到大;2、新进程到达时先进入第一级队列,按照FCFS的原则排队等待被分配时间片,若时间片已经用完进程还没结束,则进程进入下一级队尾,如果此时进程已经在最低一级的队列,则将其重新放回该队列的队尾;3、只有第k级队列为空时,才会为第k+1级队列分配时间片 进程调度 抢占式算法,当第k级队列在运行过程中,若更上级的队列到来了一个新进程,由于优先级问题,新进程会抢占处理机,并将原来运行的进程放回第k级队列的队尾 对各种类型的进程都比较公平,每个新到达的进程都会很快得到响应,短进程只用较少的时间就可以完成,不用估计进程的运行时间。 可能会导致饥饿,概率不大

    代码分析

    节点代码

    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,cur.turntime,cur.dturntime);
                cur = cur.nextnode;
            }
            return head2;
        }
    
        private void endFun(){
            System.out.println("平均周转时间:" + (double) this.num / this.count + "平均带权周转时间:" + this.nums / this.count);
            this.start = 0;
            this.num = 0;
            this.nums = 0;
            this.count = 0;
        }
    
        private static Node toolMethod(Node min,Node prev,int start,Node head){
            min.starttime = start;
            min.endtime = min.starttime + min.runtime;
            min.turntime = min.endtime - min.arrivaltime;
            min.dturntime = (double) min.turntime / (double) min.runtime;
            System.out.println("名字:" + min.name + "、优先级:" + min.priority + "、运行时间:" + min.runtime + "、到达时间" + min.arrivaltime + "、开始时间:" + min.starttime + "、结束时间:" + min.endtime + "、周转时间:" + min.turntime + "、带权周转时间:" + min.dturntime);
            if (prev == null) {
                if (min.nextnode == null) {
                    return null;
                }
                return min.nextnode;
            } else {
                prev.nextnode = min.nextnode;
            }
            return head;
        }
    
        private static Node findMin(Node head){
            Node cur = head;
            Node real = null;
            int mintime = cur.arrivaltime;
            while(cur!=null){
                if(cur.arrivaltime<=mintime){
                    mintime = cur.arrivaltime;
                    real = cur;
                }
                cur = cur.nextnode;
            }
            return real;
        }
    
        public void Fcfs(Node head) {
            Node head2 = CreateHead(head);
            while (head2 != null) {
                min = null;
                pre = null;
                Node cur = head2;
                int mintime = cur.arrivaltime;
                while (cur != null) {
                    if (cur.arrivaltime <= mintime) {
                        mintime = cur.arrivaltime;
                        prev = pre;
                        min = cur;
                    }
                    pre = cur;
                    cur = cur.nextnode;
                }
                if (min.arrivaltime > start) {
                    start = min.arrivaltime;
                }
                head2 = toolMethod(min,prev,start,head2);
                start = start + min.runtime;
                num += min.turntime;
                nums += min.dturntime;
                count++;
            }
            this.endFun();
        }
    
        public void Priority(Node head){
            Node head2 = CreateHead(head);
            while(head2!=null){
                min = null;
                pre = null;
                Node cur = head2;
                int mintime = 0;
                while(cur!=null){
                    if(cur.priority >= mintime && cur.arrivaltime <= start){
                        mintime = cur.priority;
                        prev = pre;
                        min = cur;
                    }
                    pre = cur;
                    cur = cur.nextnode;
                }
                if(min == null){
                    min = findMin(head2);
                }
                if(min.arrivaltime > start){
                    start = min.arrivaltime;
                }
                head2 = toolMethod(min,prev,start,head2);
                start = start + min.runtime;
                num += min.turntime;
                nums += min.dturntime;
                count++;
            }
            this.endFun();
        }
    
        public void ShortProcess(Node head){
            Node head2 = CreateHead(head);
            while(head2!=null){
                min = null;
                pre = null;
                Node cur = head2;
                int mintime = 1000;
                while(cur!=null){
                    if(cur.runtime <= mintime && cur.arrivaltime <= start){
                        mintime = cur.runtime;
                        prev = pre;
                        min = cur;
                    }
                    pre = cur;
                    cur = cur.nextnode;
                }
                if(min == null){
                    min = findMin(head2);
                }
                if(min.arrivaltime > start){
                    start = min.arrivaltime;
                }
                head2 = toolMethod(min,prev,start,head2);
                start = start + min.runtime;
                num += min.turntime;
                nums += min.dturntime;
                count++;
            }
            this.endFun();
        }
    
        private static double resRatio(Node node,int start){
            int waittime = start - node.arrivaltime;
            return (double)waittime/node.runtime;
        }
        public void Hreponse(Node head){
            Node head2 = CreateHead(head);
            while(head2!=null){
                min = null;
                pre = null;
                Node cur = head2;
                double mintime = 0.0;
                while(cur!=null){
                    double resratio = resRatio(cur,start);
                    if(resratio >= mintime && cur.arrivaltime <= start){
                        mintime = resratio;
                        prev = pre;
                        min = cur;
                    }
                    pre = cur;
                    cur = cur.nextnode;
                }
                if(min == null){
                    min = findMin(head2);
                }
                if(min.arrivaltime > start){
                    start = min.arrivaltime;
                }
                head2 = toolMethod(min,prev,start,head2);
                start = start + min.runtime;
                num += min.turntime;
                nums += min.dturntime;
                count++;
            }
            this.endFun();
        }
    
        public static Node QueueHead(Node head){
            Node cur = head;
            Node nodemin = null;
            Node head2 = null;
            int min = 1000;
            int count = 0;
            while(cur!=null){
                count++;
                cur = cur.nextnode;
            }
            while(count!=0) {
                min = 1000;
                cur = head;
                while (cur != null) {
                    if (cur.arrivaltime < min && cur.statu == 0) {
                        nodemin = cur;
                        min = cur.arrivaltime;
                    }
                    cur = cur.nextnode;
                }
                nodemin.statu = 1;
                count--;
                head2 = create.createNode(head2,nodemin.name,nodemin.priority,nodemin.runtime,nodemin.arrivaltime,nodemin.starttime,nodemin.endtime,nodemin.turntime,nodemin.dturntime);
            }
            return head2;
        }
    
        public static void insert(Node head,Node min){
            Node cur = head;
            Node pre = null;
            while(cur!=null){
                if(cur.arrivaltime > min.newarrival){
                    pre.nextnode = min;
                    min.nextnode = cur;
                    return;
                }
                pre = cur;
                cur = cur.nextnode;
            }
            pre.nextnode = min;
            min.nextnode = cur;
        }
    
        public void Roundrobin(Node head,int Rtime){
            Node newnode = null;
            Node head2 = QueueHead(head);
            create.check(head2);
            System.out.println(head2.newruntime);
            System.out.println(head2.newarrival);
            while(head2!=null){
                min = head2;
                if(min.arrivaltime > start){
                    start = min.arrivaltime;
                }
                if(min.newruntime > Rtime){
                    min.newruntime -= Rtime;
                    start += Rtime;
                    min.newarrival += Rtime;
                    newnode = new Node(min.name,min.priority,min.runtime,min.arrivaltime,min.starttime,min.endtime,min.turntime,min.dturntime);
                    newnode.newarrival = min.newarrival;
                    newnode.newruntime = min.newruntime;
                    insert(head2,newnode);
                    head2 = min.nextnode;
                }else{
                    start += min.newruntime;
                    min.endtime = start;
                    min.turntime = min.endtime - min.arrivaltime;
                    min.dturntime = (double) min.turntime / (double) min.runtime;
                    head2 = min.nextnode;
                    num += min.turntime;
                    nums += min.dturntime;
                    count++;
                    System.out.println("名字:" + min.name + "、优先级:" + min.priority + "、运行时间:" + min.runtime + "、到达时间" + min.arrivaltime + "、开始时间:" + min.starttime + "、结束时间:" + min.endtime + "、周转时间:" + min.turntime + "、带权周转时间:" + min.dturntime);
                }
            }
            this.endFun();
        }
    }
    

    测试代码

    
        public class Test {
        public static void dispatchMenu(Node head){
    
            Scanner sc = new Scanner(System.in);
            Algorithm al = new Algorithm();
            int count = 1;
            while(count == 1){
                System.out.println("请选择调度算法:");
                System.out.println("1.先来先服务算法");
                System.out.println("2.短作业优先算法");
                System.out.println("3.高优先级优先算法");
                System.out.println("4.高响应比优先算法");
                System.out.println("5.时间片轮转算法");
                System.out.println("0.退出");
                int num = sc.nextInt();
                switch(num){
                    case 1:al.Fcfs(head);
                        break;
                    case 2:al.ShortProcess(head);
                        break;
                    case 3:al.Priority(head);
                        break;
                    case 4:al.Hreponse(head);
                        break;
                    case 5:al.Roundrobin(head,1);
                        break;
                    case 0:count = 0;
                        break;
                    default:System.out.println("输入错误请重新输入");
                }
            }
        }
    
        public static void mainMenu(){
            Create create = new Create();
            Node head = null;
    
            Scanner sc = new Scanner(System.in);
    
            int count1 = 1;
            while(count1 == 1){
                System.out.println("请选择你需要的服务:");
                System.out.println("1.添加新进程");
                System.out.println("2.使用调度算法进行排序");
                System.out.println("3.查看当前进程信息");
                System.out.println("0.退出");
                int num = sc.nextInt();
                switch(num){
                    case 1:
                        String name;
                        int priority;
                        int runtime;
                        int arrivaltime;
                        System.out.println("请输入进程名字:");
                        name = sc.next();
                        System.out.println("请输入进程优先级:");
                        priority = sc.nextInt();
                        System.out.println("请输入进行运行时间:");
                        runtime = sc.nextInt();
                        System.out.println("请输入进程到达时间:");
                        arrivaltime = sc.nextInt();
                        head = create.createNode(head,name,priority, runtime,arrivaltime,0,0,0,0);
                        break;
                    case 2:Test.dispatchMenu(head);
                        break;
                    case 3:create.check(head);
                        break;
                    case 0:count1 = 0;
                        break;
                    default:System.out.println("输入错误请重新输入");
                }
            }
        }
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Test.mainMenu();
        }
    }
    
    
    展开全文
  • Java操作系统进程调度算法——先来先服务(FCFS)算法 Java操作系统进程调度算法——先来先服务(FCFS)算法 文章目录Java操作系统进程调度算法——先来先服务(FCFS)算法前言一、算法思想二、数据结构1.定义(PCB)进程...
  • 操作系统进程调度算法(Java 实现)

    万次阅读 2017-11-25 21:48:42
    FCFS(First Come First Server,先来先服务)这是最简单,最基本的算法,它的思想非常简单,就是按照进程到来的时间顺序,逐个分配 CPU 资源 优点:简单,方便 缺点:效率低,资源利用率低/** * CPU 占用情况 * 1...
  • 简单实现四种进程调度算法: 先来先服务算法(FCFS) 短作业优先算法(SJF) 时间片轮转算法(RR) 高响应比优先调度算法(HRRN) 源代码 Process class package com.company.schedulingalgorithm; /** * @...
  • 很详细,五种算法 ,先来先服务,短作业优先,最高响应比,时间片轮转,多级反馈队列,进程控制,挂起,等等
  • 先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既可用于作业调度,也可用于进程调度。当在作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将它们调入内存,为...
  • 用C语言实现了先来先服务(FCFS)、短作业优先(SJF)、响应比高优先(HRRF)、优先权高优先(HPF)四种作业调度算法,程序同样适用于进程调度算法。以文件形式提交输入,附样例输入文件job.txt。
  • 模拟进程调度算法—先来先服务算法模拟内容实验原理(理论)实验步骤及代码分析附录程序清单 模拟内容 利用Java语言,模拟进程的调度过程,本篇博客中将通过先来先服务算法可视化模拟进程的调度过程,并且在模拟的...
  • Java平台下的四种进程调度算法的模拟实现,代码精简,内有详细注释,看不懂随时call我
  •  时间片轮转(Round-Robin)调度算法是操作系统一种比较公平的进程调度的方式,这种方式使得就绪队列上的所有进程在每次轮转时都可以运行相同的一个时间片。 基本原理  算法实现原理是,按进程到达顺序(FCFS ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,924
精华内容 22,369
关键字:

进程调度算法java

java 订阅