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

最新推荐文章于 2021-12-16 13:33:44 发布
最新推荐文章于 2021-12-16 13:33:44 发布
阅读量579 收藏 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
关注
JAVA操作系统实验进程调度图形化模拟程序
01-10
总的来说，“JAVA操作系统实验进程调度图形化模拟程序”是一个实用的教学工具，它不仅能够帮助学生和教师理解进程调度的基本概念，还能通过实际操作体验各种调度算法的优劣，为深入学习操作系统提供了有力的支持。...
短作业优先调度算法（sjf）java实现
可行的code
03-29 7119
目录 短作业（进程）优先调度算法： 1.作业类job 2.sjf主方法类shortJobFirst 3.sjf工具类shortJobFirstUtil。 4.运行结果 短作业（进程）优先调度算法： 是指对短作业（进程）优先调度的算法。短作业优先(SJF)调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程优先(SPF)调度算法，则是从就绪队列中选...
短进程优先算法(C,Java实现)
ZLY2230530082的博客
10-26 5637
短进程优先算法(C,Java实现)
进程调度优先级JAVA_进程调度算法之短进程优先（Java）
weixin_36221948的博客
02-16 284
进程类：import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Comparator;import java.util.Date;public class Process implements Comparable {private String mName; //线程名 userpriv...
操作系统常用作业进程调度算法（Java模拟）
炎溟墨的博客
08-08 4259
文章目录什么是作业调度什么是进程调度FCFS(先来先服务调度算法)SJF（短作业优先调度算法）HRRN(高响应比优先调度算法)优先级调度算法RR(时间片轮转调度算法)多级反馈队列调度算法代码分析节点代码创建与检查节点调度算法封装测试代码 什么是作业调度 根据JCB中的信息，检查系统中的资源是否能满足作业对资源的需求，以及按照一定的调度算法，从外存的后备队列中选取某些作业调入内存，并为他们创建进程，...
用java语言，模拟实现操作系统的进程调度算法，先来先服务，高优先级、高响应比、时间片轮转和短作业
qq_39487033的博客
01-06 8496
构思算法的实现过程。 ①先来先服务算法 一开始我从最简单的先来先服务开始想，既然要排序进程链表的执行顺序，肯定要将链表的头head作为参数传入到方法中。其次为了之后方便一次性检验多种算法，传入进来的head链表我不会对它进行任何改变。所以创建一个新链表head2用CreateHead方法将链表进行复制，这样我就可以拿head2这个复制品随便搞，也不会影响之后调用其他算法，因为head没变。 当我拿...
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俩个制图包
JAVA语言实现FCFS、SJF、HRRN三种算法进程调度
06-26
本项目通过JAVA编程语言实现了三种常见的进程调度算法：先来先服务(FCFS)、最短作业优先(SJF)和高响应比优先(HRRN)。下面将详细解释这些算法以及如何在JAVA中实现它们。 **先来先服务(FCFS)** FCFS是最简单的调度...
高响应比优先调度算法(HRRN)
04-30
java平台运行高响应比优先调度算法，如果响应比相同则短作业优先。输出进程工作顺序、调度时间、周转时间、带权周转时间、平均周转时间和平均带权周转时间。压缩带有测试案例
Java实现先来先服务与短作业优先
10-25
通过Java实现常用调度算法中的先来先服务和短作业优先
【C语言源代码】 操作系统-短进程优先-进程调度算法
02-10
C语言实现：短进程优先-进程调度算法 1. 采用“短进程优先”调度算法对五个进程进行调度。每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、到达时间、需要运行时间、已用CPU时间、进程状态等等。 2. 每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。重复以上过程，直到所要进程都完成为止。
java 先来先服务，短进程优先算法
04-29
java 先来先服务，短进程优先算法 ,有含精美界面
短作业优先(SJF)调度算法（Java实现）
热门推荐
世纪末的架构师的博客
05-30 1万+
文章目录前言一、短作业优先(SJF)算法是什么？二、短作业优先(SJF)算法分析三、代码实现1.引入库2.读入数据总结 前言 在实现了先来先服务（FCFS）算法之后能够明显的感觉到先来先服务算法将当前处于就绪队列队首的那个进程调度到运行状态。也就是说，先来先服务算法只考虑作业或进程进入就绪队列的时间先后，而不考虑它的下一个CPU周期的长短等其他因素。虽然先来先服务算法简单易行并且是一种非抢占式策略，但性能却不大好导致平均周转时间特别长。因此，在先来先服务的算法基础上提出了短作业优先(SJF)算法来改进先来
java实现排程算法_调度算法——短作业优先（java实现） | 学步园
weixin_39768695的博客
02-16 410
class A{class B{//内部类方便private String processname ;//s进程名private float arrivetime ;//到达时间private float servetime ;//服务时间private float finishtime ;//完成时间private float turnovertime ;//周转时间private float ...
一文弄懂操作系统原理算法之--调度算法
q1472750149的博客
12-16 5666
第三章：操作系统--调度算法 Tips: 各种调度算法的学习思路 算法思想 算法规则 这种调度算法是用于作业调度还是进程调度? 抢占式?非抢占式? 优缺点 是否会导致饥饿 1、先来先服务(FCFS) 1.1、概述 算法思想：主要从“公平”的角度考虑(类似于我们生活中排队买东西的例子)， 先请求 CPU 的进程首先分配到 CPU。当一个进程进入就绪队列时，它的 PCB 会被链接到队列尾部。当 CPU 空闲时，它会分配给位于队列头部的进程，并且这个运行进程从队列中移去。 算法规则：按照
多线程的那些事(2)进程和线程调度算法
公众号（猴子数据分析）
08-10 8879
调度算法是指：根据系统的资源分配策略所规定的资源分配算法，如任务A在执行完后，选择哪个任务来执行，使得某个因素（如进程总执行时间，或者磁盘寻道时间等）最小。对于不同的系统目标，通常采用不同的调度算法。 几个常用的操作系统进程调度算法。 1 先来先服务（队列） 先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调
Java多线程并发：进程调度算法
河湾
05-22 701
一 优先调度算法 1.先来先服务调度算法（FCFS） 当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队 列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用 FCFS 算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机，特点是：算法比较...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值