package me.letterwish.test;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.text.DecimalFormat;
import java.util.Scanner; //先来先服务FCFS和短作业优先SJF进程调度算法
public class FJFS_SJF {
// 允许的最大进程数
public static int MaxNum = 100;
// 真正的进程数
public static int realNum;
// 当前时间
public static int NowTime;
// 各进程的达到时间
public static int ArrivalTime[] = new int[MaxNum];
// 各进程的服务时间
public static int ServiceTime[] = new int[MaxNum];
// 各进程的服务时间(用于SJF中的临时数组)
public static int ServiceTime_SJF[] = new int[MaxNum];
// 各进程的完成时间
public static int FinishTime[] = new int[MaxNum];
// 各进程的周转时间
public static int WholeTime[] = new int[MaxNum];
// 各进程的带权周转时间
public static double WeightWholeTime[] = new double[MaxNum];
// FCFS和SJF的平均周转时间
public static double AverageWT_FCFS, AverageWT_SJF;
// FCFS和SJF的平均带权周转时间
public static double AverageWWT_FCFS, AverageWWT_SJF;
// FCFS中的周转时间总和
public static int SumWT_FCFS = 0;
// FCFS中的带权周转时间总和
public static double SumWWT_FCFS = 0;
// SJF中的周转时间总和
public static int SumWT_SJF = 0;
// SJF中的带权周转时间总和
public static double SumWWT_SJF = 0;
public static Scanner input; public static void main(String args[]) throws FileNotFoundException {
System.out.println("算法选择:FCFS-“1”,SJF-“2”");
input = new Scanner(System.in);
int choice = input.nextInt(); // 算法选择:FCFS-“1”,选SJF-“2”
// 从文件中输入数据 自己新建文件放到项目的根目录下
BufferedInputStream in = new BufferedInputStream(new FileInputStream(
"test.txt"));
System.setIn(in);
input = new Scanner(System.in); realNum = input.nextInt(); // 真实进程数
for (int i = 0; i < realNum; i++) { // 各进程的到达时间
ArrivalTime[i] = input.nextInt();
}
for (int j = 0; j < realNum; j++) { // 各进程的服务时间
ServiceTime[j] = input.nextInt();
ServiceTime_SJF[j] = ServiceTime[j];
}
// 关闭文件流
input.close(); // 算法选择:1-FCFS,2-SJF;
if (choice == 1) {
FCFS();
System.exit(0);
} else if (choice == 2) {
SJF();
System.exit(0);
} else {
System.out.println("算法选择错误");
System.exit(0);
}
} // 先来先服务FCFS进程调度算法
public static void FCFS() {
// 到达时间的冒泡排序,完成时间随之变动(使先到者排在前面,后到者排在后面)
bubbleSort();
// 计算每个进程的完成时间、周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间
FinishTime[0] = ArrivalTime[0] + ServiceTime[0];
WholeTime[0] = ServiceTime[0]; // 周转时间 = 完成时间 - 到达时间
WeightWholeTime[0] = (double) WholeTime[0] / ServiceTime[0];
// 带权周转时间 = 周转时间 / 服务时间
AverageWT_FCFS = AverageWWT_FCFS = 0; AverageWT_FCFS += WholeTime[0];
AverageWWT_FCFS += WeightWholeTime[0]; for (int j = 1; j < realNum; j++) { // 从第二个进程开始计算完成时间、周转时间、带权周转时间
if (ArrivalTime[j] > FinishTime[j - 1]) { // 该进程不用等待前一个进程就能直接执行
FinishTime[j] = ArrivalTime[j] + ServiceTime[j];
WholeTime[j] = ServiceTime[j];
} else { // 该进程需要等待前一个进程完成才能执行
FinishTime[j] = FinishTime[j - 1] + ServiceTime[j];
WholeTime[j] = FinishTime[j - 1] - ArrivalTime[j]
+ ServiceTime[j];
}
WeightWholeTime[j] = (double) WholeTime[j] / ServiceTime[j];
// 带权周转时间 = 周转时间 / 服务时间
}
for (int i = 0; i < realNum; i++) { // 计算总周转时间、总带权周转时间
SumWT_FCFS = SumWT_FCFS + WholeTime[i];
SumWWT_FCFS = SumWWT_FCFS + WeightWholeTime[i];
}
AverageWT_FCFS = (double) SumWT_FCFS / realNum; // 平均周转时间 = 周转总时间 / 作业个数
AverageWWT_FCFS = (double) SumWWT_FCFS / realNum; // 平均带权周转时间 = 带权周转总时间
// / 作业个数
// 输出每个进程的完成时间、周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间
outPUT(1);
} // 短作业优先SJF进程调度算法
public static void SJF() {
// 到达时间的冒泡排序,完成时间随之变动(使先到者排在前面,后到者排在后面)
bubbleSort(); int min = 0;
NowTime = ArrivalTime[0] + ServiceTime[0];// 计算第一次的NowTIme
FinishTime[0] = ServiceTime[0];// 计算第一个进程的完成时间
ServiceTime_SJF[0] = 1000;// 赋初值
int allin = 0, j, k;
for (int i = 1; i < realNum; i++)// 进入循环,从第二个到达的进程开始
{
if (allin == 0)// 找到已经到达的进程个数
{
for (j = 0; ArrivalTime[j] <= NowTime && j < realNum; j++) {
if (j >= realNum)
allin = 1;
}
} else {
j = realNum;
} j = j - 1;// j是已经到达的进程数(减去已经计算过的第一个进程) min = 0;
k = 1;
while (k <= j)// 从已经到达的进程里找到服务时间最短的进程
{
if (ServiceTime_SJF[k] == 0)// 进程的服务时间如果等于0,则跳过该进程
k++;
else {
if (ServiceTime_SJF[min] > ServiceTime_SJF[k])// 比较,找到服务时间最短的进程
min = k;
k++;
}
}
ServiceTime_SJF[min] = 0;// 找完后置零,便于下一次循环时跳过
NowTime += ServiceTime[min];// 累加当前时间
FinishTime[min] = NowTime;// 完成时间
} for (int i = 0; i < realNum; i++)// 计算周转时间,带权周转时间,总的周转时间和总的带权周转时间
{
WholeTime[i] = FinishTime[i] - ArrivalTime[i];// 周转时间 = 完成时间 - 到达时间
WeightWholeTime[i] = (double) WholeTime[i] / ServiceTime[i];// 带权周转时间
// =
// 周转时间
// /
// 服务时间
SumWT_SJF += WholeTime[i];
SumWWT_SJF += WeightWholeTime[i];
}
AverageWT_SJF = (double) SumWT_SJF / realNum;// 平均周转时间 = 周转总时间 / 作业个数
AverageWWT_SJF = (double) SumWWT_SJF / realNum;// 平均带权周转时间 = 带权周转总时间 /
// 作业个数 // 输出每个进程的完成时间、周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间
outPUT(2);
} // 到达时间的冒泡排序,完成时间随之变动(使先到者排在前面,后到者排在后面)
public static void bubbleSort() {
int temp1 = 0;
int temp2 = 0;
for (int i = 0; i < realNum - 1; i++) {
for (int j = 0; j < realNum - 1; j++) {
if (ArrivalTime[j] > ArrivalTime[j + 1]) {
temp1 = ArrivalTime[j];
temp2 = ServiceTime[j];
ArrivalTime[j] = ArrivalTime[j + 1];
ServiceTime[j] = ServiceTime[j + 1];
ArrivalTime[j + 1] = temp1;
ServiceTime[j + 1] = temp2;
}
}
}
} // 输出每个进程的完成时间、周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间
// a=1:输出FCFS结果 a=2:输出SJF结果
public static void outPUT(int a) {
int k;
DecimalFormat format = new DecimalFormat("#.00");
System.out.print("到达时间 :");
for (k = 0; k < realNum; k++) {
System.out.print(ArrivalTime[k] + " ");
}
System.out.println("");
System.out.print("服务时间 :");
for (k = 0; k < realNum; k++) {
System.out.print(ServiceTime[k] + " ");
}
System.out.println("");
System.out.print("完成时间 :");
for (k = 0; k < realNum; k++) {
System.out.print(FinishTime[k] + " ");
}
System.out.println("");
System.out.print("周转时间 :");
for (k = 0; k < realNum; k++) {
System.out.print(WholeTime[k] + " ");
}
System.out.println("");
System.out.print("带权周转时间:");
for (k = 0; k < realNum; k++) {
System.out.print(format.format(WeightWholeTime[k]) + " ");
}
System.out.println(""); if (a == 1) {
System.out.println("平均周转时间:" + format.format(AverageWT_FCFS));
System.out.println("平均带权周时间:" + format.format(AverageWWT_FCFS));
} else {
System.out.println("平均周转时间 :" + format.format(AverageWT_SJF));
System.out.println("平均带权周转时间:" + format.format(AverageWWT_SJF));
} // 模拟整个调度过程,输出每个时刻的进程运行状态
System.out.println("时刻" + ArrivalTime[0] + ":进程" + 1 + "开始运行");
for (int i = 1; i < realNum; i++)
System.out.println("时刻" + FinishTime[i - 1] + ":进程" + (i + 1)
+ "开始运行");
}
}

