1. 程式人生 > >java_實現先來先服務(FCFS)短作業優先演算法(SJF)

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

 

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.ByteBuffer;
import java.util.concurrent.CountDownLatch;


public class FCFSANDSJF {
  
   private  static int i;
   private  int j;
   private int qiao[];
   private int qiao1[];
   private int process_number;
   private int arrival_time[];
   private int services_time[];
   private int completion_time[];
   private int turn_around_time[];
   private int average_turn_around_time[];
   private double add1;
   private double add2;
   private double add3;
   private double add4;
   private double average_add[];
   private double average_add1[];
   private double right_turn_around_time[];
   private int a[];
   private int b[];
   private int c[];
   private int d[];
   private int exchange;
 private void  FCFSANDSJF(){
  this.process_number=process_number;
  this.services_time=services_time;
  this.arrival_time=arrival_time;
  
  
 }
 private  void Set_process_number(int process_nuber)
 {
  this.process_number=process_nuber;
  
 }
 private int get_process_number(){
  return process_number;
 }
 private void Set_arrival_time(int arrival_time[]){
  for(i=0;i<process_number;i++){
   this.arrival_time[i]=arrival_time[i];
  }
 }
 private int[]  get__arrival_time(){
  
  for(i=0;i<process_number;i++){
   qiao[i]= arrival_time[i];
  }
  return qiao;
 }
 
