Java 实现OS调度算法之先来先服务算法(FCFS)

先来先服务调度:

算法描述:按照进程进入的先后次序来分配处理器。先进入就绪队列的进程优先被挑选,运行进程一旦占有处理器将一直运行下去,直到运行结束或被阻塞,这是非抢占式调度。
思维导图

Java 实现OS调度算法之先来先服务算法(FCFS)_第1张图片

例题: 对如下进程 使用FCFS算法 进行排序和结果回显

Java 实现OS调度算法之先来先服务算法(FCFS)_第2张图片

正确结果
施行FCFS调度算法:
  平均进程周转时间T = (20+30+30+35)/4 = 28.75
  平均带权进程周转时间W = (20/20+30/15+30/5+35/10)/4 = 3.13

Java实现:

package com.dhl.beyond.os_fscs;

import java.util.Scanner;

public class FCFS {
    String name;
    double arrivetime;  //进程到达时间
    double servicetime;  // 进程执行时间长度(服务时间)
    double starttime; //进程开始执行时间
    double finishtime; //进程执行完成时间
    double zztime; //周转时间
    double dqzztime; //带权周转时间
    public FCFS(){ }
    public FCFS(String name, double arrivetime, double servicetime) {
        this.name = name;
        this.arrivetime = arrivetime;
        this.servicetime = servicetime;
    }



    //主方法
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("===============先来先服务调度算法========================");
        System.out.println("输入进程数目: ");
        int num = scanner.nextInt();

        //创建进程数组对象
        FCFS[] p = new FCFS[num];
        System.out.println("请创建进程对象, 输入进程名称 到达时间 服务时间 <例如: p1 0 20>");
        for (int i= 0; i<p.length; i++){
            System.out.println("请输入进程:" +(i+1)+"的信息: ");
            p[i] = new FCFS(scanner.next(), scanner.nextDouble(),scanner.nextDouble());
        }
        OS_FCFS(p); //调用先来先服务算法
        scanner.close();
    }


    //先来先服务算法
    private static void OS_FCFS(FCFS[] 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(FCFS[] p){
        for (int i=0;i<p.length;i++){
            for (int j=i+1;j<p.length;j++){
                if (p[i].arrivetime>p[j].arrivetime){
                    FCFS temp;
                    temp = p[i];
                    p[i] = p[j];
                    p[j]= temp;
                }
            }
        }
    }


    //进程执行
    private static void run(FCFS[] 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(FCFS[] 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("%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);
        }
    }
}


结果测试


你可能感兴趣的:(Java算法,及JDK底层研究)