精华内容
下载资源
问答
  • sjf算法
    2022-05-10 17:47:05

    #include<iostream>
    #include<algorithm>
    #include<vector>
    #define num 4
    #define col 3
    using namespace std;
    int data[num][col] = {{1,0,120},
                          {2,50,50},
                          {3,60,10},
                          {4,110,20}
    };
    int systime = 0;
    int minservertime = 999;
    void sort_sjf(){
            for(int i=0; i<num-1; i++)
            for(int j=i+1; j<num; j++){
                if(data[i][1] > data[j][1])
                   swap(data[i],data[j]);
            }
        systime = data[0][1] + data[0][2];
        for(int i=1; i<num; i++){
            for(int j=i; j<num; j++){
                if(data[j][1] < systime && data[j][2] < minservertime){
                   minservertime = data[j][2];
                }
                
            }
            for(int k=i; k<num; k++){
                if(minservertime == data[k][2]){
                    swap(data[i],data[k]);
                }
            }
            systime += minservertime;
            minservertime = 999;
        }

    }

    double sum_array(double a[]){
        int i = 0;
        double sumf = 0;
        while(i<num){
            sumf = sumf + a[i];
            i++;
        }
        return sumf/num ;
    }

    void sjf(){
        sort_sjf();
        int finishtime[num];
        double runovertime[num];//周转时间 
        double dqzztime[num];//带权周转时间 
        
        for(int i=0; i<num; i++){
            if(i == 0){
                finishtime[i] = data[i][1] + data[i][2];
            }
            else{
                finishtime[i] = finishtime[i-1] + data[i][2];
            }
        }
        
        for(int i=0; i<num; i++){
            runovertime[i] = finishtime[i] - data[i][1];
            dqzztime[i] = runovertime[i] / data[i][2]; 
        }
        printf("SJF调度算法结果是:\n");
        printf("作业名\t完成时间\t周转时间\t带权周转时间\n");
            for(int i=0; i<num; i++){
                printf("%d\t%d\t        %.1lf\t        %.1lf\n",data[i][0],finishtime[i],runovertime[i],dqzztime[i]);
            }
        printf("平均周转时间:%.1lf\n",sum_array(runovertime));
        printf("平均带权周转时间:%.1lf\n",sum_array(dqzztime));
            
    }
    int main(){
        printf("-------------------------------\n");
        printf("作业名   到达时间   服务时间\n");
        for(int i=0; i<num; i++){
            for(int j=0; j<col; j++){
                printf("%d           ",data[i][j]);
            }
            printf("\n");
        }
        printf("-------------------------------\n");
        sjf();
        return 0;
    }

    更多相关内容
  • 操作系统SJF算法.cpp

    2021-07-25 10:25:38
    操作系统SJF算法.cpp
  • sjf_sjf算法_

    2021-10-01 07:41:53
    操作系统的sjf算法,有兴趣的可以看一看,互相交流讨论
  • FCFS算法和SJF算法

    2021-03-12 22:35:07
    System.out.println("SJF算法结束:——————————————————"); new SJF(). PrintProcess(process); System.out.println("平均周转时间为"+new Process().AVG_WholeTime(process)); System.out.println...

    ~~~

    package experiment;

    import java.util.*;

    import java.text.DecimalFormat;

    class Process

    {

    Process(){}

    Process(String Name,int ArrivalTime,int ServiceTime)

    {

    this.Name=Name;

    this.ArrivalTime=ArrivalTime;

    this.ServiceTime=ServiceTime;

    }

    public String getName() {

    return Name;

    }

    public void setName(String name) {

    Name = name;

    }

    public int getArrivalTime() {

    return ArrivalTime;

    }

    public void setArrivalTime(int arrivalTime) {

    ArrivalTime = arrivalTime;

    }

    public int getServiceTime() {

    return ServiceTime;

    }

    public void setServiceTime(int serviceTime) {

    ServiceTime = serviceTime;

    }

    public int getFinishTime() {

    return FinishTime;

    }

    public void setFinishTime(int finishTime) {

    FinishTime = finishTime;

    }

    public int getWholeTime() {

    return WholeTime;

    }

    public void setWholeTime(int wholeTime) {

    WholeTime = wholeTime;

    }

    public double getWeightWholeTime() {

    return WeightWholeTime;

    }

    public void setWeightWholeTime(double weightWholeTime) {

    WeightWholeTime = weightWholeTime;

    }

    private String Name;  //进程名称

    private int ArrivalTime; //到达时间

    private int ServiceTime;//服务时间

    private int FinishTime; //完成时间

    private int WholeTime;//周转时间

    private double WeightWholeTime; //带权周转时间

    public  void WholeTime(Process[]process)

    {

    //求进程的周转时间  周转时间=完成时间-到达时间

    for(int i=0;i

    process[i].setWholeTime(process[i].getFinishTime()-process[i].getArrivalTime());

    }

    public  void WeightWholeTime(Process[]process)

    {

    //求进程的带权周转时间

    DecimalFormat a = new DecimalFormat(".##");

    for(int i=0;i

    process[i].setWeightWholeTime(Double.parseDouble(a.format((double)process[i].getWholeTime()/(double)process[i].getServiceTime())));

    }

    public  double AVG_WholeTime(Process[]process)

    {

    //求进程的平均周转时间

    DecimalFormat a = new DecimalFormat(".##");

    double AVG_WholeTime=0;

    for(int i=0;i

    AVG_WholeTime=AVG_WholeTime+process[i].getWholeTime();

    return  (  Double.parseDouble(a.format(AVG_WholeTime/process.length)) );

    }

    public  double AVG_WeightWholeTime(Process[]process)

    {

    //求进程的平均带权周转时间

    DecimalFormat a = new DecimalFormat(".##");

    double AVG_WeightWholeTime=0;

    for(int i=0;i

    AVG_WeightWholeTime=AVG_WeightWholeTime+process[i].getWeightWholeTime();

    return (Double.parseDouble(a.format(AVG_WeightWholeTime/process.length)));

    }

    public void SortWithArrivalTime(Process[]process)

    {

    //按到达时间排序

    for(int i=0;i

    {

    for(int j=i+1;j

    {

    if(process[i].getArrivalTime()>process[j].getArrivalTime())

    swap(process[i],process[j]);

    }

    }

    }

    public void SortWithServiceTime(Process[]process)

    {

    //按服务时间排序

    int lastProcessFinishTime=0;//上一个进程的完成时间

    for(int i=0;i

    {

    for(int j=i+1;j

    {

    //在到达时间排序的基础上,进行服务时间的排序

    if(process[j].getArrivalTime()

    {

    if(process[i].getServiceTime()>process[j].getServiceTime())

    swap(process[i],process[j]);

    }

    }

    lastProcessFinishTime=lastProcessFinishTime+process[i].getServiceTime();

    }

    }

    public void swap(Process process1,Process process2)

    {

    //交换两个进程

    Process newProcess=new Process(process1.getName(),process1.getArrivalTime(),process1.getServiceTime());

    process1.setName(process2.getName());

    process1.setArrivalTime(process2.getArrivalTime());

    process1.setServiceTime(process2.getServiceTime());

    process2.setName(newProcess.getName());

    process2.setArrivalTime(newProcess.getArrivalTime());

    process2.setServiceTime(newProcess.getServiceTime());

    }

    public  void ProcessDetail(Process[] process,int totalTime)

    {

    //打印进程的过程

    for(int time=0;time<=totalTime;time++)

    {

    for(int i=0;i

    {

    if(process[i].getArrivalTime()==time)

    System.out.println("时刻"+time+"进程"+process[i].getName()+"到达");

    if(i==0&&time

    System.out.println("时刻"+time+"进程"+process[i].getName()+"正在执行");

    if(1<=i)

    {

    if(process[i-1].getFinishTime()<=time&&time=process[i].getArrivalTime())

    System.out.println("时刻"+time+"进程"+process[i].getName()+"正在执行");

    }

    if(process[i].getFinishTime()==time)

    System.out.println("时刻"+time+"进程"+process[i].getName()+"完成");

    if(i

    {

    if(time>process[i].getFinishTime()&&time

    {

    while(time!=process[i+1].getArrivalTime())

    {

    System.out.println("时刻"+time+"系统空闲");

    time++;

    }

    }

    }

    }

    }

    }

    }

    class FCFS

    {

    public  void PrintProcess(Process[] process)

    {

    //打印进程的名称,到达时间,服务时间

    for(int i=0;i

    {

    System.out.println("第"+(i+1)+"个进程的名称"+process[i].getName()+" "+"到达时间"+process[i].getArrivalTime()+"  "+"服务时间"+process[i].getServiceTime()+" "+"完成时间"+process[i].getFinishTime()+"  "+"周转时间"+process[i].getWholeTime() +"  "+"带权周转时间"+process[i].getWeightWholeTime());

    }

    }

    public  int FinishTime(Process[] process)

    {

    //求先来先服务算法的完成时间

    //按到达时间排序

    new Process().SortWithArrivalTime(process);

    int totalTime=0;

    int lastProcessFinishTime=process[0].getArrivalTime();//因为已经排序了 ,第一个进程到达的时间用来初始化上一个进程的完成时间

    for(int i=0;i

    {

    if(i==0)

    {

    //第一个进程单独处理

    process[i].setFinishTime(process[i].getServiceTime()+lastProcessFinishTime);

    lastProcessFinishTime=process[i].getServiceTime()+lastProcessFinishTime;

    }

    while(i!=0)

    {

    if(process[i].getArrivalTime()<=lastProcessFinishTime)

    {

    //当前进程到达时间小于上一个进程的完成时间

    process[i].setFinishTime(process[i].getServiceTime()+lastProcessFinishTime);

    lastProcessFinishTime=process[i].getServiceTime()+lastProcessFinishTime;

    break;

    }

    while(process[i].getArrivalTime()>lastProcessFinishTime)

    {

    //当前进程在上一个进程完成时还没到达

    lastProcessFinishTime++;

    }

    }

    }

    totalTime=lastProcessFinishTime;//返回给系统总时间

    return totalTime;

    }

    }

    class SJF

    {

    public  void PrintProcess(Process[] process)

    {

    //打印

    for(int i=0;i

    {

    System.out.println("第"+(i+1)+"个进程的名称"+process[i].getName()+" "+"到达时间"+process[i].getArrivalTime()+"  "+"服务时间"+process[i].getServiceTime()+" "+"完成时间"+process[i].getFinishTime()+"  "+"周转时间"+process[i].getWholeTime() +"  "+"带权周转时间"+process[i].getWeightWholeTime());

    }

    }

    public void swap(Process process1,Process process2)

    {

    //交换两个进程

    Process newProcess=new Process(process1.getName(),process1.getArrivalTime(),process1.getServiceTime());

    process1.setName(process2.getName());

    process1.setArrivalTime(process2.getArrivalTime());

    process1.setServiceTime(process2.getServiceTime());

    process2.setName(newProcess.getName());

    process2.setArrivalTime(newProcess.getArrivalTime());

    process2.setServiceTime(newProcess.getServiceTime());

    }

    public  int FinishTime(Process[] process)

    {

    //求短作业优先的完成时间

    //在FCFS的基础上,再对服务时间进行排序

    new Process().SortWithArrivalTime(process);

    new Process().SortWithServiceTime(process);

    int totalTime=0;

    int lastProcessFinishTime=process[0].getArrivalTime();

    for(int i=0;i

    {

    if(i==0)

    {

    //第一个进程单独处理

    process[i].setFinishTime(process[i].getServiceTime()+lastProcessFinishTime);

    lastProcessFinishTime=process[i].getServiceTime()+lastProcessFinishTime;

    }

    while(i!=0)

    {

    if(process[i].getArrivalTime()<=lastProcessFinishTime)

    {

    //当前进程到达时间小于上一个进程的完成时间

    process[i].setFinishTime(process[i].getServiceTime()+lastProcessFinishTime);

    lastProcessFinishTime=process[i].getServiceTime()+lastProcessFinishTime;

    break;

    }

    while(process[i].getArrivalTime()>lastProcessFinishTime)

    {

    //当前进程在上一个进程完成时还没到达

    lastProcessFinishTime++;

    }

    }

    }

    totalTime=lastProcessFinishTime;

    return totalTime;

    }

    }

    public class experiment {

    public static void sjf(Process[] process)

    {

    //进程个数为5

    //预期输出结果如下

    //    名称  到达时间  服务时间    完成时间      周转时间              带权周转时间                  平均周转时间为 7.8 平均带权周转时间为2.233

    //A  0      4    4      4          1.0

    //    B  1      3    9      8          2.666

    //    C  2      4    13      11        2.75

    //    D  3      2    6      3          1.5

    //    E  4      4    17      13        3.25

    System.out.println("SJF算法结果如下:——————————————————");

    int totalTime=new SJF().FinishTime(process);

    new Process(). WholeTime(process);

    new Process().WeightWholeTime(process);

    new Process().ProcessDetail( process, totalTime);

    System.out.println("SJF算法结束:——————————————————");

    new SJF(). PrintProcess(process);

    System.out.println("平均周转时间为"+new Process().AVG_WholeTime(process));

    System.out.println("平均带权周转时间为"+new Process().AVG_WeightWholeTime(process));

    }

    public static void fcfs(Process[] process)

    {

    //进程个数为5

    //预期输出结果如下

    //    名称  到达时间  服务时间    完成时间      周转时间              带权周转时间                  平均周转时间为 8.4 平均带权周转时间为2.7

    //A  0      4    4      4          1.0

    //    B  1      3    7      6          2.0

    //    C  2      4    11      9          2.25

    //    D  3      2    13      10        5.0

    //    E  4      4    17      13        3.25

    System.out.println("FCFS算法结果如下:——————————————————");

    int totalTime=new FCFS().FinishTime(process);

    new Process().WholeTime(process);

    new Process().WeightWholeTime(process);

    new Process().ProcessDetail( process, totalTime);

    System.out.println("FCFS算法结束:——————————————————");

    new FCFS().PrintProcess(process);

    System.out.println("平均周转时间为"+new Process().AVG_WholeTime(process));

    System.out.println("平均带权周转时间为"+new Process().AVG_WeightWholeTime(process));

    }

    public static void main(String[] args)  {

    Scanner Input=new Scanner(System.in);

    //System.out.println("请输入进程个数:");

    //int num=Input.nextInt();

    //      Process [] process=new Process[num];

    //      for(int i=0;i

    //      {

    //      System.out.println("请输入第"+(i+1)+"个进程的名称,到达时间,服务时间");

    //      String name=Input.next();

    //      int arrivalTime=Input.nextInt();

    //      int ServiceTime=Input.nextInt();

    //      process[i]=new Process(name,arrivalTime,ServiceTime);

    //      }

    Process [] process=new Process[5];

    process[0]=new Process("A",0,4);

    process[1]=new Process("B",1,3);

    process[2]=new Process("C",2,4);

    process[3]=new Process("D",3,2);

    process[4]=new Process("E",4,4);

    //      process[0]=new Process("A",1,2);

    //      process[1]=new Process("B",6,3);

    //      process[2]=new Process("C",14,5);

    //      process[3]=new Process("D",9,2);

    //      process[4]=new Process("E",20,3);  //考虑乱序,两个进程之间产生空闲时间

    System.out.println("选择FCFS算法请输入1,选择SJF算法请输入2,退出请输入0");

    String exe=Input.next();

    Input.close();

    if(Integer.parseInt(exe)==1)

    fcfs(process);

    if(Integer.parseInt(exe)==2)

    sjf(process);

    if(Integer.parseInt(exe)==0)

    return;

    }

    }

    ~~~

    展开全文
  • 课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码 问题描述 设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统,它们需要的服务时间分别为S1, … ,...
  • 操作系统:SJF算法——c++实现

    千次阅读 2020-05-29 10:22:34
    实现步骤: 1.将进程按到达时间排序; 进程开始运行: (1)在进程运行结束前到达的进程: ...class SJF { public: string name;//程序名 int a_time;//到达时间 int r_time;//运行时间 int s_time;//开始

    实现步骤:
    1.将进程按到达时间排序;
    进程开始运行:
    (1)在进程运行结束前到达的进程:
    比较运行时间—短的先运行
    (2)在进程运行结束前到达的进程:
    先到达的运行。

    	上源码:`
    
    #include <iostream>
    #include<string>
    using namespace std;
    class SJF {
    public:
    	string name;//程序名
    	int a_time;//到达时间
    	int r_time;//运行时间
    	int s_time;//开始时间
    	int f_time;//结束时间
    	int round_time;//z周转时间
    	double wr_time;//带权周转时间
    	double ar_time;//平均周转时间
    	double awr_time;//平均带权周转时间
    };	SJF a[1000];
    void sjf() {
    	int num, i, j, temp;
    	string t;
    	cout << "请输入进程个数 :";
    	cin >> num;
    	cout << "请输入" << num << "个进程名字" << endl;
    	for (i = 0; i < num; i++) {
    		cin >> a[i].name;
    		a[i].a_time = (int)rand() % 10 + 1;
    		a[i].r_time = (int)rand() % 10 + 1;
    	}//随机生成到达时间和运行时间
    	cout << "打印数据.................." << endl;
    	cout << "进程名" << " " << "到达时间" << " " << "运行时间" << " " << "开始时间" << " " << "结束时间" << " " << "周转时间" << " " << "带权周转时间" << " " << "平均周转时间" << " " << "平均带权周转时间" << endl;
    	for (i = 0; i < num; i++) {
    		cout << a[i].name << "\t" << a[i].a_time << "\t" << a[i].r_time << "\t\t" << 0 << "\t" << 0 << "\t" << 0 << "\t" << 0 << "\t" << 0 << "\t" << 0 << endl;
    	}
    	for (i = 1; i < num; i++) {
    		for (j = 0; j < num - i; j++) {
    			if (a[j].a_time > a[j + 1].a_time) {
    				t = a[j].name;
    				a[j].name = a[j + 1].name;
    				a[j + 1].name = t;
    
    				temp = a[j].a_time;
    				a[j].a_time = a[j + 1].a_time;
    				a[j + 1].a_time = temp;
    
    				temp = a[j].r_time;
    				a[j].r_time = a[j + 1].r_time;
    				a[j + 1].r_time = temp;
    			}
    		}
    	}//按到达时间排序 升序
    	for (int k = 0; k < num - 1; k++) {
    		if (a[k].a_time == a[k + 1].a_time&&a[k].r_time > a[k + 1].r_time) {
    			t = a[j].name;
    			a[j].name = a[j + 1].name;
    			a[j + 1].name = t;
    
    			temp = a[j].a_time;
    			a[j].a_time = a[j + 1].a_time;
    			a[j + 1].a_time = temp;
    
    			temp = a[j].r_time;
    			a[j].r_time = a[j + 1].r_time;
    			a[j + 1].r_time = temp;
    		}
    	}
    	cout << endl;
    	cout << "SJF算法。。。。。。。。。" << endl;
    	cout << "进程名" << " " << "到达时间" << " " << "运行时间" << "    " << "开始时间" << " " << "结束时间" << " " << "周转时间" << " " << "带权周转时间" << " " << "平均周转时间" << " " << "平均带权周转时间" << endl;
    
    	a[0].s_time = a[0].a_time + a[0].r_time;
    	a[0].f_time = a[0].a_time + a[0].r_time;
    	a[0].round_time = a[0].f_time - a[0].a_time;
    	a[0].wr_time = a[0].round_time / a[0].r_time;
    	a[0].ar_time = a[0].round_time;
    	a[0].awr_time = a[0].wr_time;
    	for (i = 1; i < num; i++) {
    		for (j = i; j < num - 1; j++) {
    			for (int d = i + 1; d < num; d++) {
    				if ((a[i - 1].f_time >= a[j].a_time) && (a[i - 1].f_time >= a[d].a_time) && (a[j].r_time > a[d].r_time)) {
    					t = a[j].name;
    					a[j].name = a[j + 1].name;
    					a[j + 1].name = t;
    
    					temp = a[j].a_time;
    					a[j].a_time = a[j + 1].a_time;
    					a[j + 1].a_time = temp;
    
    					temp = a[j].r_time;
    					a[j].r_time = a[j + 1].r_time;
    					a[j + 1].r_time = temp;
    				}
    			}
    		}
    		if (a[i].a_time < a[i - 1].f_time) {//当前到达时间在上一个作业结束时间之前
    			a[i].f_time = a[i - 1].f_time + a[i].r_time;
    			a[i].s_time = a[i - 1].f_time + a[i].r_time;
    			a[i].round_time = a[i].f_time - a[i].a_time;
    			a[i].wr_time = a[i].round_time / a[i].r_time;
    			a[i].ar_time = a[i].round_time / (i + 1);
    			a[i].awr_time = a[i].wr_time / (i + 1);
    		}
    		else {//之后
    			a[i].f_time = a[i].a_time + a[i].r_time;
    			a[i].s_time = a[i ].a_time + a[i].r_time;
    			a[i].round_time = a[i].f_time - a[i].a_time;
    			a[i].wr_time = a[i].round_time / a[i].r_time;
    			a[i].ar_time = a[i].round_time / (i + 1);
    			a[i].awr_time = a[i].wr_time /(i + 1);
    		}	
    	}
    	for (i = 0; i < num; i++) {
    		cout << a[i].name << "\t" << a[i].a_time << "\t" << a[i].r_time << "\t\t" << a[i].s_time <<"\t"<<a[i].f_time<< "\t" << a[i].round_time << "\t" << a[i].wr_time<< "\t\t" << a[i].ar_time << "\t\t" << a[i].awr_time << endl;
    	}
    }//如果到达时间相同就运行时间短的放前边
    int main()
    {
    	sjf();
    }
    
    
    
    
    
    
    展开全文
  • 用java简单实现fcfs算法和sjf算法
  • 在如上图的流程中,FCFS算法和SJF算法唯一的区别就是中间步骤的排序方法不同。因此,只需要替换代码中的排序方法即可。 本程序中,默认是FCFS算法,如果需要SPF算法,可以将dequeue()方法中被注释的...

    快速实现FCFS算法和SPF算法

    先来看看代码的总体结构:

    在这里插入图片描述

    在如上图的流程中,FCFS算法和SJF算法唯一的区别就是中间步骤的排序方法不同。因此,只需要替换代码中的排序方法即可。

    本程序中,默认是FCFS算法,如果需要SPF算法,可以将dequeue()方法中被注释的sortJcbsByServeTime()方法打开即可

    代码中的注释相对详细,有因为是早些时候写的,所以某些地方设计的不是特别好,还请理解

    代码

    • JCB实体类:

      package fcfs;
      
      import java.text.DecimalFormat;
      
      public class JCB {
          /**
           * 作业名
           */
          String name;
          /**
           * 到达时间
           */
          int arriveTime;
          /**
           * 服务时间
           */
          int serveTime;
          /**
           * 开始时间
           */
          int beginTime;
          /**
           * 结束时间
           */
          int finishTime;
          /**
           * 周转时间
           */
          int roundTime;
          /**
           * 带权周转时间
           */
          double aveRoundTime;
      
          public JCB() {
          }
      
          public JCB(String name, int arriveTime, int serveTime) {
              super();
              this.name = name;
              this.arriveTime = arriveTime;
              this.serveTime = serveTime;
          }
      
          @Override
          public String toString() {
              DecimalFormat df = new DecimalFormat("#0.00");
              return name + "\t\t"
                      + arriveTime + "\t\t"
                      + serveTime + "\t\t"
                      + beginTime + "\t\t"
                      + finishTime + "\t\t"
                      + roundTime + "\t\t"
                      + df.format(aveRoundTime);
          }
      }
      
    • ProcessQueue

      package fcfs;
      
      import java.text.DecimalFormat;
      import java.util.ArrayList;
      import java.util.Collections;
      import java.util.LinkedList;
      
      public class ProcessQueue {
      
          //jcbs的下标
          int index = 0;
          //当前的时间
          private int currentTime = 0;
          //所有任务
          private ArrayList<JCB> jcbs;
          //就绪队列
          private LinkedList<JCB> ready = new LinkedList();
          //执行结束后的结果
          private ArrayList<JCB> result = new ArrayList<>();
          //平均周转时间
          private double avgRoundTime = 0;
          //周转时间和
          private double sumRoundTime = 0;
          //平均带权周转时间
          private double avgAveRoundTime = 0;
          //带权周转时间和
          private double sumAveRoundTime = 0;
      
          public ProcessQueue(ArrayList<JCB> jcbs) {
              this.jcbs = jcbs;
              //排序(如果是FCFS算法,则不能被注释)
              sortJcbs();
          }
      
          /**
           * 将要做的所有作业按照到达顺序进行排序
           */
          public void sortJcbs() {
              Collections.sort(jcbs,(o1, o2) -> {
                  int time = o1.arriveTime - o2.arriveTime;
                  if (time > 0) {
                      return 1;
                  }else if (time == 0) {
                      //到达时间相同就比较服务时间
                      return o1.serveTime > o2.serveTime ? 1 : -1;
                  }else {
                      return -1;
                  }
              });
          }
      
          /**
           * 用于SJF算法
           * 对已到达的作业作业优先按照服务时间进行排序
           */
          public void sortJcbsByServeTime() {
              Collections.sort(ready,(o1, o2) -> {
                  int time = o1.serveTime - o2.serveTime;
                  if (time > 0) {
                      return 1;
                  }else if (time == 0) {
                      //到达时间相同就比较服务时间
                      return o1.arriveTime > o2.arriveTime ? 1 : -1;
                  }else {
                      return -1;
                  }
              });
          }
      
      
          /**
           * 到达的作业进入就绪队列
           */
          public void enqueue() {
      
              while (index < jcbs.size()) {
                  if (jcbs.get(index).arriveTime <= currentTime) {
                      //出队,index++,避免以及出队的进程重复出队
                      ready.add(jcbs.get(index));
                      index++;
                  }else {
                      break;
                  }
              }
      
          }
      
          /**
           * 第一个执行完的作业出队
           */
          public void dequeue() {
              if (!ready.isEmpty()) {
                  //如果是(SJF算法,则下面这个方法不能被注释)
                  //sortJcbsByServeTime();
                  JCB jcb = ready.removeFirst();
                  //设置出队列后的jcb的属性
                  jcb.beginTime = currentTime;
                  jcb.finishTime = jcb.beginTime + jcb.serveTime;
                  jcb.roundTime = jcb.finishTime - jcb.arriveTime;
                  jcb.aveRoundTime = (double) jcb.roundTime / jcb.serveTime;
                  //重置当前时间
                  currentTime = jcb.finishTime;
                  //记录出队列的结果
                  result.add(jcb);
              }
          }
      
          /**
           * 打印当前队列状况
           */
          public void showReady() {
      //        for (int i = 1; i < ready.size(); i++) {
      //            System.out.println("第" + i + "次队列情况:" + ready);
      //        }
              StringBuilder stringBuilder = new StringBuilder();
              stringBuilder.append("当前已到达的进程的情况:");
              ready.stream().forEach(r -> {
                  stringBuilder.append(r.name + " ");
              });
              System.out.println(stringBuilder.toString());
          }
      
          /**
           * 执行程序
           */
          public void run() {
              //当有作业的时候就一直循环
              while (index < jcbs.size()) {
                  //出队一个
                  dequeue();
                  //让到达的进程入队
                  enqueue();
                  //没有作业到达的时候,就等一下
                  if (ready.isEmpty()) {
                      currentTime++;
                  }
              }
              dequeue();
              dequeue();
              dequeue();
              System.out.println("++++++++++++++++++++++执++++++++行++++++++结++++++++果++++++++++++++++++");
              System.out.println("作业名" + "\t到达时间" + "\t服务时间" + "\t开始时间" + "\t完成时间" + "\t周转时间" + "\t带权周转时间");
              result.stream().forEach(s -> {
                  sumRoundTime += s.roundTime;
                  sumAveRoundTime += s.aveRoundTime;
                  System.out.println(s);
              });
              DecimalFormat df = new DecimalFormat("#0.00");
              avgAveRoundTime = sumAveRoundTime/result.size();
              avgRoundTime = sumRoundTime/result.size();
              System.out.println("平均周转时间:" + df.format(avgRoundTime));
              System.out.println("平均带权周转时间 " + df.format(avgAveRoundTime));
          }
      
      }
      
    • Main函数:

      package fcfs;
      
      import java.util.ArrayList;
      
      public class Main {
          public static void main(String[] args) {
              //所有任务
              ArrayList<JCB> jcbs = new ArrayList<>();
              JCB p1 = new JCB("0", 3, 2);
              JCB p2 = new JCB("1", 1, 2);
              JCB p3 = new JCB("2", 5, 3);
              JCB p4 = new JCB("3", 7, 1);
              jcbs.add(p1);
              jcbs.add(p2);
              jcbs.add(p3);
              jcbs.add(p4);
              
              //将任务传入Fcfs程序中运行
              ProcessQueue process = new ProcessQueue(jcbs);
      
              process.run();
          }
      }
      

    运行结果

    SPF算法:

    ++++++++++++++++++++++执++++++++行++++++++结++++++++果++++++++++++++++++
    作业名	到达时间	服务时间	开始时间	完成时间	周转时间	带权周转时间
    1		1		2		1		3		2		1.00
    0		3		2		3		5		2		1.00
    2		5		3		5		8		3		1.00
    3		7		1		8		9		2		2.00
    平均周转时间:2.25
    平均带权周转时间 1.25
    

    FCFS算法:

    ++++++++++++++++++++++执++++++++行++++++++结++++++++果++++++++++++++++++
    作业名	到达时间	服务时间	开始时间	完成时间	周转时间	带权周转时间
    2		1		1		1		2		1		1.00
    1		3		4		3		7		4		1.00
    3		5		1		7		8		3		3.00
    平均周转时间:2.67
    平均带权周转时间 1.67
    

    希望能帮助到大家^-^

    展开全文
  • 以洛谷P1223题为例,深入理解操作系统SJF算法
  • 《最短作业优先调度算法(SJF算法)的C++实现》由会员分享,可在线阅读,更多相关《最短作业优先调度算法(SJF算法)的C++实现(3页珍藏版)》请在人人文库网上搜索。1、在作业调度中,该算法每次从后备作业队列中挑选估计...
  • 文章目录一、先来先服务(FCFS)调度算法二、最短作业优先(SJF算法1. 非抢占式SJF2. 抢占式SJF三、优先级调度算法1. 非抢占式优先级调度算法2. 抢占式优先级调度算法四、时间片轮转(RR)算法五、多级队列调度 一...
  • 用c#FCFS与SJF算法实现作业调度.docx
  • 操作系统——sjf算法python实现

    千次阅读 2019-04-02 22:58:49
     print("最短进程优先算法SJF")  m = 1  while (m == 1):  option = int(input("请输入1运行算法(其他键退出):"))  if (option == 1):  SJF()  else:  print("退出计算")  m = 0   pcb.txt...
  • 里面有完整的实验报告以及代码 vs2019 c++
  • C#实现最短作业优先SJF算法--操作系统中的。
  • (1)对N个进程分别采用四种进程调度算法(轮转调度、静态优先级调度、动态优先级调度、最短进程优先调度)执行调度模拟。 (2)每个用来标识进程的进程表项(进程控制块 PCB)可用结构体来描述,包括以下字段(具体...
  • 进程调度之FCFS&&SJF算法(C语言版)

    千次阅读 2020-05-19 22:32:49
    分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度,计算每个进程的完成时间,周转时间和带权周转时间,并且统计n个进程的平均周转时间和平均带权周转时间。 注: 周转时间=作业完成时刻—作业到达时刻;...
  • FCFS和SJF作业调度算法模拟 带源代码 带源程序 可以直接使用
  • 在vc++6.0环境下实现对操作系统中调度算法FCFS和SJF算法的模拟。
  • 计算机操作系统的调度算法。是txt文本格式的,经编译可用。
  • 操作系统,的调度算法的短作业优先算法,SJF算法
  • xx 大学 操作系统 实验报告姓名: 学号: 班级: 实验日期:实验名称:先来先服务 FCFS 和短作业优先 SJF 进程调度算法实验一 先来先服务 FCFS 和短作业优先 SJF 进程调度算法1. 实验目的: 通过这次实验,理解 ...
  • 朔朔007操作系统实验报告实验一:作业调度学院:软件学院专业:软件工程班级:软件工程12-01姓名:***学号:541213460157实验一:作业调度实现FCFS和SJF调度算法【实验题目】:编写程序,实现FCFS和SJF算法,模拟...
  • 调度算法SJF调度算法详解

    万次阅读 多人点赞 2020-06-12 21:44:26
    详述我自身理解的SJF算法实现的思路,先按到达时间排序,再比较服务时间,附完整代码。
  • SJF算法具体实现
  • 操作系统实验报告实验一:作业调度学院:软件学院专业:软件工程班级:软件工程12-01姓名:***学号:541213460157实验一:作业调度实现FCFS和SJF调度算法【实验题目】:编写程序,实现FCFS和SJF算法,模拟作业调度过...
  • fcfs和sjf进程调度算法实验报告 FCFS 和 SJF 进程调度算法实验报告【实验题目】:编写程序,实现 FCFS 和 SJF 算法,模拟作业调度过程,加深对作业调度的理解。【实验内容】实现FCFS和SJF调度算法。– 数据结构设计...
  • 操作系统短作业优先算法java实现
  • 最短作业优先(SJF)调度算法

    千次阅读 2021-05-03 21:52:19
    最短作业优先(SJF)调度算法将每个进程与其下次 CPU 执行的长度关联起来。当 CPU 变为空闲时,它会被赋给具有最短 CPU 执行的进程。如果两个进程具有同样长度的 CPU 执行,那么可以由FCFS来处理。 一个更为恰当的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,506
精华内容 2,602
关键字:

sjf算法

友情链接: HMCOM.rar