Java实现进程调度策略（时间片轮转、最高优先级）
2017-12-07 本文已影响184人
Pursuer96
234.jpg
本次试验是使用程序来模拟操作系统中进程调度的两种不同的调度策略，分别为时间片轮转、最高优先级。模拟的情况下，进程数为8，进程所需执行时间为随机产生的整数，单位为1s，默认进程同时到达。
代码下载地址
源码请点击：Github
Process.java
Process.java是测试类，用于生成进程列表和测试两种不同的调度策略。
package Process;
import java.util.ArrayList;
import java.util.List;
/**
* 用于生成随机的进程列表，并测试.
*/
public class Process {
public static List<double []> task_info=new ArrayList<>();//进程列表
public static int task_num=8;//进程数
public static void init_task()//初始化进程列表
{
for(int i=0;i<task_num;i++)
{
double[] t=new double[4];
t[0]=i;//进程号
t[1]=0;//到达时间
t[2]=0;//响应比
t[3]=(int)(Math.random()*100)%20+1;//需要运行时间
task_info.add(t);
}
}
public static void main(String arg[])
{
Process.init_task();//初始化进程列表
System.out.println("\n\n最高优先级算法开始运行:");
HPF.init_task(task_info,task_num);
HPF.HRRN();//最高优先级
System.out.println("\n\n时间片开始轮转：");
RR.init_task(task_info,task_num);
RR.CircleTime();//时间片轮转
}
}
RR.java
RR.java是模拟实现时间片轮转的调度策略。
package Process;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
/**
*
* 时间片轮转调度算法
*/
public class RR {
private static SimpleDateFormat tm= new SimpleDateFormat("HH:mm:ss");
private static int task_num=8;
private static int Circle_size=4;//定义时间片大小
public static ArrayBlockingQueue task_q=new ArrayBlockingQueue(task_num);//进程队列
private static List<double[]> execute_time=new ArrayList<>();//进程执行时间
public static void CircleTime()
{
try {
while (true) {
double[] t = new double[4];
t = (double[])task_q.take();
int current_task_time=(int)t[3];
int task_NO=(int)t[0];
System.out.print(tm.format(new Date())+"第" +task_NO+"号进程开始运行-- ");
if(current_task_time<=Circle_size)//如果能够在本时间片中运行完成
{
Thread.sleep((long) current_task_time*1000);//模拟运行所需时间
System.out.println(tm.format(new Date())+"该任务已经运行完成--本次用时"+current_task_time+"S");
double[] exe_t=new double[2];
exe_t[0]=task_NO;
exe_t[1]=System.currentTimeMillis()-t[1];//计算该进程所用的周转时间
execute_time.add(exe_t);//加入到周转时间队列
}
else {//如果不能再本次时间片中运行完
t[3]=t[3]-Circle_size;
task_q.put(t);
Thread.sleep(Circle_size*1000);
System.out.println(tm.format(new Date())+"本次时间片用完~~进程进入等待状态");
}
if(task_q.size()==0)//如果进程队列为空了，就退出循环
break;
}
}
catch (Exception e)
{
}
show_time();//显示每个进程的调度时间
}
public static void show_time()//显示每个进程的调度时间
{
double sum_time=0;
for(int i=0;i<execute_time.size();i++)
{
double[] t=execute_time.get(i);
System.out.println("task:"+t[0]+":周转时间="+(int)(t[1]/1000)+"S");
sum_time+=t[1];
}
System.out.println("使用时间片轮转的策略，平均周转时间为："+(int)(sum_time/execute_time.size()/1000)+"S");
}
static void init_task(List<double []> in,int tn)//初始化进程列表
{
task_num=tn;
for(int i=0;i<task_num;i++)
{
double [] t=in.get(i);
t[1] = System.currentTimeMillis();//获得进程到达时间
try {
task_q.put(t);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
HPF.java
HPF.java是模拟实现最高优先级算法的调度策略。
package Process;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class HPF {
private static SimpleDateFormat tm= new SimpleDateFormat("HH:mm:ss");
public static List<double []> task_info=new ArrayList<>();//进程信息列表
public static int task_num=8;//进程数
private static List<double[]> execute_time = new ArrayList<>();//进程周转时间列表
public static void HRRN(){
for(int i=0;i<task_num;i++)
{
get_ratio();//每次循环时计算一次响应比
double [] tem=get_a_task();//从进程列表中得到一个最高响应比的任务
System.out.print(tm.format(new Date())+"第"+(int)tem[0]+"号进程开始运行====");
try {
Thread.sleep((long) tem[3]*1000);//模拟进程执行所需要的时间
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(tm.format(new Date())+"进程结束运行=====用时为"+(int)tem[3]+"S");
double[] exe_t=new double[2];
exe_t[0]=tem[0];
exe_t[1]=System.currentTimeMillis() - tem[1];
execute_time.add(exe_t);
}
show_time();//显示每个进程的周转时间
}
public static void show_time()//显示每个进程的周转时间
{
double sum_time=0;
for(int i=0;i<execute_time.size();i++)
{
double[] t=execute_time.get(i);
System.out.println("task:"+t[0]+":周转时间="+(int)(t[1]/1000)+"S");
sum_time+=t[1];
}
System.out.println("使用最高响应比的策略，平均周转时间为："+(int)(sum_time/execute_time.size()/1000)+"S");
}
public static double[] get_a_task()//根据响应比，返回一个最高相应比进程
{
double[]rt=new double[4];
double max_ratio=0;
int NO=-1;
for(int i=0;i<task_info.size();i++)
{
if(task_info.get(i)[2]>max_ratio)
{
rt=task_info.get(i);
max_ratio=task_info.get(i)[2];
NO=i;
}
}
task_info.remove(NO);//如果一个进程被选中，则在进程列表中删除掉
return rt;
}
public static void init_task(List<double[]> in,int tn)//初始化进程列表
{
task_num=tn;
for(int i=0;i<in.size();i++)
{
double[] t=in.get(i);
t[1]=System.currentTimeMillis();//获得进程到达时间
task_info.add(t);
}
}
public static void get_ratio()//计算每一个进程当前的响应比
{
for(int i=0;i<task_info.size();i++)
{
double[] t=task_info.get(i);
task_info.remove(i);
double ratio=(System.currentTimeMillis()-t[1])/t[3]+1;//计算响应比
t[2]=ratio;
task_info.add(t);
}
}
public static void main(String arg[])//用于本类测试
{
Process.init_task();
init_task(Process.task_info,Process.task_num);
HRRN();
}
}
#个人主页：www.iooy.com
