进程调度算法之最高优先级（Java）

最新推荐文章于 2024-05-11 01:36:50 发布
最新推荐文章于 2024-05-11 01:36:50 发布
阅读量558 收藏 1
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/DevLegal/p/9032292.html
版权

    这次是用String的一位数组加上list来实现的，上一次写短进程优先的时候，认为用date类太麻烦了。所以这次直接用String，没想到，还是一样的麻烦，因为我想要表示小时，分钟，秒数，三个时间单位，而不是两个时间单位。所以在从String转换成int，并进行计算的时候，比较麻烦。其中用到了简单的正则表达式，并将时间先转化成秒进行计算。

附上源码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

public class Priority {
    
    private static String[] PCB = {"0进程名", "1运行状态", "2优先级", "3提交时间", "4需要运行时间", "5完成时间", "6周转时间", "7响应比", "8已执行次数"};
    //记录当前时间
    static String now = "00:00:00";
    //时间片
    static int timeSlice = 500;
    //用String一维数组先建立几个进程
    private static String[] process1 = {"process1", "0", "1", "00:08:20", "00:10:56", "", "", "", ""};
    private static String[] process2 = {"process2", "0", "3", "00:01:08", "01:00:02", "", "", "", ""};
    private static String[] process3 = {"process3", "0", "2", "00:01:01", "00:10:02", "", "", "", ""};
    private static String[] process4 = {"process4", "0", "4", "00:01:01", "00:05:02", "", "", "", ""};
    private static String[] process5 = {"process5", "0", "7", "00:01:08", "00:00:02", "", "", "", ""};
    private static String[] process6 = {"process6", "0", "9", "00:02:08", "00:30:02", "", "", "", ""};
    private static String[] process7 = {"process7", "0", "4", "00:03:08", "00:03:01", "", "", "", ""};
    private static String[] process8 = {"process8", "0", "2", "00:05:01", "00:00:02", "", "", "", ""};
    private static String[] process9 = {"process9", "0", "1", "00:00:13", "00:11:02", "", "", "", ""};
    
    public static void main(String[] args) {
        
        List<String[]> list = new ArrayList<String[]>();
        list.add(process1);
        list.add(process2);
        list.add(process3);
        list.add(process4);
        list.add(process5);
        list.add(process6);
        list.add(process7);
        list.add(process8);
        list.add(process9);
        System.out.println(PCB[0] + " " + PCB[1] + " " + PCB[2] + " " + PCB[3] + " " + PCB[4]
                + " " + PCB[5] + " " + PCB[6] + " " + PCB[7] + " " + PCB[8]);
        startUp(list);
        
    }
    
    //修复String格式转换为long之后再转换为String而造成的格式不正确
    public static String modify(String string) {
        int i = string.length();
                
        if (i == 0) {
            return "00:00:00";
        }
        
        if (i == 1) {
            return "00:00:0" + string;
        }
        
        if (i == 2) {
            return "00:00:" + string;
        }
        
        if (i == 3) {
            char temp = string.charAt(0);
            char temp1 = string.charAt(1);
            char temp2 = string.charAt(2);
            return "00:0" + temp + ":" + temp1 + temp2;
        }
        
        if (i == 4) {
            char temp = string.charAt(0);
            char temp1 = string.charAt(1);
            char temp2 = string.charAt(2);
            char temp3 = string.charAt(3);
            return "00:" + temp + temp1 + ":" + temp2 + temp3; 
        }
        
        if (i == 5) {
            char temp = string.charAt(0);
            char temp1 = string.charAt(1);
            char temp2 = string.charAt(2);
            char temp3 = string.charAt(3);
            char temp4 = string.charAt(4);
            return "0" + temp  + ":" + temp1 + temp2 + ":" + temp3 + temp4;
        }
        
        if (i == 6) {
            char temp = string.charAt(0);
            char temp1 = string.charAt(1);
            char temp2 = string.charAt(2);
            char temp3 = string.charAt(3);
            char temp4 = string.charAt(4);
            char temp5 = string.charAt(5);
            return  temp + temp1 + ":" + temp2 + temp3 + ":" + temp4 + temp5;
        }
    
        else {
            return "false";
        }
    }
    
