给自个儿多或多或少时刻,动态高优先权算法

时间该给我多一点记忆在岁月的留痕里寻找我来时的路时间该给我多一点留恋记住每一个模糊了的面庞和所有美好过往时间该给我一点的等待也许我们都会成梦里的自己在梦外我只是我时间给不了多余的等待

算法原理

一些进程先后到达,到达有被加入等待队列,每次从等待队列中挑出一个优先级最高的进程执行一个时间片,执行完后该进程剩余执行时间-1、优先级-2,回到等待队列,再从等待队列中挑出一个优先级最高的进程执行一个时间片······ 直到所有进程被执行完。

进程参数:进程名、到达时间、服务时间、优先级

进程状态:未到达、执行、等待、执行完

进程行为(每个时间片):到达等待队列、执行一个时间片、执行完回到等待队列、执行完被销毁(服务时间为0)

等待

版权作品,未经《短文学》书面授权,严禁转载,违者将被追究法律责任。

算法演示

import java.util.Scanner;
import java.util.Arrays;
import java.math.*;

public class Main {

    static class Process implements Comparable<Process>{
        String name;            //进程标示
        int arrivetime;         //到达时间
        int servicetime;        //服务时间
        int servicetime2;       //服务时间副本
        int finishtime;         //完成时间
        int turnovertime;       //周转时间
        int priority;           //优先级

        public Process(String name, int arrivetime, int servicetime, int priority){
            //构造方法
            //参数:进程名、到达时间、服务时间、优先级
            this.name = name;
            this.arrivetime = arrivetime;
            this.servicetime = servicetime;
            this.servicetime2 = servicetime;
            this.priority = priority;
        }

        public void diaoyong(){
            //每执行一次进程,调用一次,更新进程的  服务时间  和  优先级
            this.servicetime -= 1;
            this.priority -= 2;
            if( servicetime <= 0 ){
                priority = -1000;
            }
        }

        //排序函数的比较函数
        //按照优先级从高到底排序,优先级相同,按照到达时间从低到高排序
        public int compareTo(Process o) {  
            if(this.priority > o.priority){  
                return -1;  
            }else if(this.priority < o.priority){  
                return 1;  
            }
            else{
                if(this.arrivetime < o.arrivetime){
                    return -1;
                }
                else{
                    return 0;
                }
            }
        } 
    }

    public static void main(String[] args) {
        Process[] p = new Process[10];
        System.out.println("||动态高优先权调度||");
        System.out.println("-----------------------");

        //进程参数
        p[0] = new Process("j1", 0, 5, 4);
        p[1] = new Process("j2", 1, 2, 3);
        p[2] = new Process("j3", 3, 3, 9);
        p[3] = new Process("j4", 4, 2, 2);
        p[4] = new Process("j5", 6 ,1, 6);

        //开始调度
        int t = 0;      //程序已运行的时间片数量
        int l1 = 0;     //当前处于运行和暂停状态的作业数量
        int l2 = 5;     //剩余未参加的进程数量
        int l3 = 0;     //已经执行完的进程数量
        int leng = 5;   //总进程数量
        for( ; l3!=leng; t++ ){
            //从数组中找出到达的作业
            for(int i=l1; i<leng; i++){
                if( p[i].arrivetime == t ){
                    l1++;
                    l2--;
                }
            }

            //找到到达作业中,优先级最高的进程
            //将优先级最高的进程,放到“执行/等待队列”的第一位
            Arrays.sort(p, l3, leng-l2);

            //执行该进程
            p[l3].diaoyong();

            //输出当前时间片进程执行信息
            System.out.print("当前执行时间片"+t+"当前执行进程:" + p[l3].name + "等待执行进程:");
            for( int i=l3+1; i<leng-l2; i++){
                System.out.print(p[i].name + " ");
            }
            System.out.println();

            //判读该进程是否执行完了
            if( p[l3].servicetime <=0  ){
                p[l3].finishtime = t;
                p[l3].turnovertime = p[l3].finishtime - p[l3].arrivetime;
                l3++;
                l1--;
            }

        }
        for( int i=0; i<leng; i++){
            System.out.println("作业名:"+p[i].name+"   到达时间:"+p[i].arrivetime+"    服务时间:"+p[i].servicetime2+"  完成时间:"+p[i].finishtime+"    周转时间:"+p[i].turnovertime);
        }
        System.out.println("算法完成");

    }
}

1

“我只要在等等,也许他就会回心转意呢?”,“我想再等等她。”、“等他发现我好的时候,自然会回来找我的。”……你的身边肯定有这样的一些人,愿意付出大量的时间去等待一个人,或许你也是其中的一个。这里,我将等待限定为了等待一个人,并不是限定等待的范围,而是等待一个人往往最能体现出等等待这个词的含义。

测试结果

2

