精华内容
下载资源
问答
  • 时间片轮转调度
    千次阅读
    2021-12-04 20:04:29

    本程序用时间片轮转调度算法对五个进程进行调度,假设每个进程初始状态为就绪状态。
    程序中的某进程运行时间以时间片单位为2进行计算。

    package bean;
    
    public interface process_scheduling_algorithm {
        public void round_cal();
        public pcb get_process_round();
        public int process_finish();
        public void display_round();
        public void set_state();
        public void cpu_round(pcb q);// 采用时间片轮转调度算法执行某一进程
        public pcb get_next(pcb k, pcb head);
    }
    
    package bean;
    
    public class pcb implements Cloneable{
        private String name;//进程名
        private int cputime;//CPU 运行时间
        private int needtime;//运行所需的时间
        private int count;//执行次数
        private int round;//时间片轮转轮次
        private state process;//进程状态
        private pcb next;
    
        public Object clone() {
            pcb person = null;
            try {
                person = (pcb)super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return person;
        }
    
        public void setName(String name) {
            this.name = name;
        }
        public String getName(){
            return name;
        }
    
        public void setCputime(int cputime) {
            this.cputime = cputime;
        }
        public int getCputime(){
            return cputime;
        }
    
        public void setCount(int count) {
            this.count = count;
        }
        public int getCount(){
            return count;
        }
    
        public void setNeedtime(int needtime){
            this.needtime = needtime;
        }
        public int getNeedtime(){
            return needtime;
        }
    
        public void setRound(int round) {
            this.round = round;
        }
        public int getRound(){
            return round;
        }
    
        public void setProcess(state process) {
            this.process = process;
        }
        public state getProcess(){
            return process;
        }
    
        public void setNext(pcb p){
            if(p!=null)next = (pcb) p.clone();
            else next = null;
        }
        public pcb getNext(){
            return next;
        }
    }
    
    enum state{
        ready,
        execute,
        block,
        finish
    };// 定义进程状态
    
    
    package bean;
    
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Scanner;
    
    public class round_robin implements process_scheduling_algorithm,Cloneable{
        public static final int P_NUM = 5;
        public static final int P_TIME = 50;
        public static List list = new LinkedList<pcb>();
        //public int position = 1;
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    
        @Override
        public void round_cal() {
            pcb p,r;
            p = get_process_round();
            //System.out.println(p.getName()+"--------");
            //display_round(p);
            int cpu = 0;
            r = (pcb)p.clone();//r = p;
            while (process_finish() == 0){
                cpu += 2;
                cpu_round(r);
                r = (pcb) get_next(r,p).clone();//r = get_next(r,p);
                // System.out.println(r.getName() + "------");
                System.out.println("cpu  " + cpu);
                display_round();
                set_state();
            }
        }
    
        @Override
        public pcb get_process_round() {
            pcb q = new pcb();
            pcb t = new pcb();
            pcb p = new pcb();
            int i = 0;
            System.out.println("input name and time");
            while(i < P_NUM){
                q.setName(cin.next());
                q.setNeedtime(cin.nextInt());
                q.setCputime(0);
                q.setRound(0);
                q.setCount(0);
                q.setProcess(state.ready);
                q.setNext(null);
                if(i == 0){
                    // p = q;
                    p = (pcb) q.clone();
                    //System.out.println(p.needtime + "---------");
                    //t = q;
                    t = (pcb) q.clone();
                    list.add(t);
                } else {
                    //t.next = q; //创建就绪进程队列
                    t.setNext(q);
                    //t = q;
                    t = (pcb) q.clone();
                    list.add(t);
                }
                i++;
            }
    //        for(int x=0;x<list.size();x++) {
    //        	pcb temp = (pcb) list.get(x);
    //        	System.out.println(temp.getName());
    //        }
            //System.out.println(p.getName() + "------");
            return p;
        } //输入模拟测试的进程名和执行所需时间
    
        @Override
        public int process_finish() {
            //System.out.println(q.needtime + "------------");
            int bl = 1,i = 0;
            while(bl!=0 && i < list.size()){
                pcb q = (pcb) list.get(i);
                if(bl != 0 && q.getNeedtime() == 0)bl = 1;
                else bl = 0;
                i++;
                //q = q.next;
                // q = q.getNext();
                // System.out.println(q.getName());
            }
            return bl;
        }
    
        @Override
        public void display_round() {
            System.out.println("NAME         CPUTIME         NEEDTIME         COUNT         ROUND         STATE");
            for(int i=0;i<list.size();i++){
                pcb p = (pcb) list.get(i);
                System.out.print(p.getName() + "             ");
                System.out.print(p.getCputime() + "               ");
                System.out.print(p.getNeedtime() + "               ");
                System.out.print(p.getCount() + "              ");
                System.out.print(p.getRound() + "           ");
                switch (p.getProcess()){
                    case ready:
                        System.out.println("ready");
                        break;
                    case execute:
                        System.out.println("execute");
                        break;
                    case finish:
                        System.out.println("finish");
                        break;
                }
                //p = p.getNext();
            }
        }
    
        @Override
        public void set_state() {
            for(int i=0;i<list.size();i++){
                pcb p = (pcb) list.get(i);
                if(p.getNeedtime() == 0) p.setProcess(state.finish);
                if(p.getProcess() == state.execute) p.setProcess(state.ready);
                //p = p.getNext();
            }
        }
    
        @Override
        public void cpu_round(pcb q) {
            q.setCputime(q.getCputime() + 2);//q.cputime += 2;
            q.setNeedtime(q.getNeedtime() - 2);//q.needtime -= 2;
            if (q.getNeedtime() < 0) q.setNeedtime(0);
            q.setCount(q.getCount() + 1);//q.count++;
            q.setRound(q.getRound() + 1);//q.round++;
            q.setProcess(state.execute);//q.process = state.execute;
            for(int i=0;i<list.size();i++) {
                pcb temp = (pcb) list.get(i);
                if(q.getName() == temp.getName()) {
                    list.remove(i);
                    list.add(i, q);
                }
            }
        }//采用时间片轮转调度算法执行某一进程
    
        @Override
        public pcb get_next(pcb k, pcb head) {
            //System.out.println(k.getName() + " " + head.getName() + "------");
            pcb t;
            t = (pcb) k.clone();//t = k;
            int opsition = 0;
            for(int i=0;i<list.size();i++) {//从列表中查找k的位置
                pcb temp = (pcb) list.get(i);
                if(t.getName() == temp.getName()) {
                    opsition = i;
                    break;
                }
            }
            do {
                //t = t.getNext();//t = t.next;
                if(opsition+1 < list.size()) {
                    t = (pcb) list.get(++opsition);
                    //System.out.println(t.getName() +"-----------");
                    //break;
                }
                else{
                    opsition++;
                    break;
                }
            }while(t != null && t.getProcess()== state.finish && opsition < list.size());
            if(opsition == list.size()) {
                t = (pcb) head.clone();//t = head;
                //System.out.println(t.getName() + " -------------");
                //while (t.getNext() != k && t.getProcess() == state.finish) t = t.getNext();
                for(int i = 0; i < list.size(); i++){
                    pcb temp = (pcb) list.get(i);
                    if(temp.getName() == t.getName()){
                        opsition = i;
                        break;
                    }
                }
                do {
                    if(opsition+1 < list.size()) t = (pcb) list.get(++opsition);
                    //opsition++;
                }while(t != null && t.getNext() != k && t.getProcess() == state.finish && opsition < list.size());
            }
            return t;
        }
    
        public static void main(String[] args) {
            round_robin test = new round_robin();
            test.round_cal();
        }
        public Scanner cin = new Scanner(System.in);
    }
    /*测试样例一
    a1 2
    a2 3
    a3 4
    a4 5
    a5 6
    测试样例二
    a1 2
    a2 3
    a3 4
    a4 2
    a5 4
     */
    
    
    更多相关内容
  • 操作系统课程时间片轮转调度模拟程序,程序相对简单,通过这个模拟程序能够帮助学习者会更好的学习os,供有需要的人学习使用。
  • 时间片轮转调度算法

    2013-02-06 03:40:39
    时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法。每个进程被分配一个时间段,称作它的时间片,即该进程允许运行的时间。如果在时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程。如果进程...
  • 在Windows等操作系统下,使用的VC、VB、java或C等编程语言,利用相应的WIN32 API函数,编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法
  • 第11讲 UCOSIII时间片轮转调度ppt,ALIENTEK UCOS学习视频(课件)
  • 内容:南邮实验周,时间片轮转调度算法模拟实验完整代码 时间:2018/5/31 说明:该代码实现功能的完整描述见我空间的“南邮实验周_时间片轮转调度算法模拟_报告”
  • 一、实验目的 在采用多道程序设计的系统中,同时处于就绪态的进程往往有多个,当就绪态的进程数大于...本次设计模拟在单处理器情况下采用基于优先数的时间片轮转调度算法进行处理器调度,加深了解处理器调度工作过程。
  • core.zip,os_dbg_r.c,os_task.c,os_cfg_r.h,os_tmr.c,ucos_ii.h,os_mbox.c,UC/OS-Ⅱ内核扩充时间片轮转调度算法的设计.pdf,基于时间片轮转的ucos,OS_MBOX.C,uCOS_II.H,OS_TIME.C,TEST.C,OS_CPU_C.C,OS_MUTEX.C,OS_...
  • 按照各进程到达就绪队列的顺序,轮流让各个进程执行一个时间片,若进程未在一个时间片内执行完,则会剥夺处理机,将进程重新放到就绪队列队尾重新排队。用于进程调度抢占式算法不会优点:公平,响应快,适用于分时...

    一、时间片轮转调度算法

    1、算法思想

    公平地、轮流地为各个进程服务,让每个进程在一定时间间隔内都可以得到响应。

    2、算法规则

    按照各进程到达就绪队列的顺序,轮流让各个进程执行一个时间片,若进程未在一个时间片内执行完,则会剥夺处理机,将进程重新放到就绪队列队尾重新排队。

    3、用于作业/进程调度

    用于进程调度

    4、是否可抢占

    抢占式算法

    5、是否会导致饥饿

    不会

    6、优缺点

    优点:公平,响应快,适用于分时操作系统。

    缺点:由于高频率的进程切换,因此有一定的开销,不区分任务的紧急程度。

    7、例题

    例:各进程到达就绪队列的时间、需要运行时间如下表,使用时间片轮转调度算法,分析时间片大小是2时的进程运行情况。

    进程到达时间运行时间
    P105
    P224
    P341
    P456

    答:

     

    0时刻(P1运行):只有P1到达就绪对列,让P1运行一个时间片2.。

    2时刻(P2运行):P2到达就绪对列,P1被剥夺CPU,放到队尾,P2运行。

    4时刻(P1运行):P3到达,先插到就绪队列队尾,紧接着,P2也插到队尾。

    5时刻(P1运行):P4到达,插到就绪队尾。

    6时刻(P3运行):P1时间片用完,重新回到就绪队尾。

    7时刻(P2运行):P3主动放弃CPU。

    9时刻(P4运行):P2时间片用完,并刚好运行完。

    11时刻(P1运行):P4时间片用完,回到就绪队尾。

    12时刻(P4运行):P1运行完,主动放弃CPU,就绪队列只剩P4。

    二、优先级调度算法

    1、算法思想

    根据任务的紧急程度来决定处理顺序。

    2、算法规则

    每个 作业/进程 有各自的优先级,调度时选择优先级最高的 作业/进程。

    3、用于作业/进程调度

    可用于作业调度,也可用于进程调度,还可以用于I/O调度。

    4、是否可抢占

    抢占式、非抢占式都有。

    5、是否会导致饥饿

    6、优缺点

    优点:用优先级区分紧急程度、重要程度,适用于实时操作系统,可灵活调整对各作业/进程的偏好程度。

    缺点:若源源不断的高优先级到来,会导致饥饿。

    7、例题

    例:各进程到达就绪队列的时间、需要运行时间、进程优先级如下表。使用非抢占式的优先级调度算法,分析进程运行情况。

    进程到达时间运行时间优先级
    P1071
    P2242
    P3413
    P4542

    非抢占式

    答:

     

    0时刻(P1运行):只有P1到达。

    7时刻(P3运行):P1运行完主动放弃处理机,其余进程都已到达,P3优先级最高。

    8时刻(P2运行):P3完成,P2、P4优先级相同,由于P2先到达,P2优先。

    12时刻(P4):P2完成,只剩P4。

    16时刻:所有进程结束。

    抢占式

    答:

     

    0时刻(P1运行):P1到达。

    2时刻(P2运行):P2到达,优先级更高。

    4时刻(P3运行):P3到达,优先级更高。

    5时刻(P2运行):P3完成,主动释放,P4到达,由于P2更先进入就绪队列,P2上。

    7时刻(P4运行):只剩P1、P4,P4优先级高。

    11时刻(P1运行):P4完成,P1上。

    注意:优先级未必只有一个,可以按照不同优先级来组织队列,高优先级在队头。

    如何合理设置各进程优先级:

    系统进程优先级高于用户进程

    前台进程优先级高于后台进程

    操作系统更偏好I/O型进程

    三、多级反馈队列调度算法

    1、算法思想

    对其他调度算法的折中权衡。

    2、算法规则

    ①设置多级就绪队列,各级队列优先级从高到低时间片从小到大。

    ②新进程到达时先进入第1级队列,按FCFS原则排队等待被分配时间片,若用完时间片进程未结束,则进程进入下一级队列队尾。如果此时已经是在最下级队列,则重新放回该队列队尾。

    ③只有第K级队列为空时,才会为k+1级队头的进程分配时间片。

    3、用于作业/进程调度

    进程调度

    4、是否可抢占

    抢占式

    5、是否会导致饥饿

    6、优缺点

    对各进程公平,每个新到达的进程都可以很快得到响应,短进程只需较少的时间就可完成,不必实现估计进程的运行时间,可灵活调整对各进程的偏好程度。

    7、例题

    例:各进程到达就绪队列的时间、需要的运行时间如下表,使用多级反馈队列调度算法,分析各进程运行的过程。

    进程到达时间运行时间
    P108
    P214
    P351

    答:

    P1先到达,到第1级队列,使用1个时间片,然后进入下一个队列队尾。

    P2到达,先到第1级队列,使用1个时间片,进入到下一队列队尾。

    P1,在第2级队列,使用2个时间片,然后进入下一个队列队尾。

    P2,在第2级队列,使用1个时间片后,P3到达第1级队列,P2被抢占,P2重新回到第2级队列队尾。

    P3,在第1级队列,使用1个时间片,结束。

    P2,在第2级队列,使用1个时间片,结束。

    P1,在第3级队列,使用4个时间片,然后重新回到第3级队列队尾,重新调度。

    上面三种调度算法适用于交互式系统。

    展开全文
  • 时间片轮转调度算法详解

    千次阅读 2022-05-19 12:21:36
    在分时系统中都采用时间片轮转算法进行进程调度。时间片是指一个较小的时间间隔,通常为10-100毫秒。在简单的轮转算法中,系统将所有的就绪进程按先来先服务(即FIFO)规则排成一个队列,将CPU分配给队首进程,且...

    轮转调度算法Round-Robin(RR) 
    在分时系统中都采用时间片轮转算法进行进程调度。时间片是指一个较小的时间间隔,通常为10-100毫秒。在简单的轮转算法中,系统将所有的就绪进程按先来先服务(即FIFO)规则排成一个队列,将CPU分配给队首进程,且规定每个进程最多允许运行一个时间片;若时间片使用完进程还没有结束,则被加入就绪FIFO队列队尾,并把CPU交给下一个进程。时间片轮转算法只用于进程调度,它属于抢占调度方式。

    优点 :CPU分配相对公平;平均响应时间较短 
    缺点:不利于紧急作业,而且当进程的运行时间都相近时,平均的等待时间比较长,甚至不如先来先服务算法。

    下面根据一个典型例题来展示,时间片轮转算法的调度过程。

    例:考虑5个进程P1、P2、P3、P4、P5,如下表,试计算在采用下述时间片轮转调度算法时各个进程周转时间和带权周转时间。假设忽略进程的调度时间。

     

    时间片轮转算法调度过程
    时间/ms就绪队列描述(执行顺序)
    0P1调度P1进程
    1P1调度P1进程
    2P2,P12ms时P2进程到达;P1进程调度完,插入队列末尾;调度P2进程
    3P1,P2P2进程调度完,插入队列末尾;调度P1进程
    4P2,P34ms时P3进程到达;P1进程运行完成;调度P2进程
    5P3,P2P2进程调度完,插入队列末尾;调度P3进程
    6P2,P4,P36ms时P4进程到达;P3进程调度完,插入队列末尾;调度P2进程
    7P4,P3,P2P2进程调度完,插入队列末尾;调度P4进程
    8P3,P2,P5,P48ms时P5进程到达,插入队列末尾;P4进程调度完,插入队列末尾;调度P3进程
    9P2,P5,P4,P3P3进程调度完,插入队列末尾;调度P2进程
    10P5,P4,P3,P2P2进程调度完,插入队列末尾;调度P5进程
    11P4,P3,P2,P5P5进程调度完,插入队列末尾;调度P4进程
    12P3,P2,P5,P4P4进程调度完,插入队列末尾;调度P3进程
    13P2,P5,P4,P3P4进程调度完,插入队列末尾;调度P2进程
    14P5,P4,P3,P2P2进程调度完,插入队列末尾;调度P5进程
    15P4,P3,P2P5进程运行结束;调度P4进程
    16P3,P2,P4P2进程调度完,插入队列末尾;调度P3进程
    17P2,P4P3进程运行结束;调度P2进程
    18P4P2进程运行结束;调度P4进程

    19

    P4调度P4进程
    20P4进程运行结束

    展开全文
  • 1、设计一个程序实现基于优先数的时间片轮转调度算法调度处理器。 2、假定系统有5个进程,每个进程用一个进程控制块PCB开代表,进程控制块的结构 /*例如一组进程如下表: 进程名 A B C D E F G H J K L M 到达时间 ...
  • 分时系统模拟(Java实现)一、实验名称二、实验目的三、实验...加深对多道系统中进程管理的理解,了解进程的各种状态及其转换过程,分时系统中时间片的设置及进程在时间片开始和结束时的调度过程。 三、实验内容和要求

    一、实验名称

    实验(一)多道程序、进程、分时系统模拟

    二、实验目的

    加深对多道系统中进程管理的理解,了解进程的各种状态及其转换过程,分时系统中时间片的设置及进程在时间片开始和结束时的调度过程。

    三、实验内容和要求

    (1)利用程序设计语言模拟分时系统中多个进程按时间片轮转调度算法进行进程调度的过程;
    (2)假设有五个进程A,B,C,D,E,它们的到达时间及要求服务的时间分别为:
    进程名 A B C D E
    到达时间 0 1 2 3 4
    服务时间 4 3 4 2 4
    时间片大小为1,利用程序模拟A,B,C,D,E五个进程按时间片轮转的调度及执行过程并计算周转时间及带权周转时间。
    (3)时间片大小为2,利用程序模拟A,B,C,D,E五个进程按时间片轮转的调度及执行过程并计算周转时间及带权周转时间。
    (4)时间片大小为4,利用程序模拟A,B,C,D,E五个进程按时间片轮转的调度及执行过程并计算周转时间及带权周转时间。

    四、实验设计

    package com.symc.dsaa.os.test1;
    import java.util.ArrayDeque;
    import java.util.ArrayList;
    import java.util.Scanner;
    
    /**
     * 分析:
     * 第一,对于进程,每个进程有名称、到达时间、服务时间等属性,我们将它封装成对象Process,
     * 并且添加好getter、setter方法和构造器。
     * 第二,对于模拟这个进程的顺序,我们需要创建多个进程去测试,在执行的过程中,是轮流执行的,
     * 每次只能执行一个进程,剩下的进程等待,需要一个数据结构去存放等待执行的进程,也即就绪队列,
     * 我这里推荐使用队列(queue)
     * 第三,队列的使用。队列是一个具有 先进先出 特性的线性结构,而我们用的就是它只能从队首出,从队尾进
     * 的特点,放入队列的进程,使它做到经过时间片的处理,假设我这里的时间片是1秒,那处理后此进程的
     * 服务时间就减去1秒,这里判断是否执行完,如果减完后小于或等于0,说明它执行完了,如果还大于0,
     * 说明没执行完,这时就将它放到队尾,继续操作下一个进程。
     * 第四,我们的实验中需要完成这四道题,它所对应的时间片不同,所以我们的程序应该灵活,能够同时实现
     * 各种需求。
     */
    public class TimeAround {
    
        /**
         * 变量介绍:
         * ArrayList<Process> list:定义一个用于存放创建的进程的集合
         * <p>
         * int CPURun:用于记录CPU的执行时间,比如说,我们明确题目中5个进程,单线程运行的话,
         * 一定是它们的服务时间的总和,也就是说,该程序运行时间为4+3+4+2+4=17
         * <p>
         * int num:我们可以自定义任务(进程)的数量
         * <p>
         * int[] serveTimes:用于存放进程的时间运行时间,也就是刚开始的服务时间,用于计算带权周转时间
         *
         * int timeSlice;定义时间片的大小
         * <p>
         * int finishedTime:进程的运行结束的时间,用于计算周转时间
         * <p>
         * double floatWi:带权周转时间,这里用double类型
         * <p>
         * ArrayDeque<Process> deque:定义队列,这是本次实验的核心的数据结构,在代码中有详细注释
         *
         * @param args
         */
        public static void main(String[] args) {
    
            ArrayList<Process> list = new ArrayList<>();
            int CPURun = 0;//int CPURun:用于记录CPU的执行时间
            int finishedTime = 0;
            //int finishedTime:进程的运行结束的时间,用于计算周转时间
    
            System.out.println("请输入进程数:");
            int num = new Scanner(System.in).nextInt();
            int[] serveTimes = new int[num];
            //int[] serveTimes:用于存放进程的时间运行时间,用于计算带权周转时间
    
            for (int i = 0; i < num; i++) {
                System.out.println("请给第" + (i + 1) + "个进程起个名字:");
                Process initProcess = Process.createInitProcess();
                CPURun += initProcess.getServeTime();
                serveTimes[i] = initProcess.getServeTime();
                initProcess.setIndex(i);
                list.add(initProcess);
            }
    
            System.out.println("请设置时间片大小(s):");
            int timeSlice = new Scanner(System.in).nextInt();
            //int timeSlice;定义时间片的大小
            ArrayDeque<Process> deque = new ArrayDeque<Process>(num);
            Process process;
            for (int i = 0; i < CPURun; i++) {
                if (i == 0) {
                    System.out.println("第" + i + "秒:");
                }
                //每隔一秒,向队列尾添加一个新的进程
                if (i < num) {
                    process = list.get(i);
                    deque.offerLast(process);
                    System.out.println("进程" + process.getName() + "首次到达就绪队列");
                }
                System.out.println("进程" + deque.getFirst().getName() + "正在执行。。。");
    
                System.out.println("当前就绪队列情况如下;");
                for (Process task : deque) {
                    if (task.getName().equals(deque.getFirst())) {
                        continue;
                    }
                    System.out.print(task.getName() + "\t");
                }
                System.out.println();
                System.out.println("----------------------------------------");
                if (i != 0) {
                    System.out.println("第" + i + "秒:");
                }
    
                if (i % timeSlice != 0) {
                    continue;
                }
                //resetServeTime刷新服务时间,
    
                Process process1 = deque.pollFirst().resetServeTime(timeSlice);
                if (process1.isAchieved()) {
                    System.out.println("进程" + process1.getName() + "执行结束!");
                    finishedTime = i + process1.getServeTime();
                    System.out.println("进程" + process1.getName() + "的周转时间为:");
                    System.out.println(finishedTime - process1.getArriveTime());
                    System.out.println("进程" + process1.getName() + "的带权周转时间为:");
                    double floatWi =
                            (finishedTime - process1.getArriveTime()) / serveTimes[process1.getIndex()];
                    System.out.println(floatWi);
                } else {
                    deque.offerLast(process1);
                    System.out.println("进程" + process1.getName() + "进入就绪队列");
                }
            }
        }
    
    
    }
    
    
    package com.symc.dsaa.os.test1;
    
    import java.util.Scanner;
    
    public class Process {
    
        private String name;
        private int arriveTime;
        private int serveTime;
    
        private int index;
    
        public Process() {
        }
    
        public Process(String name, int arriveTime, int serveTime) {
            this.name = name;
            this.arriveTime = arriveTime;
            this.serveTime = serveTime;
        }
    
        public boolean isAchieved() {
            if (serveTime <= 0) {
                return true;
            }
            return false;
        }
    
        public static Process createInitProcess() {//创建初始化进程
            Process process = new Process();
            Scanner sc = new Scanner(System.in);
            process.setName(sc.next());
            System.out.println("请输入进程" + process.getName() + "的到达时间:");
            process.setArriveTime(sc.nextInt());
            System.out.println("请输入进程" + process.getName() + "的服务时间:");
            process.setServeTime(sc.nextInt());
            return process;
        }
    
    
        public Process resetServeTime(int timeSlice) {//时间片大小 当一个进程从队列中取出并执行完,期间经过了时间片的处理,服务时间缩减
            this.serveTime = this.serveTime - timeSlice;
            return this;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getArriveTime() {
            return arriveTime;
        }
    
        public void setArriveTime(int arriveTime) {
            this.arriveTime = arriveTime;
        }
    
        public int getServeTime() {
            return serveTime;
        }
    
        public void setServeTime(int serveTime) {
            this.serveTime = serveTime;
        }
    
        public int getIndex() {
            return index;
        }
    
        public void setIndex(int index) {
            this.index = index;
        }
    }
    
    

    五、实验步骤及实验结果

    1、实验内容
    运行程序:根据题目要求输入数据
    需要输入进程数,每个进程的名称,到达时间和服务时间,以及设置时间片的大小。
    在这里插入图片描述

    2、实验结果

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    六、实验中出现的问题及解决方法

    问题1:程序实现的思想

    在一开始,我考虑用的是实时的或者说动态的实现进程执行的根据时间片的顺序执行,并且使用了非阻塞队列的DelayQueue的集合。在这个方式中,是我对这个队列以及API的实现原理掌握得不透彻,导致遇到了很多问题,我甚至去重写该集合的源码来实现我的目的,还用到了对象克隆技术,还创建了两个安全性的线程,分别用来添加新的进程和被循环取出的进程到队列中。虽然实现列动态实时添加的效果,但是一些执行的效果并不好,由于我没有做到控制两个线程和主线程之间的顺序,导致结果显示得很难懂。
    解决办法:我要的目的是实现这个模拟的结果,并不是注重这个过程,所以我只需要让它按照这个顺序跑出结果就可以了,并且,动态的每次执行需要等待,比如题中这5个任务一共是17秒的服务时间,那还需要等待17秒,才能看到我们想要的完整的结果。并且,使用普通的队列和单线程易控制,实现方式也简单。由此可见算法思想的重要性,此题将面向过程的思想转成面向结果的思想就简答多了。

    问题2:有序地创建出进程(任务)以及进程的存储

    我的想法是用户先将所有的进程设定好,然后一起跑(Run,运行的意思),但是设定好后的程序不能立即就使用,需要存放起来。
    解决办法:将进程封装好后,我在此类中添加一个用于快速创建进程对象的静态方法,它的返回值就是根据用户的设定初始化好的进程。使用for循环批量创建,同时使用ArrayList将这些进程存储起来。

    问题3:何时从队列中取出进程放到结尾

    要知道正在执行的程序是按照时间片循环执行的,要让程序按照这个规定间隔的顺序去取出和放入就绪队列,也是一件麻烦的事情。刚开始我按照1秒钟的时间片去写程序,这个跑起来很流畅,但是换成2秒,4秒的话,它就不听话了。
    解决办法:我加了这行代码:
    if (i % timeSlice != 0) {
    continue;
    }
    它是这么实现的,i是当前的时间,timeSlice是时间片,当前的时间点若是能被它是这么实现的,i是当前的时间,timeSlice是时间片,当前的时间点若是能被整除,说明此时正好是进程执行完一次的时间,后面就是交换进程的代码,如果要是不能被整除,说明此次时间片还没用完,结束本次循环,不让它跑后面的代码。比如,时间片大小为3,若i=6,那此时正好是第二轮时间片的结束时刻,此时应该交换进程;若i=5,不能整除,那不好意思,不能交换进程,需要再等一秒再说。

    问题4:进程每次执行完后的处理以及放入就绪队列队尾

    首先要知道它有没有执行完,若执行完就不用放到队尾,若没有执行完,那就得放到队尾,在放到队尾之前,对应的服务时间应该减去时间片。
    解决办法:好在用的面向对象的方式,直接通过set方法去修改服务时间即可。对于判断是否执行完,我在进程的类中添加了一个boolean类型的方法,服务时间等于或者小于0就说明它执行完了。我还定义了一个reset方法使该进程的服务时间减少。队列的集合有相关取出元素和放入元素的API。

    七、结论

    时间片大小应适中。

    展开全文
  • 1、设计一个程序实现基于优先数的时间片轮转调度算法调度处理器。 2、假定系统有5个进程,每个进程用一个进程控制块PCB开代表,进程控制块的结构 /*例如一组进程如下表: 进程名 A B C D E F G H J K L M 到达时间 ...
  • 1、设计一个程序实现基于优先数的时间片轮转调度算法调度处理器。 2、假定系统有5个进程,每个进程用一个进程控制块PCB开代表,进程控制块的结构 /*例如一组进程如下表: 进程名 A B C D E F G H J K L M 到达...
  • 时间片轮转调度算法模拟在单处理器情况下处理器调度时间片轮转算法,系统将所有进程排成一个队列,按照先来先执行的原则,将CPU分配给队首的进程,执行该进程一个时间片。一个时间片结束后停止执行该进程,将队...
  • 时间片轮转调度 时间片轮转调度策略:在轮转(RR)法中,系统将所有的就绪进程按FCFS策略排成一个就绪队列。系统可设置每隔一定时间(如30 ms)便产生一次中断,去激活进程调度程序进行调度,把CPU分配给队首进程,并...
  • 操作系统【时间片轮转调度算法 课本例题】
  • 【操作系统】时间片轮转调度

    千次阅读 2020-12-21 10:40:02
    操作系统——时间片轮转调度法 同义词:时间片轮转法一般指时间片轮转调度算法,时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法。每个进程被分配一时间段,称作它的时间片,即该进程允许运行的时间。 ...
  • 实验1 进程调度 一、实验目的 通过实验加强对进程调度算法的理解和掌握。 二、实验内容 编写程序实现基于优先级的时间片轮转调度算法。
  • 时间片轮转调度算法-代码独立性强,方便移植并且关于时间片的核心代码均有注释
  • 时间片轮转调度算法实现 学校的一个处理机调度实验,可能有的细节做的不是很好,但能运行出想要的结果,希望能够帮助有需要的人。 #include <iostream> #include <queue> #include <iomanip> #...
  • 1) 实验中使用的数据结构 (1) PCB进程控制块 内容包括参数①进程名name;...3) 时间片的大小由实验者自己定义,可为3或5 4) 可参考的程序流程图如图3.2 图3.2模拟进程调度的流程图 5) 参考程序 #inc
  • 我们说过 UCOSIII 是支持多个任务拥有同一个优先级的,这些任务采用时间片轮转调度方法进行任务调度。在 os_cfg.h 文件中有个宏 OS_CFG_SCHED_ROUND_ROBIN_EN,我们要想 使用时间片轮转调度就需要将OS_CFG_SCHED_...
  • 时间片轮转调度算法-c语言编程实现

    千次阅读 2021-11-08 17:03:39
    使用c语言编写程序,实现时间片轮转调度算法,对作业进行调度。当前时间为0点,时间单位为分钟。程序通过命令行读入作业信息。将调度结果输出到屏幕上,输出结果包括作业ID、作业开始时间、作业结束时间、周转时间和...
  • 时间片轮转调度算法 a.在时间片轮转调度算法中,系统根据先来先服务的原则,将所有的就绪进程排成一个就绪队列,并且每隔一段时间产生一次中断,激活系统中的进程调度程序,完成一次处理机调度,把处理机分配给就绪...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,240
精华内容 9,696
关键字:

时间片轮转调度