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;