package com.mini.process;
import java.util.*;
import java.io.*;
//进程类，可以产生进程对象
class Process{
private String name;
private int state; //0 表示就绪 1等待
private int sort; //优先级，sort越大优先级越高,随机产生（1-5）
private int time; //执行时间
private Random rd=new Random(); //用于产生随机数
Process (String in_name){
name=in_name;
time=rd.nextInt(20)+1; //随机产生0到19的整数
sort=rd.nextInt(5)+1;
}
int Begin_state(){
state=rd.nextInt(2); //返回随机产生的0或1，用于判断处于就绪还是等待队列
return state;
}
String getName(){
return name;
}
int getTime(){
return time;
}
void setTime(int inputtime){
time=inputtime;
}
int getSort(){
return sort;
}
void print(){
System.out.println("进程名 "+name+" "+"执行所需时间"+time+"ms"+"\t\t"+"进程状态: "+state+" "+"优先数 "+sort);
}
}
//主类
public class ProcessCall{
//主函数，调用各种不同算法函数
public static void main(String []args)throws IOException{
LinkedList<Process> ready=new LinkedList<Process>(); //就绪队列链表头
LinkedList<Process> wait =new LinkedList<Process>(); //等待队列链表头
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
boolean in=true;
String s=new String();
String []name={"a","b","c","d","e","f","g","h","i","j"}; //进程名
while(in){
for(int i=0;i<10;i++){
Process process=new Process(name[i]); //产生一个进程
if (process.Begin_state()==0){
ready.addLast(process);
}
else{
wait.addLast(process);
}
}
System.out.println("\n选择调度算法"+"\n\n"+"1-先进先出调度算法 2-基于优先数的调度算法 3-最短执行时间调度算法 其他数字键键-退出");
try{
s=br.readLine(); //接受Ascii码，1的Ascii码为49；
}catch(IOException e){};
switch(Integer.parseInt(s)){
case 1: call_FCFS(ready,wait);in=true;break; //调用先进先出算法
case 2: call_PrevSort(ready,wait);in=true;break; //调用基于优先数的调度算法
case 3: call_LessTime(ready,wait);in=true;break; //调用最短执行时间调度算法
default: in=false;System.out.println("退出系统！");
}
}
}
//输出链表内容
static void outPrint(LinkedList<Process> list){
Process temp;
if(list.size()>0){
for(int i=0;i<list.size();i++){
temp=list.get(i);
System.out.print("第"+(i+1)+"个进程："+"\t");
temp.print();
}
}
else
System.out.println("空队列");
}
//输出所有进程信息
static void process_Print(LinkedList<Process> ready,LinkedList<Process> wait){
System.out.println("\n就绪队列:");
outPrint(ready);
System.out.println("等待队列:");
outPrint(wait);
}
//先进先出调度算法函数
static void call_FCFS(LinkedList<Process> ready,LinkedList<Process> wait){
int time=0; //处理机分配的时间片
Random rd=new Random();
//执行进程
while(ready.size()>0 || wait.size()>0){
process_Print(ready,wait); //输出所有进程信息
time=rd.nextInt(15)+5; //随机产生时间片长度
System.out.println("\n时间片长度： "+time);
if(ready.size()>0){
if(ready.get(0).getTime() > time){ //进程执行所需时间大于处理机分配的时间片，执行完时间片长度后
ready.get(0).setTime(ready.get(0).getTime()-time); //该进程随机进入等待或就绪对列，否则该进程执行完毕删除
if(rd.nextInt(2)==0){ //该进程
ready.add(ready.get(0));
System.out.print("进程："+ready.get(0).getName()+" 时间片不够进入就绪对列队尾。 ");
}
else{
wait.add(ready.get(0));
System.out.print("进程："+ready.get(0).getName()+" 时间片不够进入等待对列队尾。 ");
}
}
else
System.out.print("进程："+ready.get(0).getName()+" 执行完毕！ ");
ready.remove(0);
}
//在进程执行过程中，产生随机数0或1，该随机数为1时，将等待队列中的第一个PCB加入就绪队列的对尾
if(wait.size()>0){
waittoready(ready,wait);
}
}
System.out.println("\n\n所有进程执行完毕!");
}
//基于优先数的调度算法函数
static void call_PrevSort(LinkedList<Process> ready,LinkedList<Process> wait){
int time=0; //处理机分配的时间片
Random rd=new Random();
Process pro_hightsort;
while(ready.size()>0 || wait.size()>0){
process_Print(ready,wait); //输出所有进程信息
time=rd.nextInt(15)+5; //随机产生时间片长度
System.out.println("\n时间片长度： "+time);
if(ready.size()>0){
pro_hightsort=search_HightSort(ready); //寻找一个优先数最高的进程
System.out.print("进程"+pro_hightsort.getName()+"优先数最高。 ");
if(pro_hightsort.getTime() > time){ //进程执行所需时间大于处理机分配的时间片，执行完时间片长度后
pro_hightsort.setTime(pro_hightsort.getTime()-time); //该进程随机进入等待或就绪对列，
if(rd.nextInt(2)==0){ //否则该进程执行完毕删除该进程
ready.add(pro_hightsort);
System.out.print("进程："+pro_hightsort.getName()+" 时间片不够进入就绪对列队尾。 ");
}
else{
wait.add(pro_hightsort);
System.out.print("进程："+pro_hightsort.getName()+" 时间片不够进入等待对列队尾。 ");
}
}
else
System.out.print("进程："+pro_hightsort.getName()+" 执行完毕！ ");
ready.remove(ready.indexOf(pro_hightsort));
}
//在进程执行过程中，产生随机数0或1，该随机数为1时，将等待队列中的第一个PCB加入就绪队列的对尾
if(wait.size()>0){
waittoready(ready,wait);
}
}
System.out.println("\n\n所有进程执行完毕!");
}
//最短执行时间调度算法函数
static void call_LessTime(LinkedList<Process> ready,LinkedList<Process> wait){
int time=0; //处理机分配的时间片
Random rd=new Random();
Process pro_lesstime;
while(ready.size()>0 || wait.size()>0){
process_Print(ready,wait); //输出所有进程信息
time=rd.nextInt(15)+5; //随机产生时间片长度
System.out.println("\n时间片长度： "+time);
if(ready.size()>0){
pro_lesstime=search_LessTime(ready);
System.out.print("进程"+pro_lesstime.getName()+"执行时间最短。 ");
if(pro_lesstime.getTime() > time){ //进程执行所需时间大于处理机分配的时间片，执行完时间片长度后
pro_lesstime.setTime(pro_lesstime.getTime()-time); //该进程随机进入等待或就绪对列，
if(rd.nextInt(2)==0){ //否则该进程执行完毕删除该进程
ready.add(pro_lesstime);
System.out.print("进程："+pro_lesstime.getName()+" 时间片不够进入就绪对列队尾。 ");
}
else{
wait.add(pro_lesstime);
System.out.print("进程："+pro_lesstime.getName()+" 时间片不够进入等待对列队尾。 ");
}
}
else
System.out.print("进程："+pro_lesstime.getName()+" 执行完毕！ ");
ready.remove(ready.indexOf(pro_lesstime));
}
//在进程执行过程中，产生随机数0或1，该随机数为1时，将等待队列中的第一个PCB加入就绪队列的对尾
if(wait.size()>0){
waittoready(ready,wait);
}
}
System.out.println("\n\n所有进程执行完毕!");
}
//在进程执行过程中，产生随机数0或1，该随机数为1时，将等待队列中的第一个PCB加入就绪队列的对尾；
static void waittoready(LinkedList<Process> ready,LinkedList<Process> wait){
Random rd=new Random();
if(rd.nextInt(2)==1){
ready.add(wait.get(0));
System.out.println("等待队列第一个进程: "+wait.get(0).getName()+" 进入就绪对列队尾!");
}
else{
wait.add(wait.get(0));
System.out.println("等待队列第一个进程: "+wait.get(0).getName()+" 进入等待对列队尾!");
}
wait.remove(0);
}
//寻找一个所需时间最少的进程
static Process search_LessTime(LinkedList<Process> ready){
Process lesstime=ready.get(0);
for(int i=1;i<ready.size();i++){
if(lesstime.getTime()>ready.get(i).getTime())
lesstime=ready.get(i);
}
return lesstime;
}
//寻找一个优先数最高的进程
static Process search_HightSort(LinkedList<Process> ready){
Process hightsort=ready.get(0);
for(int i=1;i<ready.size();i++){
if(hightsort.getSort()<ready.get(i).getSort())
hightsort=ready.get(i);
}
return hightsort;
}
}
最近下载
最近浏览