~~~
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.length;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.length;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<process.length;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<process.length;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<process.length;i++)
{
for(int j=i+1;j<process.length;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<process.length;i++)
{
for(int j=i+1;j<process.length;j++)
{
//在到达时间排序的基础上，进行服务时间的排序
if(process[j].getArrivalTime()<lastProcessFinishTime)
{
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<process.length;i++)
{
if(process[i].getArrivalTime()==time)
System.out.println("时刻"+time+"进程"+process[i].getName()+"到达");
if(i==0&&time<process[i].getFinishTime())
System.out.println("时刻"+time+"进程"+process[i].getName()+"正在执行");
if(1<=i)
{
if(process[i-1].getFinishTime()<=time&&time<process[i].getFinishTime()&&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<process.length-1)
{
if(time>process[i].getFinishTime()&&time<process[i+1].getArrivalTime())
{
while(time!=process[i+1].getArrivalTime())
{
System.out.println("时刻"+time+"系统空闲");
time++;
}
}
}
}
}
}
}
class FCFS
{
public void PrintProcess(Process[] process)
{
//打印进程的名称,到达时间，服务时间
for(int i=0;i<process.length;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<process.length;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<process.length;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<process.length;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<num;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;
}
}
~~~
网友评论