首先，我是用java写的，当然的面向对象的思想设计。。
设计思路是模拟。按时间一个单位单位的处理。。。每运行一个时间单位，加入到达的进程（开始时间小于当前时间的），然后处理运行的进程，处理运行的队列。
进程类：包含进程的相关信息（名，开始时间，服务时间，优先级，运行时间，完成时间）
队列：完成先进先出功能，还实现了优先队列。。（没有考虑效率。嘿嘿，作业而已。。。）
运行：设置了准备队列（按开始时间排序,等待运行时间到达加入运行队列），运行队列（就绪等待调度的队列），完成队列（运行完成的进程），正在运行的进程（正在运行的进程，没有为空），时间（当前运行的时间，初值为-1，运行一次后为刚开始第0时间的状态。。）
主函数：输入，调用运行类运行，输出。
代码可以到（http://pan.baidu.com/s/1mg9JkNY）下载。这里粘出一部分。。。。
process类：
package test2;
/**
*
* @ClassName: Process
* @Description: TODO(进程对象)
* @author 朱争光 1023024917@qq.com
* @date 2014-4-9 下午10:16:00
*
*/
public class Process {
private static int id=0;//用途：设置默认id
private String Proname;//进程名
private int stratTime;//进程的到达时间
private int serviceTime;//进程的服务时间
private int level;//优先级，数值越小优先权越高
private char proState;//进程状态（W——等待,R——运行,F——完成）
private int runTime;//已经执行了多少时间
private int finishTime;//完成时用了多少时间
public Process (){
this.stratTime=0;
this.serviceTime=0;
this.proState='W';
this.finishTime=0;
this.level=0;
}
public Process (int stratTime,int serviceTime ){
this();
this.stratTime=stratTime;
this.serviceTime=serviceTime;
}
public String toString (int style){
if(style==ProcessStyle.OnlyProname){
return this.Proname;
}else if(style==ProcessStyle.runFinishTime){
return this.Proname+"("+this.stratTime+","+this.serviceTime+","+this.runTime+","+this.finishTime+")";
}else{
return this.Proname+"("+this.stratTime+","+this.serviceTime+","+this.level+","+this.runTime+","+this.finishTime+")";
}
}
public void SetAutoProname (){
this.Proname="Pro"+id;
id++;
}
public String getProname() {
return Proname;
}
public void setProname(String proname) {
Proname = proname;
}
public int getStratTime() {
return stratTime;
}
public void setStratTime(int stratTime) {
this.stratTime = stratTime;
}
public int getServiceTime() {
return serviceTime;
}
public void setServiceTime(int serviceTime) {
this.serviceTime = serviceTime;
}
public char getProState() {
return proState;
}
public void setProState(char proState) {
this.proState = proState;
}
public int getRunTime() {
return runTime;
}
public void setRunTime(int runTime) {
this.runTime = runTime;
}
public int getFinishTime() {
return finishTime;
}
public void setFinishTime(int finishTime) {
this.finishTime = finishTime;
}
public static int getId() {
return id;
}
public static void setId(int id) {
Process.id = id;
}
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
}
run类：
package test2;
import java.util.ArrayList;
import java.util.List;
/**
*
* @ClassName: Run
* @Description: TODO(处理机调度)
* @author 朱争光 1023024917@qq.com
* @date 2014-4-10 下午5:03:51
*
*/
public abstract class Run {
List<Process> readylist=new ArrayList<Process>();//所有初始化进程(有序，开始时间降序)
Queue<Process> runlist=new Queue<Process>();//进入执行的进程
List<Process> finishList=new ArrayList<Process>();//完成队列
Process runProcess;//保持正在运行的进程
int tip=-1;//保存当前运行时间单位，初始化为-1为运行，执行一次进入t=0状态
/**
*
* @Title: addProcess
* @Description: TODO(根据开始时间顺序添加进程)
* @param process
* @return int
* @throws
*/
private int addProcess (Process process){
process.setRunTime(0);
process.setFinishTime(0);
process.setProState('W');
int flag=0;
for(int i=readylist.size()-1;i>=0;i--){
if(readylist.get(i).getStratTime()<process.getStratTime()){
readylist.add(i,process);
flag=i+1;
break;
}
}
if(flag==0)
readylist.add(process);
return flag;
}
/**
*
* @Title: setReadylist
* @Description: TODO(加入初始化队列)
* @param readylist void
* @throws
*/
public void setReadylist(List<Process> readylist) {
for (Process process : readylist) {
addProcess(process);
}
}
abstract public boolean AddRunlistFromReadyListByTip();//根据时间把进程加入运行队列
abstract public boolean run ();//处理机调度，执行1个单位时间
/**
*
* @Title: runToEnd
* @Description: TODO(执行调度知道完成)
* @return boolean
* @throws
*/
public boolean runToEnd (){
while(isEnd ()){
run();
if(tip>0&&tip%100==0){
System.out.println("怀疑为无法完成调度，已停止，可以继续执行");
return false;
}
}
return true;
}
/**
*
* @Title: isEnd
* @Description: TODO(判断是否完成调度)
* @return boolean
* @throws
*/
public boolean isEnd (){
if(runlist.size()>0||readylist.size()>0||runProcess!=null){
return false;
}
else {
return true;
}
}
//输出当前状态 参数为进程输出格式
public String toString (int outStyle){
StringBuilder sBuilder=new StringBuilder();
sBuilder.append(tip+"-"+(tip+1));
while(sBuilder.length()<10) sBuilder.append(' ');
if(runProcess!=null){
sBuilder.append(runProcess.toString(ProcessStyle.all));
}else {
sBuilder.append("none");
}
while(sBuilder.length()<30) sBuilder.append(' ');
sBuilder.append("(");
for (int i = 0; i < finishList.size(); i++) {
sBuilder.append(finishList.get(i).toString(outStyle)+"<--");
}
sBuilder.append(")");
while(sBuilder.length()<60) sBuilder.append(' ');
sBuilder.append("(");
for (int i = 0; i < runlist.size(); i++) {
sBuilder.append(runlist.get(i).toString(outStyle)+"<--");
}
sBuilder.append(")");
while(sBuilder.length()<100) sBuilder.append(' ');
sBuilder.append("(");
for (int i = readylist.size()-1; i >=0 ; i--) {
sBuilder.append(readylist.get(i).toString(outStyle)+"<--");
}
sBuilder.append(") ");
return sBuilder.toString();
}
public List<Process> getReadylist() {
return readylist;
}
public Queue<Process> getRunlist() {
return runlist;
}
public List<Process> getFinishList() {
return finishList;
}
public Process getRunProcess() {
return runProcess;
}
public int getTip() {
return tip;
}
}
main类：
package test2;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class MainRR {
private Scanner cin;
private List<Process> scanf(){
List<Process> list=new ArrayList<Process>();
System.out.println("--------输入输出菜单 (输入‘END’返回上级)--------");
System.out.println("请输入进程信息：");
System.out.println("进程名(输入‘a’为自动生成) 进程的到达时间 进程的服务时间 ");
System.out.println("例：‘a 0 1’ ");
while(true){
try {
String name=cin.next();
if("END".equals(name.toUpperCase())){
break;
}
Process process=new Process();
if("a".equals(name)==false){
process.setProname(name);
}else {
process.SetAutoProname();
}
process.setStratTime(cin.nextInt());
process.setServiceTime(cin.nextInt());
list.add(process);
System.out.println(process.getProname()+"输入完成");
} catch (Exception e) {
System.out.println("输入失败，请重试(输入‘END’返回上级)");
}
}
return list;
}
private void printf(List<Process> list){
if(list==null){
System.out.println("请先输入。。。");
}else {
System.out.println("--------输出菜单--------");
System.out.println("请设置时间片（正整数）:");
int timeSlice=1;
try {
timeSlice=cin.nextInt();
} catch (Exception e) {
// TODO: handle exception
System.out.println("时间片设置失败。。。");
return;
}
while(true){
System.out.println("A:输出执行过程 A-n:执行n个时间单位的结果 B:计算周转时间 (输入‘END’返回上级)" );
String name=cin.next();
if("END".equals(name.toUpperCase())){
break;
}else if ("A".equals(name.toUpperCase())) {
System.out.println("时间\t 正在运行进程(开始时间，服务时间，优先级。运行时间，完成时间)\t\t 完成队列 \t\t 就绪队列 \t\t 未加入队列\t");
RunRR runRR=new RunRR(list);
runRR.setTimeSlice(timeSlice);
while(true){
runRR.run();
System.out.println(runRR.toString(ProcessStyle.OnlyProname));
if (runRR.isEnd()) {
break;
}
if(runRR.getTip()>0&&runRR.getTip()%100==0){
System.out.println("怀疑为无法完成调度，已停止，可以继续执行");
System.out.println("是否继续执行？（Y/N）");
if("N".equals(cin.next().toUpperCase())){
break;
}
}
}
}else if (name.length()>1&&"A-".equals(name.toUpperCase().subSequence(0, 2))) {
System.out.println("时间\t 正在运行进程(开始时间，服务时间，优先级。运行时间，完成时间)\t\t 完成队列 \t\t 就绪队列 \t\t 未加入队列\t");
try {
int i=Integer.parseInt(name.substring(2));
RunRR runRR=new RunRR(list);
runRR.setTimeSlice(timeSlice);
while(i-->=0){
runRR.run();
System.out.println(runRR.toString(ProcessStyle.OnlyProname));
if (runRR.isEnd()) {
break;
}
if(runRR.getTip()>0&&runRR.getTip()%100==0){
System.out.println("怀疑为无法完成调度，已停止，可以继续执行");
System.out.println("是否继续执行？（Y/N）");
if("N".equals(cin.next().toUpperCase())){
break;
}
}
}
} catch (Exception e) {
System.out.println("输入格式不对，请重新输入");
// TODO: handle exception
}
}else if ("B".equals(name.toUpperCase())) {
RunRR runRR=new RunRR(list);
runRR.setTimeSlice(timeSlice);
while(true){
runRR.run();
//System.out.println(runRR.toString(ProcessStyle.OnlyProname));
if (runRR.isEnd()) {
break;
}
if(runRR.getTip()>0&&runRR.getTip()%100==0){
System.out.println("怀疑为无法完成调度，已停止，可以继续执行");
System.out.println("是否继续执行？（Y/N）");
if("N".equals(cin.next().toUpperCase())){
break;
}
}
}
if(runRR.isEnd()==false){
System.out.println("未能完成调度，无法计算");
}else {
double sn=0;
List<Process> list2=runRR.getFinishList();
String [] s=new String [list2.size()];
for(int i=0;i<list2.size();i++){
int a=(list2.get(i).getFinishTime()-list2.get(i).getStratTime());
sn+=a;
s[i]=list2.get(i).toString(ProcessStyle.all)+" "+a ;
}
double averageA=sn/list2.size();
double tn=0;
for(int i=0;i<list2.size();i++){
double t=(list2.get(i).getFinishTime()-list2.get(i).getStratTime())/list2.get(i).getServiceTime();
tn+=t;
s[i]+=" "+t ;
}
System.out.println("进程(开始时间，服务时间，优先级。运行时间，完成时间) 周转时间 带权周转时间");
for(int i=0;i<s.length;i++){
System.out.println(s[i]);
}
System.out.println("平均周转时间："+sn/list2.size());
System.out.println("平均带权周转时间："+tn/list2.size());
}
}else {
System.out.println("菜单命令未识别，请重新输入");
}
System.out.println("输出完成。。。。");
}
}
}
public void main(String[] args) {
List<Process> list=null;
while(true){
System.out.println("--------菜单--------");
System.out.println("‘IN’:输入。 ‘RUN’:运行 QUIT:退出");
String menu=cin.next();
if("IN".equals(menu.toUpperCase())){
list=scanf();
}else if ("RUN".equals(menu.toUpperCase())) {
printf(list);
}else if("QUIT".equals(menu.toUpperCase())){
break;
}else {
System.out.println("菜单命令未识别，请重新输入");
System.out.println("--------菜单--------");
System.out.println("‘IN’:输入。 ‘RUN’:运行 QUIT:退出");
}
}
System.out.println("欢迎下次使用调度算法演示程序");
}
public Scanner getCin() {
return cin;
}
public void setCin(Scanner cin) {
this.cin = cin;
}
}
扫一扫
1704
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