    public static void outPut(List<String[]> list) {
        for (String[] strings : list) {
            System.out.println(strings[0] + " " + strings[1] + " " + strings[2] + " " + strings[3]
                    + " " + strings[4] + " " + strings[5] + " " + strings[6] + " "
                    + strings[7]);
    }
    }
    //进程刚开始的时候调用此方法
    public static void startUp(List<String[]> list) {
        Collections.sort(list, new sortBySubAndPri());
        String[] processTemp = list.get(0);
        processTemp[1] = "1";
        
        if (toSecond(processTemp[4].replaceAll("[-\\s:]","")) < timeSlice) {
        processTemp[5] = revString(toSecond(processTemp[3].replaceAll("[-\\s:]","")) 
                + toSecond(processTemp[4].replaceAll("[-\\s:]","")));
        processTemp[6] = processTemp[4];
        processTemp[7] = "1";
        list.remove(0);
        list.add(0, processTemp);
        outPut(list);
        
        now = list.get(0)[4];
        list.remove(0);
        System.out.println("第一次进程执行完毕");
        execute(list);
        }
        else {
            processTemp[1] = "1";
            processTemp[4] = revString(toSecond(processTemp[4].replaceAll("[-\\s:]","")) - 500);
            now = revString(toSecond(processTemp[3].replaceAll("[-\\s:]","")) + 500);
            processTemp[2] = String.valueOf(Integer.valueOf(processTemp[2]) + 1); 
            processTemp[8] = "1";
            list.remove(0);
            list.add(0, processTemp);
            for (String[] strings : list) {
                System.out.println(strings[0] + " " + strings[1] + " " + strings[2] + " " + strings[3]
                        + " " + strings[4] + " " + strings[5] + " " + strings[6] + " "
                        + strings[7]);
        }
            processTemp[1] = "0";
            System.out.println("第一次进程执行完毕");
            execute(list);
        }
  }
    
    public static void execute(List<String[]> list) {
        
        if (list.isEmpty()) {
            System.out.println("进程运行结束");
            System.exit(0);
        }
        
        List<String[]> newList = new ArrayList<>();
        for (String[] strings : list) {
            int x = toSecond(strings[3].replaceAll("[-\\s:]",""));
            int y = toSecond(now.replaceAll("[-\\s:]",""));
            if (x < y) {
                newList.add(strings);
            }
        }
        
        Collections.sort(newList, new sortByPri());
        String[] processTemp = newList.get(0);
        if (toSecond(processTemp[4].replaceAll("[-\\s:]","")) < timeSlice) {
            processTemp[1] = "1";
            processTemp[5] = revString(toSecond(now.replaceAll("[-\\s:]",""))
                    + toSecond(processTemp[4].replaceAll("[-\\s:]","")));
            
                processTemp[6] = revString(toSecond(processTemp[5].replaceAll("[-\\s:]",""))
                        - toSecond(processTemp[3].replaceAll("[-\\s:]","")));
                if (processTemp[8] != "") {
                    int temp = Integer.valueOf(processTemp[8]);
                    //processTemp[7] = revString(toSecond(processTemp[6].replaceAll("[-\\s:]",""))
                    //      /((toSecond(processTemp[4].replaceAll("[-\\s:]","")) + temp * 500)));
                    String xxx = processTemp[6].replaceAll("[-\\s:]","");
                    int x = toSecond(xxx);
                    int y = toSecond(processTemp[4].replaceAll("[-\\s:]","")) + temp * 500;
                    double z = (double)x/y;
                    processTemp[7] = String.valueOf(z);
                            
    
    
                }
                else {
                //  processTemp[7] = revString(toSecond(processTemp[6].replaceAll("[-\\s:]",""))
                //          /toSecond(processTemp[4].replaceAll("[-\\s:]","")));
                        int x = toSecond(processTemp[6].replaceAll("[-\\s:]",""));
                        int y = toSecond(processTemp[4].replaceAll("[-\\s:]",""));
                        double z = (double)x/y;
                        processTemp[7] = String.valueOf(z);
                }
                now = processTemp[5];
                System.out.println(processTemp[0] + " " + processTemp[1] + " " + processTemp[2] + " " + processTemp[3]
                        + " " + processTemp[4] + " " + processTemp[5] + " " + processTemp[6] + " "
                        + processTemp[7]);
                Iterator<String[]> iterator = list.iterator();
                while (iterator.hasNext()) {
                    String[] strings = (String[]) iterator.next();
                    if (strings[0] == processTemp[0]) {
                        iterator.remove();
                    }
                }
        }
        
        else {
            processTemp[1] = "1";
            processTemp[2] = String.valueOf(Integer.valueOf(processTemp[2]) + 1); 
            processTemp[4] = revString(toSecond(processTemp[4].replaceAll("[-\\s:]","")) - 500);
            processTemp[5] = "do not finished";
            processTemp[6] = "do not confirm";
            processTemp[7] = "do not confirm";
            if (processTemp[8] != "") {
                int temp = Integer.valueOf(processTemp[8]);
                processTemp[8] = String.valueOf(temp + 1);
            }
            else {
                processTemp[8] = "1";
            }
            
            System.out.println(processTemp[0] + " " + processTemp[1] + " " + processTemp[2] + " " + processTemp[3]
                    + " " + processTemp[4] + " " + processTemp[5] + " " + processTemp[6] + " "
                    + processTemp[7]);
            processTemp[1] = "0";
            
            
            String hehe = now.replaceAll("[-\\s:]","");
            int haha = toSecond(hehe);
            now = revString(haha + 500);
            Iterator<String[]> iterator = list.iterator();
            while (iterator.hasNext()) {
                String[] strings = (String[]) iterator.next();
                if (strings[0] == processTemp[0]) {
                    iterator.remove();
                }
            }
            list.add(processTemp);
            
        }
        execute(list);
    }
    