 private void Set_services_time(int services_time[]){
  for(i=0;i<process_number;i++){
   this.services_time[i]=services_time[i];
  }
 }
 private int[] get_services_time(){
  for(i=0;i<process_number;i++){
   qiao1[i]=services_time[i];
  }
  return qiao1;
 }
 private void FCFS(){
  
  System.out.println("\n===FCFS先來先服務演算法===");
  System.out.println("\n完成時間是:");
  for(i=0;i<process_number;i++){
   completion_time[i]=services_time[i];
   }
  for(i=0;i<process_number;i++){
   completion_time[i+1]=completion_time[i]+completion_time[i+1];
   
  }
  for(i=0;i<process_number;i++){
   System.out.print(completion_time[i]+"\t");
  }
  System.out.println("\n週轉時間是:");
  for(i=0;i<process_number;i++){
   turn_around_time[i]=completion_time[i]-arrival_time[i];
  }
  for(i=0;i<process_number;i++){
   System.out.print(turn_around_time[i]+"\t");
  }
  System.out.println("\n平均週轉時間是:");
  for(i=0;i<process_number;i++){
   average_turn_around_time[i]=turn_around_time[i];
   }
  for(i=0;i<process_number;i++){
   average_turn_around_time[i+1]=average_turn_around_time[i]+average_turn_around_time[i+1];
   add1=average_turn_around_time[i+1];
  }
  System.out.println(add1/process_number);
  System.out.println("\n帶權週轉時間:");
  for(i=0;i<process_number;i++){
   right_turn_around_time[i]=turn_around_time[i]/services_time[i];
   System.out.print(right_turn_around_time[i]+"\t");
  }
  System.out.println("\n平均帶權週轉時間:");
  for(i=0;i<process_number;i++){
   average_add[i]=right_turn_around_time[i];
   
  }
  for(i=0;i<process_number;i++){
   average_add[i+1]=average_add[i]+average_add[i+1];
   add2=average_add[i+1];
  }
  System.out.println(add2/process_number);
 }
 private void SJF(){
  System.out.println("\n===SJF:短作業優先演算法===");
  System.out.println("\n完成時間是:");
  for(i=0;i<process_number;i++){
   a[i]=services_time[i];
  }
  for(i=1;i<process_number-1;i++){
   for(j=i+1;j<process_number;j++){
    if(a[j]<a[i]){
     exchange=a[j];
     a[j]=a[i];
     a[i]=exchange;
    }
     
   }
  
  }
  for(i=1;i<process_number;i++){
   for(j=1;i<process_number;j++){
    if(a[i]==services_time[j]){
     b[i]=j;
     break;
    }
   }
  }
  b[0]=services_time[0];
  for(i=1;i<process_number;i++){
   a[i]=a[i]+a[i-1];
   c[b[i]]=a[i];
   
  }
  c[0]=4;
  for(i=0;i<process_number;i++){
   
   System.out.print(c[i]+"\t");
  }
  System.out.println("\n週轉時間是:");
  for(i=0;i<process_number;i++){
   turn_around_time[i]=c[i]-arrival_time[i];
  }
  for(i=0;i<process_number;i++){
   System.out.print(turn_around_time[i]+"\t");
  }
  for(i=0;i<process_number;i++){
   d[i]=turn_around_time[1];
  }
  for(i=0;i<process_number;i++){
   turn_around_time[i+1]=turn_around_time[i+1]+turn_around_time[i];
   add3=turn_around_time[i+1];
  }
  System.out.println("\n平均週轉時間是:"+add3/process_number);
  System.out.println("\n帶權週轉時間是:");
  for(i=0;i<process_number;i++){
   right_turn_around_time[i]=c[i]/services_time[i];
  }
  for(i=0;i<process_number;i++){
   System.out.print(right_turn_around_time[i]+"\t");
  }
  System.out.println("\n平均帶權週轉時間是:");
  for(i=0;i<process_number;i++){
   right_turn_around_time[i+1]=right_turn_around_time[i+1]+right_turn_around_time[i];
   add4=right_turn_around_time[i+1];
  }
  System.out.println(add4/process_number);
  
 }
 public static void main(String[] args) throws Exception{
  System.out.println("請輸入程序數:");
  FCFSANDSJF wo=new FCFSANDSJF();
  BufferedReader buf=null;
  buf=new BufferedReader(new InputStreamReader(System.in));
  String str1=null;
  str1=buf.readLine();
  wo.process_number=Integer.parseInt(str1);
  wo.arrival_time=new int[wo.process_number];
  wo.services_time=new int[wo.process_number];
  wo.completion_time=new int[wo.process_number+1];
  wo.turn_around_time=new int[wo.process_number+1];
  wo.average_turn_around_time=new int[wo.process_number+1];
  wo.right_turn_around_time=new double[wo.process_number+1];
  wo.average_add=new double[wo.process_number+1];
  wo.b=new int[wo.process_number+3];
  wo.a=new int[wo.process_number+3];
  wo.c=new int[wo.process_number+3];
  wo.d=new int[wo.process_number+3];
  
  String str=null;
  String str2=null;
 
  
  System.out.println("\n請輸入各程序到達時間");
  for(i=0;i<wo.process_number;i++){
   str=buf.readLine();
   wo.arrival_time[i]=Integer.parseInt(str);
  }
  
  
  System.out.println("\n請輸入各個程序服務時間");
  for(i=0;i<wo.process_number;i++){
   str2=buf.readLine();
   wo.services_time[i]=Integer.parseInt(str2);
   
  }
  System.out.println("該程序數為"+wo.process_number);
  System.out.println("\n到達時間為");
  for(i=0;i<wo.process_number;i++){
   System.out.print(wo.arrival_time[i]+"\t");
  }
  System.out.println("\n服務時間為:");
  for(i=0;i<wo.process_number;i++){
   System.out.print(wo.services_time[i]+"\t");
  }
  System.out.println("\n======先來先服務【0】========");
  System.out.println("\n======短作業優先【1】========");
  System.out.println("\n======退出系統【2】========");
  String str3=null;
  str3=buf.readLine();
  i=Integer.parseInt(str3);
  while(i!=2){
   
  switch (i) {
  case 0:
   wo.FCFS();
   break;
  case 1:
   wo.SJF();

  default:
   break;
  }
  if(i==2){
   break;
  }
  
  str3=buf.readLine();
  i=Integer.parseInt(str3);
      }
 }
        

}

