2. 程式人生 > >最短作業優先演算法

最短作業優先演算法

阿新 • • 發佈：2018-12-26
public class Operating {
 public static String dealTime(String time, int parMinutes) {
  StringTokenizer tokenizer = new StringTokenizer(time,":");
  String hour = tokenizer.nextToken();
  String minute = tokenizer.nextToken();
  int intHour = Integer.parseInt(hour);
  int intMinute = Integer.parseInt(minute);
  if((intMinute + parMinutes) < 60) {
   intMinute = intMinute + parMinutes;
  }else {
   intHour = (int)(intMinute + parMinutes)/60 + intHour;
   intMinute = (intMinute + parMinutes)%60;
  }
  if(intMinute < 10)
   return intHour+":0"+intMinute;
  else
   return intHour+":"+intMinute;
 }
 public static boolean compareTime(String time1,String time2) {
  
  StringTokenizer tokenizer1 = new StringTokenizer(time1,":");
  String hour1 = tokenizer1.nextToken();
  String minute1 = tokenizer1.nextToken();
  int intHour1 = Integer.parseInt(hour1);
  int intMinute1 = Integer.parseInt(minute1);
  
  StringTokenizer tokenizer2 = new StringTokenizer(time2,":");
  String hour2 = tokenizer2.nextToken();
  String minute2 = tokenizer2.nextToken();
  int intHour2 = Integer.parseInt(hour2);
  int intMinute2 = Integer.parseInt(minute2);
  
  if(intHour1 > intHour2) {
   return true;
  }else if (intHour1 == intHour2) {
   if(intMinute1 > intMinute2) {
    return true;
   }
  }
  return false;
 }
 public static void main(String[] args) throws Exception {
  int sumOverturn = 0;
  float sumWithPower = 0;
  int jobNum = 0;
  BufferedReader fromFile = new BufferedReader(new FileReader("in.txt"));
  Vector<Job> jobs = new Vector<Job>();  
  String jobInLine;
  while((jobInLine = fromFile.readLine()) !=null) {
   Job job = new Job();
   StringTokenizer  strTokenizer = new StringTokenizer(jobInLine);
   job.setName(strTokenizer.nextToken());
   job.setInTime(strTokenizer.nextToken());
   job.setMaybeRunTime(Integer.parseInt(strTokenizer.nextToken()));
   jobs.addElement(job);
  }  
  System.out.println("作業名稱 " + "/t進入 " + "/t開始" + "/t結束 " + "/t週轉時間 " + "/t帶權週轉時間 ");
  while(!jobs.isEmpty()) {
   Job toDealJob = new Job();
   int k = 0;
   for (int i = 0,j = 0;i < jobs.size();) {
    i = 0;
    j = 0;
    k = 0;
    toDealJob = jobs.elementAt(i);    
    for (j = i + 1;j < jobs.size(); j++) {
     String jInTime = jobs.elementAt(j).getInTime();
     String nowTime = Operating.dealTime(toDealJob.getInTime(),toDealJob.getWaitTime());
     
     
     if((jobs.elementAt(j).getMaybeRunTime() < toDealJob.getMaybeRunTime())
       && (Operating.compareTime(jInTime, nowTime))) {
       toDealJob = jobs.elementAt(j);
       k = j;
     }
    }
    String startTime = Operating.dealTime(toDealJob.getInTime(), toDealJob.getWaitTime());    
    toDealJob = jobs.elementAt(k);
    int overturn = toDealJob.getWaitTime() + toDealJob.getMaybeRunTime();
    float withPower = overturn/toDealJob.getMaybeRunTime();
    String endTime = Operating.dealTime(toDealJob.getInTime(), overturn);
    System.out.println(toDealJob.getName() + "/t" //作業名稱
         + toDealJob.getInTime()+ "/t" //進入
         + startTime +  "/t" //開始
         + endTime + "/t"//結束
         + overturn + "/t"
         + withPower);
    sumOverturn = sumOverturn + overturn;
    sumWithPower = sumWithPower + withPower;
    jobNum++;    
    for(int t = 0;t < jobs.size();t++) {
     jobs.elementAt(t).setWaitTime(jobs.elementAt(t).getWaitTime() + toDealJob.getMaybeRunTime());
    }
    jobs.remove(k);
   }
  }
  System.out.println();
  float averageOverturn = sumOverturn/jobNum;
  float averageWithPower = sumWithPower/jobNum;
  System.out.println("平均週轉時間為 ：" + averageOverturn + " 分鐘");
  System.out.println("平均帶權週轉時間為 ：" + averageWithPower + " 分鐘");
 }
}

/////////////////////////////////////////////////////////////////////////////////////////


in.txt的內容:

Job1 12:00 30
Job2 12:30 40
Job3 12:40 30
Job4 13:00 30
Job5 13:50 50
Job6 14:00 30
Job7 14:40 30
Job8 15:01 30

相關推薦

最短作業優先演算法

