java实现操作系统时间片轮转进程调度算法（RR算法）

最新推荐文章于 2024-04-19 16:34:14 发布
最新推荐文章于 2024-04-19 16:34:14 发布
阅读量3.2k 收藏 57
点赞数 4
文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55915890/article/details/124008528
版权

Time类

package RR算法;
public class time {
    private int hour;
    private int min;

    public int getHour() {
        return hour;
    }

    public void setHour(int hour) {
        this.hour = hour;
    }

    public int getMin() {
        return min;
    }

    public void setMin(int min) {
        this.min = min;
    }

    public void initTime(String t){
        this.hour = Integer.parseInt(t.split(":")[0]);
        this.min = Integer.parseInt(t.split(":")[1]);
    }

    public static int sub(String s,String f){
        return Integer.parseInt(f.split(":")[0])*60+Integer.parseInt(f.split(":")[1])
                -Integer.parseInt(s.split(":")[0])*60-Integer.parseInt(s.split(":")[1]);
    }

    @Override
    public String toString() {
        if(min < 10){
            return hour+":0"+min;
        }else{
            return hour+":"+min;
        }
    }
}

Process类

package RR算法;

import RR算法.Process;
import RR算法.time;

class jxQueue {
	//链结点
	Process front;
	Process rear;
//		public jxQueue() {}
}

public class Process implements Comparable{

	private int id; //编号
    private String name; // 进程名
    int good;          //优先级
    private time arrive; //到达就绪队列的时间
    private int zx; //执行时间
    private time firstStart; //进入CPU运行开始的时间
    private time finish; //完成时间
    private int zz; //周转时间 = 完成时间 - 到达就绪时间
    private float zzxs; // 带权周转系数 = 周转时间/执行时间
    public Process next;
    private int size;
    public int flag; //记录该进程的执行次数 flag的最大值等于 执行时间/时间片时间 取整
    public int haveFinish; //记录该进程的已完成时间
    private time currentStart; //当前开始时间

  //初始化操作
  	public void init(jxQueue q){
  		this.size =0;
  		q.front = q.rear = null;
  	}
  	
  //判队空
  	public boolean isEmpty(jxQueue q) {
  		if((q.front == q.rear) && size == 0) {
  			return true;
  		}else {
  			return false;
  		}
  	}
  	
  //入队
  	public void add(jxQueue q,Process p) {
  		p.next = null;
  		if(isEmpty(q)) {
			q.front = p;
			q.rear = p;
			size++;
		}else {
			q.rear.next = p;
			q.rear = p;
			size++;
		}
  	}
  	
  	//出队
  	public void pop(jxQueue q) {
  		Process p = q.front;
  		q.front = p.next;
		size--;
  	}
  	
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public int getGood() {
        return good;
    }

    public void setGood(int good) {
        this.good = good;
    }

    public time getArrive() {
        return arrive;
    }

    public void setArrive(time arrive) {
        this.arrive = arrive;
    }

    public int getZx() {
        return zx;
    }

    public void setZx(int zx) {
        this.zx = zx;
    }

    public time getfirstStart() {
        return firstStart;
    }

    public void setfirstStart(time firstStart) {
        this.firstStart = firstStart;
    }
    
    public time getcurrentStart() {
        return currentStart;
    }

    public void setcurrentStart(time currentStart) {
        this.currentStart = currentStart;
    }

    public time getFinish() {
        return finish;
    }

    public void setFinish(time finish) {
        this.finish = finish;
    }

    public int getZz() {
        return zz;
    }

    public void setZz(int zz) {
        this.zz = zz;
    }

    public float getZzxs() {
        return zzxs;
    }

    public void setZzxs(float zzxs) {
        this.zzxs = zzxs;
    }

    @Override
    public int compareTo(Object o) {
        if( o instanceof Process){
            Process t = (Process) o;
            return (this.arrive.getHour()*60+this.arrive.getMin())-(t.arrive.getHour()*60+t.arrive.getMin());
        }
        return 0;
    }

    @Override
    public String toString() {
        return "Process{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", good=" + good +
                ", arrive=" + arrive +
                ", zx=" + zx +
                ", start=" + firstStart +
                ", finish=" + finish +
                ", zz=" + zz +
                ", zzxs=" + zzxs +
                '}';
    }

}

Main主函数

package RR算法;
import java.util.ArrayList;
import java.util.Scanner;
import RR算法.Process;