    //先将字符串转化成秒来进行比较
    //注意[1]和[2]不要转
    public static int toSecond(String string) {
        
        int len = string.length();
        
        if (len == 0) {
            return 0;
        }
        
        if (len == 1 || len == 2) {
            return Integer.valueOf(string);
        }
        
        if (len == 3) {
            char temp = string.charAt(0);
            char temp1 = string.charAt(1);
            char temp2 = string.charAt(2);
            
            return (Integer.valueOf(temp) - 48) * 60 + (Integer.valueOf(temp1) - 48) * 10 + (Integer.valueOf(temp2) - 48);
        
        }
        
        if (len == 4) {
            char temp = string.charAt(0);
            char temp1 = string.charAt(1);
            char temp2 = string.charAt(2);
            char temp3 = string.charAt(3);
            
            return (Integer.valueOf(temp) - 48) * 10 * 60 + (Integer.valueOf(temp1) - 48) * 60
                    + (Integer.valueOf(temp2) - 48) * 10 + (Integer.valueOf(temp3) - 48);
        }
        
        if (len == 5) {
            char temp = string.charAt(0);
            char temp1 = string.charAt(1);
            char temp2 = string.charAt(2);
            char temp3 = string.charAt(3);
            char temp4 = string.charAt(4);

            return (Integer.valueOf(temp) - 48) * 60 * 10 * 60 + (Integer.valueOf(temp1) - 48) * 10 * 60
                    + (Integer.valueOf(temp2) - 48) * 60 + (Integer.valueOf(temp3) - 48) * 10 + (Integer.valueOf(temp4) - 48);
        }
        
        if (len == 6) {
            char temp = string.charAt(0);
            char temp1 = string.charAt(1);
            char temp2 = string.charAt(2);
            char temp3 = string.charAt(3);
            char temp4 = string.charAt(4);
            char temp5 = string.charAt(5);
            
            int i1 = (Integer.valueOf(temp) - 48) * 10 * 60 * 60;
            int i2 = (Integer.valueOf(temp1) - 48) * 60 * 60;
            int i3 = (Integer.valueOf(temp2) - 48) * 10 * 60;
            int i4 = (Integer.valueOf(temp3) - 48) * 60;
            int i5 = (Integer.valueOf(temp4) - 48) * 10;
            int i6 = (Integer.valueOf(temp5) - 48);
            
            
            
            return i1 + i2 + i3 + i4 + i5 + i6;
        }
        
        else {
            return 100000000; //如果都不是则说明出现了错误，则象征性的返回一个非常大的数字代表出错
        }
    }
    
    public static String revString(int a) {
        int secondTime, minuteTime, hourTime;
        String temp = "xxx";
        hourTime = a/3600;
        if (hourTime > 0) {
            minuteTime = (a - hourTime * 3600)/60;
        }
        
        else {
            minuteTime = a/60;
        }
        
        secondTime = a;
        
        if (hourTime > 0 && minuteTime > 0) {
            secondTime = a - minuteTime * 60 - hourTime * 3600;
        }
        
        if (hourTime == 0 && minuteTime > 0) {
            secondTime = a - minuteTime * 60;
        }
        
        //你这Bug我服，不写等于10的情况
        if (secondTime < 10 && minuteTime < 10) {
            temp = String.valueOf(hourTime) + "0" + String.valueOf(minuteTime) + "0" + String.valueOf(secondTime);                  
        }
        
        if (secondTime >= 10 && minuteTime < 10) {
            temp = String.valueOf(hourTime) + "0" + String.valueOf(minuteTime) + String.valueOf(secondTime);                
        }
        
        if (secondTime < 10 && minuteTime >= 10) {
            temp = String.valueOf(hourTime) + String.valueOf(minuteTime) + "0" + String.valueOf(secondTime);                
        }
        
        if (secondTime >= 10 && minuteTime >= 10) {
            temp = String.valueOf(hourTime) + String.valueOf(minuteTime) + String.valueOf(secondTime);                  
        }
        
        return modify(temp);
        
    }
}