相關推薦

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

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

作業系統之服務FCFS實現程式碼

完成與:2013.12.11實驗步驟:1. 演算法的思想先來先服務(FCFS)排程演算法是一種最簡單的排程演算法,該演算法既可用於作業排程,也可用於程序排程。採用FCFS演算法,每次從後備佇列中選擇一個或多個最先進入該佇列的作業,將他們調入記憶體,為他們分配資源,建立程序,然

磁碟排程-服務FCFS

為了減少對檔案的訪問時間,應採用一種最佳的磁碟排程演算法,以使各程序對磁碟的平均訪問時間最小,由於在訪問磁碟的實際那中主要是尋道時間,因此磁碟排程的目標是使磁碟的平均尋道時間最少。 先來先服務:根據程序請求訪問磁碟的先後次序進行排程。 輸入:起始磁軌以及要訪問的磁軌數目,

服務演算法FCFS作業優先演算法SJF

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

磁軌管理:服務FCFS

先來先服務:就是將申請磁碟服務的程序按先後順序排隊,每次排程選擇位於隊首的程序執行。假定當前磁頭處於第10道,等待服務的程序有七個,它們請求的磁軌順序是8、5、24、6、18、36、16。可以計算所有程序執行後磁頭一共移動的磁軌數:2+3+19+18+13+18+20=93下

作業系統:服務FCFS作業優先SJF程序排程演算法

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

作業排程演算法-服務FCFS

關於先到先服務演算法,我這裡只陳述幾個要點: 1.為什麼縮寫是FCFS? first-come first-served,先到先服務。 2.FCFS演算法中優先順序的評定標準? 優先順序根據等待時間來確定,等待時間越長,優先順序越高,越優先執行。 3.為

【作業系統 】服務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

1】服務FCFS作業優先SJF程序排程演算法

// 作業系統_實驗一.cpp : 定義控制檯應用程式的入口點。 // /* //實驗題目:先來先服務FCFS和短作業優先SJF程序排程演算法 *******概念******* 1. 先來先服務FCFS: 2. 短作業優先SJF: 3. 高階排程:根據某種演算法,在外存中把處於後備佇列中的那些作業調入記憶體,

作業系統——實驗一服務演算法作業優先演算法

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

服務作業優先演算法

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

Linux 中實現文件傳輸服務

term 安裝程序 fig gin 分享圖片 域名解析 anon size upload 繼續上章vsftpd,介紹vsftpd的虛擬用戶配置 一、背景需求 當有多個用戶需要不同的權限時,本地用戶、匿名用戶都無法控制那麽精細,這時候可以考慮下虛擬用戶了,例如有如下要求。

基於順序儲存實現的多叉樹1:深度優先儲存

需求分析    在資料結構中,樹有兩種儲存方式,一種是鏈式儲存,另一種是順序儲存。前者就是使用指標來記錄樹結點間的關係,在新增結點或刪除結點時,只需改變與父結點或兄弟結點的指標值即可,實現較為簡單;後者就是使用陣列來儲存,可以用相對偏移量來記錄樹結點間的關係,在新增結點或刪除結點時,則不僅是改變

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

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

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

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

作業優先演算法不完善

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

服務演算法FCFS java實現

package Arithmetic; import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.nio.ByteBuf

用C語言實現服務FCFS程序排程演算法

**分析:**先來先服務的意思就是哪個程序先到就先進行哪個程序,只與來的先後次序有關,等第一個程序執行完之後才會程序下一個程序的執行。 只有第一個程序的開始時間是它的到達時間,後邊的程序開始時間都是前一個進的完成時間。 完成時間就等於該程序的開始時間加上服務時間 週轉

Java實現程序排程演算法(一) FCFS(服務)

FCFS類(主類) 只有calc()中涉及了演算法,init()和printResult()都只有簡單的輸入輸出操作。 1 package xqy.algorithm; 2 3 import java.util.ArrayList; 4 import java.util.Scanner;