public class Main {
	
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.print("请输入操作(1：开始进程调度 0:结束进程):");
        int flag = s.nextInt();
        while (flag == 1){
            ArrayList<Process> list = new ArrayList<>();
            ArrayList<Process> list1 = new ArrayList<>(); //用来存放remove了的进程
            ArrayList<Process> list2 = new ArrayList<>(); //用来临时存放队首进程
            int zz;
            int hour=0;
            int min=0;
            int n = 1; //第n轮执行
            System.out.print("请输入时间片时间:");
            int para = s.nextInt();
            System.out.print("请输入进程数:");
            int num = s.nextInt();
            System.out.println("请输入进程的参数:");
            System.out.println("ID号  名字  优先级	 到达时间  执行时间(分钟):");//输入用空格分隔
            for (int i = 0; i < num; i++) {
                Process p = new Process();
                p.setId(s.nextInt());
                p.setName(s.next());
                p.setGood(s.nextInt());
                time t = new time();
                t.initTime(s.next());
                p.setArrive(t);
                p.setZx(s.nextInt());
                time tt = new time();
                tt.setHour(hour);
                tt.setMin(min);
                p.setcurrentStart(tt);
                p.haveFinish = 0;
                p.flag = 0; //初始化执行次数
                list.add(p);
            }
            list.sort(Process::compareTo); //对list的进程按到达时间排序
            System.out.println(" ");
            jxQueue q = new jxQueue();
            Process p = new Process();
            p.init(q);
            int loc=0;
            float sumZz = 0;
            float sumZzxs = 0;
            
         // 找出最先到达的进程
            for (int i = 1; i < list.size(); i++) {
                if(time.sub(list.get(loc).getArrive().toString(),list.get(i).getArrive().toString()) < 0){
                    loc = i;
                }
            }
            list.get(loc).setcurrentStart(list.get(loc).getArrive());
            p.add(q, list.get(loc)); //入就绪队列
            list.remove(loc);
            
            while(list.size() != 0 || !p.isEmpty(q)){
            	
            	int turnFinish = 0; //执行该进程花的时间
            	if(q.front.getZx()-q.front.flag*para >= para) {
            		q.front.flag++;
            		//该进程开始执行，设置首次开始时间
            		if(q.front.flag==1) {
            			q.front.setfirstStart(q.front.getcurrentStart());
            		}
            		q.front.haveFinish = q.front.flag*para;
            		turnFinish = para;
            	}else if(q.front.getZx()-q.front.flag*para < para){
            		q.front.haveFinish = q.front.getZx();
            		turnFinish = q.front.getZx() - q.front.flag*para;
            	}
            	
            	for(int i=0;i<list.size();i++) {
                	//如果该次该进程执行完成时已经有新的进程到达，则入队
                	if(q.front.getcurrentStart().getHour()*60+q.front.getcurrentStart().getMin() + turnFinish >= 
                			list.get(i).getArrive().getHour()*60+list.get(i).getArrive().getMin()) {
                		p.add(q, list.get(i));
                		list.remove(i);
                		i--;
                	}
                }
            	
                //如果进程的已完成时间等于总执行时间，进程执行结束，设置完成时间
                if(q.front.haveFinish == q.front.getZx()) {
            		if(q.front.getcurrentStart().getMin()+turnFinish < 60) {
                    	time t1 = new time();
                    	t1.setHour(q.front.getcurrentStart().getHour());
                    	t1.setMin(q.front.getcurrentStart().getMin()+turnFinish);
                    	q.front.setFinish(t1);
                    }else {
                    	time t2 = new time();
                    	t2.setHour(q.front.getcurrentStart().getHour()+1);
                    	t2.setMin(q.front.getcurrentStart().getMin()+turnFinish-60);
                    	q.front.setFinish(t2);
                    }
            	}
                
                // 计算周转时间和周转系数
                if(q.front.getFinish() != null) {
                	zz = time.sub(q.front.getArrive().getHour()+":"+q.front.getArrive().getMin(),
  	            		 q.front.getFinish().getHour()+":"+q.front.getFinish().getMin());
  	              	q.front.setZz(zz);
  	              	q.front.setZzxs((float)q.front.getZz()/q.front.getZx());
  	              	sumZz += q.front.getZz();
  	              	sumZzxs += q.front.getZzxs();
                }
                
                System.out.println("第" + n + "轮执行和就绪队列的结果：");
                System.out.println("ID号  名字  到达时间  总执行时间(分钟)  当前开始时间  已完成时间(分钟)  剩余完成时间(分钟)");
                Process p1 = q.front;
                while(p1 != null) {
                	if(p1 != q.front) {
                		time t = new time();
                		t.setHour(0);
                		t.setMin(0);
                		p1.setcurrentStart(t);
                	}
                    System.out.println(String.format("%-6d",p1.getId())
                            +String.format("%-6s",p1.getName())
                            +String.format("%-10s",p1.getArrive().toString())
                            +String.format("%-13s",p1.getZx()+"(分钟)")
                            +String.format("%-9s",p1.getcurrentStart().toString())
                            +String.format("%-10d",p1.haveFinish)
                            +String.format("%-10d",p1.getZx()-p1.haveFinish));
                    p1 = p1.next;
                }
                System.out.println(); //换行
                
                n++; //开始下一轮
                //设置下一个进程的当前开始时间 等于前一个进程的当前开始时间加上执行所花费的时间turnFinish
                if(q.front.next != null) {
                	if(q.front.getcurrentStart().getMin()+turnFinish < 60) {
                    	time t3 = new time();
                    	t3.setHour(q.front.getcurrentStart().getHour());
                    	t3.setMin(q.front.getcurrentStart().getMin()+turnFinish);
                    	q.front.next.setcurrentStart(t3);
                    }else if(q.front.getcurrentStart().getMin()+turnFinish >= 60){
                    	time t4 = new time();
                    	t4.setHour(q.front.getcurrentStart().getHour()+1);
                    	t4.setMin(q.front.getcurrentStart().getMin()+turnFinish-60);
                    	q.front.next.setcurrentStart(t4);
                    }
                }
                if(q.front != q.rear) {
                	//处理这轮执行的进程：如果已完成时间等于总执行时间，则出队；否则将该进程放在队尾排队等待执行
                    if(q.front.haveFinish == q.front.getZx()) {
                    	list1.add(q.front);
                    	p.pop(q);
                    }else if(q.front.haveFinish < q.front.getZx()){
                    	list2.add(q.front);
                    	p.pop(q); //出队
                    	p.add(q, list2.get(0)); //入队尾
                    	list2.clear(); //list2用于每次临时存放队首，使用完应该清零
                    }
                }else if(q.front == q.rear) {
                	if(q.front.getZx()-q.front.flag*para >= para) {
                		q.front.flag++;
                		q.front.haveFinish = q.front.flag*para;
                		turnFinish = para;
                	}else if(q.front.getZx()-q.front.flag*para < para){
                		q.front.haveFinish = q.front.getZx();
                		turnFinish = q.front.getZx() - q.front.flag*para;
                	}

                	q.front.haveFinish = q.front.getZx();
                	if(q.front.getcurrentStart().getMin()+para < 60) {
                    	time t5 = new time();
                    	t5.setHour(q.front.getcurrentStart().getHour());
                    	t5.setMin(q.front.getcurrentStart().getMin()+para);
                    	q.front.setcurrentStart(t5);
                    }else if(q.front.getcurrentStart().getMin()+para >= 60){
                    	time t6 = new time();
                    	t6.setHour(q.front.getcurrentStart().getHour()+1);
                    	t6.setMin(q.front.getcurrentStart().getMin()+para-60);
                    	q.front.setcurrentStart(t6);
                    }
                	if(q.front.getcurrentStart().getMin()+turnFinish < 60) {
                    	time t1 = new time();
                    	t1.setHour(q.front.getcurrentStart().getHour());
                    	t1.setMin(q.front.getcurrentStart().getMin()+turnFinish);
                    	q.front.setFinish(t1);
                    }else {
                    	time t2 = new time();
                    	t2.setHour(q.front.getcurrentStart().getHour()+1);
                    	t2.setMin(q.front.getcurrentStart().getMin()+turnFinish-60);
                    	q.front.setFinish(t2);
                    }
                	zz = time.sub(q.front.getArrive().getHour()+":"+q.front.getArrive().getMin(),
     	            		 q.front.getFinish().getHour()+":"+q.front.getFinish().getMin());
     	              	q.front.setZz(zz);
     	              	q.front.setZzxs((float)q.front.getZz()/q.front.getZx());
     	              	sumZz += q.front.getZz();
     	              	sumZzxs += q.front.getZzxs();
                	System.out.println("第" + n + "轮执行和就绪队列的结果：");
                	System.out.println("ID号  名字  到达时间  总执行时间(分钟)  当前开始时间  已完成时间(分钟)  剩余完成时间(分钟)");
                	System.out.println(String.format("%-6d",q.front.getId())
                            +String.format("%-6s",q.front.getName())
                            +String.format("%-10s",q.front.getArrive().toString())
                            +String.format("%-13s",q.front.getZx()+"(分钟)")
                            +String.format("%-9s",q.front.getcurrentStart().toString())
                            +String.format("%-10d",q.front.haveFinish)
                            +String.format("%-10d",q.front.getZx()-q.front.haveFinish));
                	list1.add(q.front);
                	break;
                }
            }
            
            System.out.println();
            //按完成时间的先后打印进程执行的信息
            System.out.println("ID号  名字  到达时间  执行时间(分钟)  首次开始时间  完成时间  周转时间  带权周转时间:");
            for(int k=0;k<num;k++) {
            	loc = 0;
            	for (int i = 0; i < list1.size(); i++) {
                    if(time.sub(list1.get(loc).getFinish().toString(),list1.get(i).getFinish().toString()) < 0){
                        loc = i;
                    }
                }
                System.out.println(String.format("%-6d",list1.get(loc).getId())
                        +String.format("%-6s",list1.get(loc).getName())
                        +String.format("%-10s",list1.get(loc).getArrive().toString())
                        +String.format("%-13s",list1.get(loc).getZx()+"(分钟)")
                        +String.format("%-9s",list1.get(loc).getfirstStart().toString())
                        +String.format("%-10s",list1.get(loc).getFinish().toString())
                        +String.format("%-16s",list1.get(loc).getZz()+"(分钟)")
                        +String.format("%-4.2f",list1.get(loc).getZzxs()));
                list1.remove(loc);
            }
        	
            System.out.println(String.format("%-48s","系统平均周转时间为:")+String.format(" %-4.2f",sumZz/num));
            System.out.println(String.format("%-64s","系统带权平均周转时间为: ")+String.format("%-4.2f",sumZzxs/num));
            
            System.out.print("是否继续进程调度实验,开始实验:1，结束实验:0 :");
            flag = s.nextInt();
        }
        System.out.println("进程调度实验结束!!!");
        s.close();
    }
}
/*
 * 实验数据：
5001	p1	1	9:40	20
5004	p4	4	10:10	10
5005	p5	3	10:05	30
5002	p2	3	9:55	15
5003	p3	2	9:45	25


5001  p1  1  19:40  20
5002  p4  2  10:10  10
5003  p5  3  10:05  30
5004  p2  4  9:55   15
5005  p3  5  9:45   25
5006  p6  6  11:40  20
5007  p8  7  12:10  10
5008  p9  8  13:05  30
5009  p10 9  19:55  15
5010  p7  10 7:15   15
* */