test.txt的文件格式

第一行 进程个数

第二行 到达时间

第三行 服务时间

os的进程调度算法(抄袭的)的更多相关文章

  1. Linux常见的进程调度算法

    进程调度:在操作系统中调度是指一种资源分配. 调度算法是指: 根据系统的资源分配策略所规定的资源分配算法. 操作系统管理了系统的有限资源,当有多个进程(或多个进程发出的请求)要使用这些资源时,因为资源 ...

  2. Python::OS 模块 -- 进程参数

    os模块的简介请参看 Python::OS 模块 -- 简介 os模块的文件和目录操作 Python::OS 模块 -- 文件和目录操作 os模块的进程管理 Python::OS 模块 -- 进程管理 ...

  3. Python::OS 模块 -- 进程管理

    os模块的简介参看 Python::OS 模块 -- 简介 os模块的文件相关操作参看 Python::OS 模块 -- 文件和目录操作 os模块的进程参数 Python::OS 模块 -- 进程参数 ...

  4. 进程调度算法Linux进程调度算法

    这次介绍一下操作系统的进程调度算法 操作系统的调度分为三种:1.远程调度(创建新进程):2.中程调度(交换功能的一部分):3.短程调度(下次执行哪个进程) 这次讲述的就是短程调度,可以简单的看作咱们平 ...

  5. Linux 常见的进程调度算法

    1.在介绍进程调度之前,先对进程的状态的概念应该有所了解,下面是关于进程状态的一些基本概念:进程的状态分为三种,分别为: 1).运行态:该状态表明进程在实际占用CPU 2).就绪态: 该状态下进程可以 ...

  6. 《操作系统_时间片轮转RR进程调度算法》

    转自:https://blog.csdn.net/houchaoqun_xmu/article/details/55540250 时间片轮转RR进程调度算法 一.概念介绍和案例解析时间片轮转法 - 基 ...

  7. OS之进程管理---进程调度和多线程调度

    进程调度基本概念 多道程序的目标就是始终允许某个进程运行以最大化CPU利用率,多个进程通时存在于内存中,操作系统通过进程调度程序按特定的调度算法来调度就绪队列中的进程到CPU,从而最大限度的利用CPU ...

  8. Linux内核初探 之 进程(三) —— 进程调度算法

    一.基本概念 抢占 Linux提供抢占式多任务,基于时间片和优先级对进程进行强制挂起 非抢占的系统需要进程自己让步(yielding) 进程类型 IO消耗型 经常处于可运行态,等待IO操作过程会阻塞 ...

  9. x01.os.9: 进程切换

    进入内核后,当然不能无所事事.先创建三个进程,分别打印 A,B,C.虽然只是简单的打印,但却是一切扩展的基础,不可等闲视之. 进程切换,涉及一系列的寄存器需要保护,于是,就有了 ProcessStac ...