public class Operating { public static String dealTime(String time, int parMinutes) {  StringTokenizer tokenizer = new StringTokenizer(time,":");  String h

排程演算法之最短作業優先演算法

最短作業優先演算法又叫做短程序優先演算法 寫此博文目的： 1.方便自己複習 2.給正在學習此演算法的人一點參考 單道（一次只能執行一個程序） 分析： 先將程序按照到達時間升序排序，第一個程序到達的時候不等待，直接執行，因為他是第一個到達的程序，在他之前沒有程序在執行，當有程序到達但是有其他程序在執行的時候，到

最短作業優先演算法（不完善）

最短作業優先（SJF） 問題描述： 最短作業優先（SJF）是一種除錯任務請求的除錯策略。每個任務請求都含有請求時間（即向系統提交請求的時間）和持續時間（即完成任務所需時間）屬性。當前任務完成後，SJF策略選擇最短持續時間的任務執行；如果多個任務具有相

Java模擬最短作業優先、時間片輪轉、最高響應比三種程序排程演算法

本次試驗是使用程式來模擬作業系統中程序排程的三種不同的排程策略，分別為最短作業有限、時間片輪轉、最高響應比。 模擬的情況下，程序數為8，程序所需執行時間為隨機產生的整數，單位為1S，預設程序同時到達。 以下是實驗的程式碼： Process.java是測試類，用於生成程序列表

用C語言寫的一個最短作業優先排程演算法

#include <stdio.h> //定義一個結構體 struct sjf{ char name[10]; //程序名 float arrivetime; //到達時間 float servicetime;//服務時間 float starttime; //開

最短作業優先排程演算法（SJF演算法）的C++實現

題目要求： 在作業排程中，該演算法每次從後備作業佇列中挑選估計服務時間最短的一個或幾個作業，將他們調入記憶體，分配必要的資源，建立程序並放入就緒佇列。與在程序排程中的原理類似。假設有n項作業位於就緒佇

最短作業優先（SJF）

cin abs ios ont logs vector cal get 變化 1. 最短作業優先： 最短作業優先（SJF）是一種調度任務請求的調度策略。每個任務請求包含有請求時間（即向系統提交的請求的時間）和持續時間（即完成任務所需時間）。 當前任務完成後，

短作業優先演算法c++版

 #include "stdafx.h" #include "iostream" #include "string" using namespace std; struct JOB//作業結構體 {  string  name; //程序名  

用java語言模擬短作業優先演算法

package two; public class Job { private String name;//作業名稱（ID) private int execTime; //執行時間 private long startTime;//開始時間 private int endTime;//

先來先服務演算法（FCFS）和 短作業優先演算法（SJF）

先來先服務演算法（FCFS） FCFS是最簡單的排程演算法，既可以用作作業排程，也可以用作程序排程 這種演算法優先考慮系統中等待時間最長的作業（程序），而不管作業所需執行時間長短， 做法是從後備佇列中選擇幾個最先進入該佇列的作業，將它們調入記憶體，為它們分配資源和建

計算機作業系統排程演算法——短作業優先演算法簡單實現

//排程演算法的模擬 //1.SJF 短作業優先演算法 #include<stdio.h> #include <malloc.h> #include <string> #include <string.h> #include

C語言寫的作業系統短作業優先演算法

短作業優先的演算法思想：        通過對執行時間的排序然後比較，執行時間短的程序優先執行，第一個程序的開始時間等於到達時間，完成時間=開始時間+服務時間，當下一個程序的開始時間>=該程序的完成時間時，下一個程序的開始時間=上一個程序的完成時間，週轉時間和帶權週轉時

java_實現先來先服務（FCFS）短作業優先演算法(SJF)

  import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.nio.ByteBuffer; import java.ut

短作業優先演算法c++實現

短作業優先：短作業優先（SJF, Shortest Job First）又稱為“短程序優先”SPN(Shortest Process Next)；這是對FCFS演算法的改進,其目標是減少平均週轉時間.定義對預計執行時間短的作業（程序）優先分派處理機.通常後來的短作業不搶先正在

作業系統——實驗一（先來先服務演算法和短作業優先演算法）

作業系統實驗報告一[實驗題目]先來先服務FCFS和短作業優先SJF排程演算法[實驗目的]通過本次實驗，加深對程序概念的理解，進一步掌握對程序狀態轉變、程序排程策略及對系統性能的評價方法。[實驗內容]程式設計實現如下內容：1.先來先服務演算法； 2.短程序優先演算法；3.根據排

先來先服務和短作業優先演算法

先來先服務演算法（FCFS） FCFS是最簡單的排程演算法，既可以用作作業排程，也可以用作程序排程 這種演算法優先考慮系統中等待時間最長的作業（程序），而不管作業所需執行時間長短， 做法是從後備佇列中選擇幾個最先進入該佇列的作業，將它們調入記憶體，為它們分

作業系統：先來先服務FCFS和短作業優先SJF程序排程演算法

目的：陸續整理近一年的學習收穫                                先來先服務FCFS和短作

【作業系統 】先來先服務FCFS和短作業優先SJF程序排程演算法

  1.先來先服務FCFS和短作業優先SJF程序排程演算法 2.時間片輪轉RR程序排程演算法 3.預防程序死鎖的銀行家演算法 4.動態分割槽分配演算法 5.虛擬記憶體頁面置換演算法 6.磁碟排程演算法 void FCFS() { /* 1. 找

《作業系統》 先來先服務FCFS和短作業優先SJF程序排程演算法相關計算及實驗

  為了和FCFS排程演算法進行比較，我們仍利用FCFS演算法中所使用的例項，並改用SJ(P)F演算法重新排程，再進行效能分析。由上圖中的(a)和(b)可以看出，採用SJ(P)F演算法後，不論是平均週轉時間還是平均帶權週轉時間，都有較明顯的改善，尤其是對短作業D，其週轉時間由原來的(用FCFS演算法時)1

短作業優先排程演算法（SJF）——Java實現

短作業優先排程演算法（SJF）         短作業優先排程演算法（Short Job First）用於程序排程時又被稱為短程序優先排程演算法（Short Process First），該演算法既可以用於作業排程，又可以用於程序排程。         在作業排程中，該