运行结果截图

 详细算法思想可以参考：Java操作系统进程调度算法——时间片轮转(RR)算法_哆啦有个B梦*的博客-CSDN博客_时间片轮转算法的进程状态转换图

今晚不熬夜_00
关注
  • 4
    点赞
  • 踩
  • 57
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
进程调度 RR 时间片轮转调度 java实现
SKPrimin的博客
11-19 1351
时间片轮转调度 时间片轮转调度策略：在轮转(RR)法中，系统将所有的就绪进程按FCFS策略排成一个就绪队列。系统可设置每隔一定时间(如30 ms)便产生一次中断，去激活进程调度程序进行调度，把CPU分配给队首进程，并令其执行一个时间片。当它运行完毕后，又把处理机分配给就绪队列中新的队首进程，也让它执行一个时间片。这样，就可以保证就绪队列中的所有进程在确定的时间段内，都能获得一个时间片的处理机时间。 数据结构和符号说明 本次的PCB类数据结构有三个公共变量，五个私有变量，一个标志变量，以及一个时时返回给调
Java操作系统进程调度算法——时间片轮转(RR)算法
吉祥宝典
04-22 6978
Java操作系统进程调度算法——时间片轮转(RR)算法 文章目录Java操作系统进程调度算法——时间片轮转(RR)算法前言一、算法思想二、数据结构1.定义PCB进程控制块2.实现思路三、流程图四、完整代码五、实验结果1、输入示例2、运行截图 前言 一、算法思想 按进程到达顺序将进程依次加入就绪队列当中，然后将 CPU 分配给位于队首的进程，确定一个时间片，让该进程执行一个时间片。当该进程执行时间到时，该进程可能已经执行完毕（可能在时间片未到时就以及执行完毕），或者未执行完毕，如果是前者只需将进程弹出队列
按时间片轮转的处理机调度java实现
03-20
使用java语言实现按时间片轮转的处理机调度
CPU调度算法-Linux操作系统下的时间片轮转调度算法-C语言（附代码）
m0_73160444的博客
04-19 1035
这个算法的核心思想是将所有的就绪进程排成一个队列，并给每个进程分配一个固定的时间段，称为“时间片”（time slice），通常在10到100毫秒之间。每个进程轮流使用CPU，如果在分配的时间片内没有完成，则会被放回队列末尾，等待下一次机会。但如果顾客太多，或者每个人的饭量不一样（进程的任务大小不同），就需要合理安排每个人的服务时间（时间片的长度），以确保大家都满意。：输入完数据后，程序会根据您输入的数据执行时间片轮转调度算法，并显示每个时间片执行的进程和时间。宏定义了每个时间片的长度，而。
操作系统课设（时间片轮转调度java可视化）
Ricardo的博客
05-26 1095
借鉴博主的金句：记住，每个人都不是一座孤岛，遇到困难先别放弃，先在网上找找，因为程序员最好的帮手，就应该有现如今发达的网络。通过课程设计，可加强学生对原理知识的理解。I，O，W三条指令实际上是不占有CPU的，执行这三条指令就应该将进程放入对应的等待队列（输入等待队列，输出等待队列 ，其他等待队列）。例如，有一虚拟程序文件prc.txt描述如下，其中，指令后面的数值代表该指令需要执行的时间片个数，如C10，代表需要计算10个。1、进程的个数，进程的内容（即进程的功能序列）来源于一个进程序列描述文件。
Linux操作系统课程设计，使用JAVA实现时间片轮转法
IshidaYoshiyama的博客
07-16 565
时间片轮转算法-将CPU 的处理时间划分成一个个时间片，就绪队列中的诸进程轮流运行一个时间片，当时间片结束时，就强迫运行进程让出CPU，该进程进入就绪队列，等待下一次调度，同时,进程调度又去选择就绪队列中的一个进程,分配给它一个时间片，以投入运行。在轮转法中，时间片长度的选择非常重要,将直接影响系统开销和响应时间。如果时间片长度很小，则调度程序剥夺处理机的次数频繁,加重系统开销；反之，如果时间片长度选择过长，比方说一个时间片就能保证就绪队列中所有进程都执行完毕，则轮转法就退化成先进先出算法。
LeetCode：189. 轮转数组（Java）
Yanir的博客
04-30 875
方法1：跳序轮转法——带标记，时间复杂度和空间复杂度均为O(n) 因为有些特殊情况，会陷入循环，比如这个例子： 我不知道怎么处理这种情况，所以直接搞个标记数组falgs[]来看看这个位置的数字是否被处理过。方法二来改进这个陷入循环的问题 class Solution { public void rotate(int[] nums, int k) { // 1.跳序 轮转法——带标记，时间复杂度和空间复杂度均为O(n) int len=n...
java 时间片_Java 实现--时间片轮转 RR 进程调度算法
weixin_29601703的博客
02-12 1615
时间片轮转(Round-Robin)调度算法是操作系统一种比较公平的进程调度的方式，这种方式使得就绪队列上的所有进程在每次轮转时都可以运行相同的一个时间片。基本原理算法实现原理是，按进程到达顺序(FCFS 原则)将进程依次加入就绪队列当中，然后将 CPU 分配给位于队首的进程，确定一个时间片，让该进程执行一个时间片。当该进程执行时间到时，该进程可能已经执行完毕(可能在时间片未到时就以及执行完毕)，...
操作系统实验：时间片轮转RR进程调度算法.doc
05-11
本文档对时间片轮转RR进程调度算法进行了详细的实现和分析。该算法是操作系统中的一种常用的进程调度算法，能够合理地分配CPU时间片，提高系统的效率和公平性。 一、需求分析 时间片轮转RR进程调度算法的主要需求...
操作系统 时间片轮转RR进程调度算法 java版.doc
05-30
操作系统时间片轮转RR进程调度算法java版.doc 本文档主要介绍了操作系统中时间片轮转RR进程调度算法的Java实现。该算法用于模拟进程的时间片轮转调度过程，计算每个进程的完成时间、周转时间和带权周转时间，并统计...
操作系统实验二 时间片轮转RR进程调度算法
02-02
时间片轮转算法是一种公平的调度策略，它将所有的就绪进程放入一个队列中，然后按照先入先出(FIFO)的原则进行处理。每个进程被分配一个固定的时间片（通常非常短，如几十毫秒），在该时间片内，进程可以独占CPU执行...
Java模拟操作系统实验之四种进程调度算法实现（FCFS,SJF,RR,HRN）
01-01
本文将深入探讨Java环境下实现的四种进程调度算法：先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)以及高响应比优先(HRN)。这些算法在多任务环境中用于决定哪个进程应该获得CPU的执行权，以达到资源分配的公平...
6操作系统实验课程设计-时间片轮转调度算法
12-05
时间片轮转调度算法是操作系统中的一个重要概念，用于管理多道程序环境下的进程调度。该算法的基本思想是将CPU的时间划分为多个固定长度的时间片，每个时间片内只允许一个进程执行。当进程运行完其分配到的时间片或...
java设计一个按时间片轮转法实现处理器调度的程序
2301_77431234的博客
10-19 202
【代码】java设计一个按时间片轮转法实现处理器调度的程序。
Java模拟操作系统实验一：四种进程调度算法实现（FCFS,SJF,RR,HRN）
热门推荐
走过，路过，别错过的博客
01-01 3万+
前言 刚学完操作系统，模拟实现了其中一些经典的算法，内容比较多，打算写一个系列的总结，将自己的源码都分享出来，既方便自己以后复习，也希望能帮助到一些刚入坑的小伙伴。我的所有代码的运行环境都是基于Eclipse，jdk1.10下。 1.问题概述 编程实现常用调度算法，即先来先服务、短作业（进程）优先、时间片轮转以及最高响应比优先调度算法。编程语言及环境不限。须给出关键数据结构、算法以及变量的详...
时间片轮转调度算法（Java）
小L的博客
12-04 3042
本程序用时间片轮转调度算法对五个进程进行调度，假设每个进程初始状态为就绪状态。 程序中的某进程运行时间以时间片单位为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(
Java调度算法实现与应用（FCFS、SJF、RR、HPF）
秃了也弱了
08-04 676
调度算法常见于操作系统中，因为系统资源有限，当有多个进程（或多个进程发出的请求）要使用这些资源时，就必须按照一定的原则选择进程（请求）来占用资源。这就是所谓的调度。在现实生活中也是一样，比如会议室的占用。应用：CPU资源调度云计算资源调度容器化Docker编排与调度先来先服务，很好理解，就是按照服务提交申请的顺序，依次执行。讲究先来后到。执行时间短的优先得到资源。即执行前申报一个我需要占据cpu的时间，根据时间长短，短的优先被调度。时间片逐个扫描轮询，轮到谁谁执行。
java进程调度_Java实现进程调度算法(二) RR(时间片轮转)
weixin_33487490的博客
02-20 347
RR类(主类)只有calc()中涉及了算法，init()和printResult()都只有简单的输入输出操作。1 packagexqy.algorithm;23 import java.util.*;45 importxqy.Util.Tools;6 importxqy.been.Process;78 /**9 * @author xqy10 * @date 2018年12月19日19:14:...
轮转数组（Java）
weixin_51423778的博客
06-24 198
轮转数组（java）
时间片轮转RR进程调度算法实验原理
最新发布
05-18
时间片轮转（Round Robin）算法是一种常见的进程调度算法。它的核心思想是将 CPU 的执行时间分成若干个时间片，每个进程在一个时间片内能够执行的时间有限，如果在这个时间片内没有执行完，则放到队列的末尾等待下一轮的调度。 具体来说，RR 算法会维护一个就绪队列，每次从队头取出一个进程执行，如果该进程在时间片内没有执行完毕，则将其放到队尾，等待下一轮的调度。这样，所有就绪进程都有机会获得 CPU 的执行时间。 需要注意的是，RR 算法中的时间片大小是可调的，可以根据系统的实际情况进行设置。时间片太短会导致频繁地进行上下文切换，降低系统性能；时间片太长则会导致长时间等待 CPU 的进程响应变慢。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值