《操作系统》 ——进程管理和调度算法实现

最新推荐文章于 2023-12-30 16:50:57 发布

TaoTie830

最新推荐文章于 2023-12-30 16:50:57 发布

阅读量2.1k

点赞数 2

分类专栏：《操作系统原理》实验报告

本文链接：https://blog.csdn.net/yubo_830/article/details/103340182

版权

《操作系统原理》实验报告专栏收录该内容

4 篇文章 5 订阅

订阅专栏

《操作系统》课程实验（二）

——进程管理和调度算法实现

实验目的

进程调度是处理机管理的核心内容。本设计要求用高级语言编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先权调度算法和时间片轮转调度算法的具体实施办法。

实验内容

设计进程控制块PCB表结构，分别适用于优先权调度算法和时间片轮转调度算法。
PCB结构包括以下信息：进程名、进程优先数（或轮转时间片），进程所占用的CPU时间，进程的状态，当前队列指针等。根据调度算法的不同，PCB结构的内容可以作适当的增删。
建立进程就绪队列。对两种不同算法编制入链子程序。
编制两种进程调度算法：a）优先数调度；b）时间片轮转调度。允许用户在程序运行时选择使用某一种调度算法。

编程工具

编程语言：Java

开发工具：IntelliJ IDEA

实验内容

实验要求

选用优先数算法和简单时间片轮转法对五个进程进行调度，每个进程可有三种状态：运行状态（RUN）、就绪状态（READY）和完成状态。并假定初始状态为就绪状态。

设计进程控制块PCB结构如下：

NAME //进程标识符；

PRIO/ROUND // PRIO表示进程优先数，ROUND表示进程轮转时间片大小；

CPUTIME //进程占用CPU时间；

COUNT //计数器；

NEEDTIME /进程到完成还要的CPU时间；

STATE //进程的状态；

NEXT //链指针

进程控制块链结构如图所示。

其中：

RUN——当前运行进程指针；

READY——就绪队列头指针；

TAIL——就绪队列尾指针；

FINISH——完成队列头指针。

为了便于处理，程序中进程的运行时间以时间片为单位计算。各进程的优先数或轮转时间片数以及进程需运行的时间片数的初值均由用户给定。

程序说明：

a）在优先数算法中，进程每执行一次，优先数减3，CPU时间片数加1，进程还需要的时间片数减1。在轮转法中，采用固定时间片，时间片数为2，进程每执行一次，CPU时间片数加2，进程还需要的时间片数减2，并排到就绪队列的尾上。

b）程序结构说明如下：

整个程序由CREATE，FIRSTIN，INSERT1，INSERT2，PRINT，PRISCH和ROUNDSCH过程组成。其中：

CREATE的功能是创建新的进程，即创立进程的PCB，并将此PCB链入到就绪队列中去。

FIRSTIN的功能是将就绪队列中的第一个进程投入运行。

INSERT1的功能是把还未完成且优先数小于别的进程PCB按进程优先数的顺序插入到就绪队列中。

INSERT2是轮转法使用的过程，将执行了一个单位时间片数（为2）且还未完成的进程的PCB插入到就绪队列的队尾。

PRINT打印每执行一次后的所有进程的状态，这里，就绪（等待）用“W”代表。

PRISCH按优先数算法调度进程。

ROUNDSCH按时间片轮转法调度进程。

c）主程序中定义了PCB的结构和其它变量NUMBER——进程数，ALGO为10个字符长的字符串，存放要求输入的算法的名，输入“PRIORITY”表示调用优先数算法，输入“ROUNDROBIN”表示调用循环轮转法，要求用户在程序运行时输入其中的一个。

实验代码

类名：High //最高优先级调度算法

public class High {
    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]*100);//模拟进程执行所需要的时间
            } 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]/100)+"S");
            sum_time+=t[1];
        }
        System.out.println("使用最高响应比的策略，平均周转时间为："+(int)(sum_time/execute_time.size()/100)+"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();
    }
}

类名：Time //轮转时间片调度算法

public class Time {
    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*100);//模拟运行所需时间
                    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*100);
                    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]/100)+"S");
            sum_time+=t[1];
        }
        System.out.println("使用时间片轮转的策略，平均周转时间为："+(int)(sum_time/execute_time.size()/100)+"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();
            }
        }
    }
}

类名：Process //测试类

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最高优先级算法开始运行:");
        High.init_task(task_info,task_num);
        High.HRRN();//最高优先级

        System.out.println("\n\n时间片开始轮转：");
        Time.init_task(task_info,task_num);
        Time.CircleTime();//时间片轮转
    }
}

实验截图

TaoTie830

关注

2
点赞
踩
28

收藏

觉得还不错? 一键收藏
0
评论
《操作系统》 ——进程管理和调度算法实现

《操作系统》课程实验（二）——进程管理和调度算法实现实验目的进程调度是处理机管理的核心内容。本设计要求用高级语言编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先权调度算法和时间片轮转调度算法的具体实施办法。实验内容设计进程控制块PCB表结构，分别适用于优先权调度算法和时间片轮转调度算法。 PCB结构包括以下信息：进程名、...
复制链接

扫一扫

专栏目录