我从未怀疑过“等待”这个词的价值,即使这个词令我失望过多次,但是我依旧坚信着等待的各种可能性。或许正是因为存在这样的一种可能性,才使等待这个词变得具有价值。但是,在这里我还是想给观看这篇文章的你泼一点冷水:人生有太多的事,是你争取不来、改变不了的。你所谓的等待,只是为了某种可能性,换句话说,你所谓的等待是你用来摆脱对于某件事无力感的唯一方式。

||动态高优先权调度||

当前执行时间片0当前执行进程:j1等待执行进程:
当前执行时间片1当前执行进程:j2等待执行进程:j1
当前执行时间片2当前执行进程:j1等待执行进程:j2
当前执行时间片3当前执行进程:j3等待执行进程:j2j1
当前执行时间片4当前执行进程:j3等待执行进程:j4j2j1
当前执行时间片5当前执行进程:j3等待执行进程:j4j2j1
当前执行时间片6当前执行进程:j5等待执行进程:j4j2j1
当前执行时间片7当前执行进程:j4等待执行进程:j2j1
当前执行时间片8当前执行进程:j2等待执行进程:j1j4
当前执行时间片9当前执行进程:j1等待执行进程:j4
当前执行时间片10当前执行进程:j4等待执行进程:j1
当前执行时间片11当前执行进程:j1等待执行进程:
当前执行时间片12当前执行进程:j1等待执行进程:
作业名:j3 到达时间:3 服务时间:3 完成时间:5 周转时间:2
作业名:j5 到达时间:6 服务时间:1 完成时间:6 周转时间:0
作业名:j2 到达时间:1 服务时间:2 完成时间:8 周转时间:7
作业名:j4 到达时间:4 服务时间:2 完成时间:10 周转时间:6
作业名:j1 到达时间:0 服务时间:5 完成时间:12 周转时间:12
算法完成

3

这个世界上有千种等待,但最好的是来日可期。我相信着在车水马龙过后总会有寂静之时、城市白日繁华也会在黑夜变得沉静,这些是可期的,而等待的矛盾点却又是亮点的地方就在于:等待本身是没有时间限制的,但等待的最好方式确实来日可期;这本身就是矛盾的,但却因此让更多人选择了等待。让我们折中一下,等待一件事是有确定的时间的,你5年后肯定能出名付出时间去等待,但如果这个已确定的时间长到连你自己都产生了怀疑、时间长到连你最初选择等待的理由都忘却了、时间长到连你自己都看不清了的时候,这份等待值得么?

代码解释

这个代码我没有用复杂的数据结构,而是用了一个数组,所以过程比较复杂。

其实可以使用三个数组,分别存放 未到达的进程 执行/等待的进程 执行完的进程 ,由于这三者数量和是已知的,所以我就合并到了一个数组里,这个数组,最左边存放执行完的进程 (假如有的话),最右边存放未到达的进程 ,中间存放执行/等待的进程 ,用 l1 l2 l3 来控制每个时间片的循环。

如果需要进一步优化的话,可以将数组换成链表,那样,每个到达的进程插入到合适的位置,每个时间片执行链表的第一个进程,然后插入到链表合适的位置,知道链表没有进程。

4

我等过一个于我非常重要的一个人,等了非常久,不论她发生了什么我都对自己说:“再等等吧,总会等到她的。” 在这等待的过程中,我却开始变得逐渐动摇了起来,时间长到已经忘记了呢个人的音貌、长到我自己都忘了等待的初衷,这也是我第一次对等待这个词产生了怀疑,也是第一次让我意识到这个世界暗自形成的规则:并不是所有的等待都会有结果!

5

我这里所提及的等待并不是伫立在原地、两手空空的状态,而是在不断提升自己的同时仍然维持内心的坚守。即使是这样的等待,也摆脱不了这个世界形成的束缚。这份等待,值得么?

6

我深知有些人穷尽一生可能都等不到花开的时候,所以我对我等待的人的要求可以用大冰老师的一句话来概括:若有缘再聚,给个微笑就好;若无缘再聚,别忘了我就行。而此时的等待就已经成为即使没有结果也能坦然接受的状态,回到之前的问题:这份等待,值得么?
不论你的回答是继续也好还是放弃也罢,其实还是在看自己。若是放弃等待,则是一种“我去摘你想要的星星,但想了想还是算了,因为我碰得到星星,却碰不到你。”;若是继续等待,说明这个人对你已经不是能用利益去衡量的了,等待这个词在他们的严重虽然用期限来定义,却远远超越了时间的概念。

7

笔者呢?可能还是会选择后者,即使知道人生的确有很多时候会等不到花开,但对我来说:等待花开的时候却会使我极尽自己的想象绘编花盛开时候的所有美丽……

本文由11选5走势图发布于教育房产,转载请注明出处:给自个儿多或多或少时刻,动态高优先权算法

相关阅读