Process Scheduling Simulation Algorithm
in Operating System 访问: 19,863 次 with 2 comments

Process Scheduling Simulation Algorithm

in Operating System with 2 comments

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();
    }

}
Comments are closed.
  1. Kudos! I like this.

  2. AlinaSpoomihoowl

    Excellent!
    Respect the author!
    And I read the actual news here ...News Technology