class sortBySubAndPri implements Comparator<String[]>{
    
    
    @Override
    public int compare(String[] s1, String[] s2) {
        
        long longs1 = Priority.toSecond(s1[3].replaceAll("[-\\s:]","")); //用正则表达式处理格式问题
        long longs2 = Priority.toSecond(s2[3].replaceAll("[-\\s:]",""));
        
        int x = Integer.valueOf(s1[2]);
        int y = Integer.valueOf(s2[2]);
        
        if (longs1 != longs2) {
            return (int) (longs1 - longs2);
        }
        else {
            return y - x;
        }
        
    }
}


class sortByPri implements Comparator<String[]>{

    @Override
    public int compare(String[] o1, String[] o2) {
    
        int x = Integer.valueOf(o1[2]);
        int y = Integer.valueOf(o2[2]);
        return x - y;
    }
    
}

1286531-20180513153412213-618412707.png

转载于:https://www.cnblogs.com/DevLegal/p/9032292.html

adeq28027
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA操作系统实验进程调度图形化模拟程序
01-10
总的来说，“JAVA操作系统实验进程调度图形化模拟程序”是一个实用的教学工具，它不仅能够帮助学生和教师理解进程调度的基本概念，还能通过实际操作体验各种调度算法的优劣，为深入学习操作系统提供了有力的支持。...
短进程优先算法(C,Java实现)
ZLY2230530082的博客
10-26 5565
短进程优先算法(C,Java实现)
操作系统常用作业进程调度算法（Java模拟）
炎溟墨的博客
08-08 4014
文章目录什么是作业调度什么是进程调度FCFS(先来先服务调度算法)SJF（短作业优先调度算法）HRRN(高响应比优先调度算法)优先级调度算法RR(时间片轮转调度算法)多级反馈队列调度算法代码分析节点代码创建与检查节点调度算法封装测试代码 什么是作业调度 根据JCB中的信息，检查系统中的资源是否能满足作业对资源的需求，以及按照一定的调度算法，从外存的后备队列中选取某些作业调入内存，并为他们创建进程，...
Java最全高响应比优先调度算法和短作业优先调度算法_高相应比优先调度，蚂蚁金服、拼多多、字节跳动社招面经
最新发布
2401_84557608的博客
05-11 300
分享一套我整理的面试干货，这份文档结合了我多年的面试官经验，站在面试官的角度来告诉你，面试官提的那些问题他最想听到你给他的回答是什么，分享出来帮助那些对前途感到迷茫的朋友。
用java语言，模拟实现操作系统的进程调度算法，先来先服务，高优先级、高响应比、时间片轮转和短作业
qq_39487033的博客
01-06 8428
构思算法的实现过程。 ①先来先服务算法 一开始我从最简单的先来先服务开始想，既然要排序进程链表的执行顺序，肯定要将链表的头head作为参数传入到方法中。其次为了之后方便一次性检验多种算法，传入进来的head链表我不会对它进行任何改变。所以创建一个新链表head2用CreateHead方法将链表进行复制，这样我就可以拿head2这个复制品随便搞，也不会影响之后调用其他算法，因为head没变。 当我拿...
短作业优先调度算法（sjf）java实现
可行的code
03-29 6887
目录 短作业（进程）优先调度算法： 1.作业类job 2.sjf主方法类shortJobFirst 3.sjf工具类shortJobFirstUtil。 4.运行结果 短作业（进程）优先调度算法： 是指对短作业（进程）优先调度的算法。短作业优先(SJF)调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程优先(SPF)调度算法，则是从就绪队列中选...
短作业优先(SJF)调度算法（Java实现）
热门推荐
世纪末的架构师的博客
05-30 1万+
文章目录前言一、短作业优先(SJF)算法是什么？二、短作业优先(SJF)算法分析三、代码实现1.引入库2.读入数据总结 前言 在实现了先来先服务（FCFS）算法之后能够明显的感觉到先来先服务算法将当前处于就绪队列队首的那个进程调度到运行状态。也就是说，先来先服务算法只考虑作业或进程进入就绪队列的时间先后，而不考虑它的下一个CPU周期的长短等其他因素。虽然先来先服务算法简单易行并且是一种非抢占式策略，但性能却不大好导致平均周转时间特别长。因此，在先来先服务的算法基础上提出了短作业优先(SJF)算法来改进先来
Java模拟最短作业优先、时间片轮转、最高响应比三种进程调度算法
12-14
本次试验是使用程序来模拟操作系统中进程调度的三种不同的调度策略，分别为最短作业有限、时间片轮转、最高响应比。 模拟的情况下，进程数为8，进程所需执行时间为随机产生的整数，单位为1S，默认进程同时到达。 ...
shiyan1_进程调度_操作系统_最高优先数优先_
10-01
综上所述，最高优先数优先调度算法是一种有效的进程调度策略，它基于进程优先数进行决策，但需注意防止优先级反转问题。操作系统通过PCB管理进程，并可能结合其他机制优化调度性能。实际编程实现时，可以通过像...
Java模拟最短作业优先、时间片轮转、最高响应比和先来先服务进程调度算法
06-21
Java模拟最短作业优先、时间片轮转、最高响应比和先来先服务进程调度算法 rar中有四种算法和俩个对进程用时和周转时间制图的java源代码，另外有jcommon-1.0.23.jar和jfreechart-1.0.19.jar俩个制图包
编写程序实现基于优先级的时间片轮转调度算法
06-19
在操作系统设计中，进程调度是核心任务之一，它决定了如何有效地在多个并发进程中分配处理器资源。本实验聚焦于“基于优先级的时间片轮转调度算法”，这是一种兼顾响应时间和系统效率的调度策略。以下是对该算法及其...
高响应比优先调度算法(HRRN)
04-30
java平台运行高响应比优先调度算法，如果响应比相同则短作业优先。输出进程工作顺序、调度时间、周转时间、带权周转时间、平均周转时间和平均带权周转时间。压缩带有测试案例
进程调度的两种算法JAVA实现----FCFS(先来先服务)和SJF(最短作业优先)
06-19
进程调度的两种算法JAVA实现----FCFS(先来先服务)和SJF(最短作业优先) 直接能运行，完整版本，jdk 1.6就行
【C语言源代码】 操作系统-短进程优先-进程调度算法
02-10
C语言实现：短进程优先-进程调度算法 1. 采用“短进程优先”调度算法对五个进程进行调度。每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、到达时间、需要运行时间、已用CPU时间、进程状态等等。 2. 每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。重复以上过程，直到所要进程都完成为止。
java 先来先服务，短进程优先算法
04-29
java 先来先服务，短进程优先算法 ,有含精美界面
Java实现先来先服务与短作业优先
10-25
通过Java实现常用调度算法中的先来先服务和短作业优先
Java多线程并发：进程调度算法
河湾
05-22 641
一 优先调度算法 1.先来先服务调度算法（FCFS） 当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队 列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用 FCFS 算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机，特点是：算法比较...
操作系统进程调度 FCFS，SJF，RR算法（Java实现）
weixin_46050542的博客
03-25 4815
一、问题描述 设计程序模拟内存的动态分区法存储管理。内存空闲区使用自由链管理,采用最坏适应算法从自由链中寻找空闲区进行分配。 假定系统的内存共364K,初始状态为操作系统本身占用64K。在t1时间之后,有作业A、B、C、D分别请求8K、16K、64K、124K的内存空间:在t2时间之后,作业C完成;在t3时间之后,作业E请求5K的内存空间;在t4时间之后,作业D完成。要求编程序分别输出t1、t2、t3、t4(时刻内存的空闲区的状态。 通过这次试验，加深对内存管理的认识，进一步掌握内存的分配、回收算法的
java实现排程算法_调度算法——短作业优先（java实现） | 学步园
weixin_39768695的博客
02-16 387
class A{class B{//内部类方便private String processname ;//s进程名private float arrivetime ;//到达时间private float servetime ;//服务时间private float finishtime ;//完成时间private float turnovertime ;//周转时间private float ...
编制高响应比优先调度算法进程调度算法java
05-10
Java中的进程调度算法主要是由JVM和操作系统协同实现的。Java虚拟机（JVM）中包含有一个线程调度器，该调度器使用了多种调度算法来实现线程的调度。其中最常用的是时间片轮转调度算法和优先级调度算法。时间片轮转...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值