随机推荐

  1. CodeForces 580B(尺取法)

    Kefa and Company 题意:Kefa这个人要去吃饭,他要邀请一些朋友一起去,他的每个朋友有两个属性金钱和关系度,要求邀请的人里边任意两个人之间的金钱差的绝对值不大于d:求被邀请的所有朋友的 ...

  2. 23.match_phrase_prefix实现search-time搜索推荐

    主要知识点: 搜索推荐的使用场景 用法 原理 一.搜索推荐的使用场景 搜索推荐,就是在你做搜索时,当你写出一部搜索词时,es会自提示接下来要写的词,比如当你在搜索hello w 时,如果es中有如下文 ...

  3. hdu2012 素数判定【C++】

    素数判定 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submis ...

  4. 00110_Class类

    1.Class 对象是在加载类时由 Java虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的: 2.获取Class对象的三种方式 (1)方式一:通过Object类中的getObj ...

  5. Python 1 初识python

    1.Python介绍 Python是一种高级语言,与JAVA C# 等同.可以编写各种应用程序,每种语言都有其合适的应用场景.而Python 的优势在于更加人性化.简便的语法规则,以及针对各种具体场景 ...

  6. 算是学完了《Servlet&JSP学习笔记》,立此存照

    我感觉从构架上来说,算是入门了, 终于可以正式进入SPRING的学习啦...爽 代码就不弄了,真的太多了...花了差不多两周呢..

  7. hdu_1014_Uniform Generator_201310141958

    Uniform Generator Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others ...

  8. LeetCode——Permutation Sequence

    The set [1,2,3,-,n] contains a total of n! unique permutations. By listing and labeling all of the p ...

  9. 【bzoj2038】[2009国家集训队]小Z的袜子(hose)(细致总结)

    [bzoj2038][2009国家集训队]小Z的袜子(hose)(细致总结) Description 作为一个生活散漫的人,小Z每天早上都要耗费很久从一堆五颜六色的袜子中找出一双来穿.终于有一天,小Z ...

  10. linux端口号与PID的互相查询

    最近用linux在玩Tomcat,启动的时候总是会报错(8080/8009/8005) 于是整理了一下网上零乱的查看PID和端口的命令,以备记录. 1.由端口号查询PID号 首先myeclipse报错 ...