操作系统常用作业进程调度算法（Java模拟）

什么是作业调度

根据JCB中的信息，检查系统中的资源是否能满足作业对资源的需求，以及按照一定的调度算法，从外存的后备队列中选取某些作业调入内存，并为他们创建进程，分配必要的资源，然后再将新创建的进程排在就绪队列上等待调度。因此，也把作业调度称为接纳调度。

什么是进程调度

当计算机系统处于就绪状态的用户进程数多于CPU数时，就会产生多个进程或线程同时竞争CPU的结果。假设现在只有一个CPU可用，那么操作系统就必须选择一个进程运行，并把处理机分配给该进程。

FCFS(先来先服务调度算法)

算法思想	算法规则	适用调度类型	是否可以抢占	优点	缺点	是否会饥饿
主要从公平的角度考虑	按照作业/进程到达的先后顺序进行调度，即：优先考虑在系统中等待时间最长的作业	进程调度和作业调度	非抢占式算法	满足公平原则，且算法容易实现，比较利于长作业进程	排在长进程后的短进程的等待时间大，而且带权周转时间大，不利于短作业进程	不会

SJF（短作业优先调度算法）

算法思想	算法规则	适用调度类型	是否可以抢占	优点	缺点	是否会饥饿
实际上，短进程作业在实际情况中占有很大比例，为了使得它们优先执行，追求最少的平均等待时间、平均周转时间、平均带权周转事件	要求服务时间最短的作业进程优先得到服务	进程调度和作业调度	非抢占式算法	可以得到最少的平均等待时间，平均周转时间，平均带权周转时间	不公平，对长作业不友好，对短作业友好	会，短作业优先可能导致长作业一直得不到处理

HRRN(高响应比优先调度算法)

算法思想	算法规则	适用调度类型	是否可以抢占	优点	缺点	是否会饥饿
综合考虑等待时间和运行时间	在每次调度时，先计算各个作业进程的优先权：优先权=响应比=（等待时间+要求服务时间）/要求服务时间=响应时间/要求服务时间	进程调度和作业调度	非抢占式算法	综合考虑了等待时间和要求服务时间，在等待时间相同时，要求服务的时间越短，其优先权越高，拥有SJF算法的优点，在要求服务时间相同时，作业的优先权决定于其等待时间，等待时间越长，其优先权越高，拥有FCFS算法的优点	需要计算优先权，增加了系统的开销	不会

优先级调度算法

算法思想	算法规则	适用调度类型	是否可以抢占	优点	缺点	是否会饥饿
根据任务的紧急程度进行调度	调度时选择优先级最高的作业/进程，为其分配处理机	进程调度、作业调度、I/O调度	抢占式算法和非抢占式算法	用优先级区分任务的紧急程度，适用于实时操作系统。	如果有源源不断的高优先级进程到来，那么低优先级的进程可能会饥饿	会

1、优先级是利用某一范围内的整数来表示的，又把该整数称为优先数（优先数的大小并不一定和优先级成正比）。确定优先级大小的依据如下;

• 进程类型
• 进程对资源的需求
• 用户要求

2、优先级的类型有两种：

• 静态优先级：在创建进程时确定的，在进程的整个运行期间保持不变。虽然静态优先级简单易行，系统开销小，但是不够精确，可能会出现优先级低的进程长期没有被调度的情况。
• 动态优先级：在创建程序之初，先赋予其一个优先级，然后其值随进程的推进或者等待时间的增加而改变，以获得更好的调度性能。

RR(时间片轮转调度算法)

算法思想	算法规则	适用调度类型	是否可以抢占	优点	缺点	是否会饥饿
公平的、轮流的为各个进程服务，让每个进程在一定时间间隔内都可以得到响应	系统根据FCFS策略，将所有的就绪进程排成一个就绪队列。轮流让各个进程执行一个时间片的，若进程未在一个时间片内执行完，则被剥夺处理机，将进程放到就绪队列队尾重新排队。	进程调度	抢占式算法	公平、响应快，适用于分时操作系统	由于高频率的进程切换，增加了开销，并且它不区分任务的紧急程度	不会

• 时间片过小：有利于短作业，因为它能在该时间片内完成，但是，意味着频繁的执行进程调度和进程上下文的切换，增加系统的开销。即：退化为短作业优先算法 。
• 时间片过大：每个进程都能在一个时间片内完成，即退化为FCFS算法。

多级反馈队列调度算法

算法思想	算法规则	适用调度类型	是否可以抢占	优点	缺点	是否会饥饿
对以上调度算法的权衡和弥补	1、设置多个就绪队列，各级队列的优先级由高到低，时间片从小到大；2、新进程到达时先进入第一级队列，按照FCFS的原则排队等待被分配时间片，若时间片已经用完进程还没结束，则进程进入下一级队尾，如果此时进程已经在最低一级的队列，则将其重新放回该队列的队尾；3、只有第k级队列为空时，才会为第k+1级队列分配时间片	进程调度	抢占式算法，当第k级队列在运行过程中，若更上级的队列到来了一个新进程，由于优先级问题，新进程会抢占处理机，并将原来运行的进程放回第k级队列的队尾	对各种类型的进程都比较公平，每个新到达的进程都会很快得到响应，短进程只用较少的时间就可以完成，不用估计进程的运行时间。	无	可能会导致饥饿，概率不大

代码分析

节点代码

class Node{
    String name;
    int priority;
    int runtime;
    int arrivaltime;
    int starttime;
    int endtime;
    int turntime;  //周转时间
    double dturntime;  //带权周转时间
    Node nextnode;
    int statu;
    int newarrival;
    int newruntime;

    public Node(String name,int priority,int runtime,int arrivaltime, int starttime, int endtime, int turntime, double dturntime){
        this.name = name;
        this.priority = priority;
        this.runtime = runtime;
        this.arrivaltime = arrivaltime;
        this.nextnode = null;
        this.starttime = starttime;
        this.endtime = endtime;
        this.turntime = turntime;
        this.dturntime = dturntime;
        this.newarrival = arrivaltime;
        this.newruntime = runtime;
    }

}

创建与检查节点

class Create{
    public Node createNode(Node head, String name, int priority, int runtime, int arrivaltime, int starttime, int endtime, int turntime, double dturntime){

        if(head == null){
            Node node = new Node(name,priority,runtime,arrivaltime,starttime,endtime,turntime,dturntime);
            head = node;
            return head;
        }
        Node cur = head;
        while(cur.nextnode!=null){
            cur = cur.nextnode;
        }
        Node node = new Node(name,priority,runtime,arrivaltime,starttime,endtime,turntime,dturntime);
        cur.nextnode = node;
        return head;
    }

    public void check(Node head){
        if(head == null){
            System.out.println("当前没有节点信息");
            return;
        }
        Node cur = head;
        while(cur!=null){
            System.out.println("名字:"+cur.name+"、优先级:"+cur.priority+"、运行时间:"+cur.runtime+"、到达时间"+cur.arrivaltime);
            cur = cur.nextnode;
        }
    }
}

调度算法封装

class Algorithm{
    private Node pre = null;
    private Node prev = null;
    private Node min = null;
    private int num = 0;
    private int start = 0;
    private double nums = 0.0;
    private int count = 0;
    private static Create create = new Create();
    private static Node CreateHead(Node head){
        Node head2 = null;
        Node cur = head;
        while(cur!=null){
            head2 = create.createNode(head2,cur.name,cur.priority,cur.runtime,cur.arrivaltime,cur.starttime,cur.endtime,cur.turntime,cur.dturntime);
            cur = cur.nextnode;
        }
        return head2;
    }

    private void endFun(){
        System.out.println("平均周转时间:" + (double) this.num / this.count + "平均带权周转时间:" + this.nums / this.count);
        this.start = 0;
        this.num = 0;
        this.nums = 0;
        this.count = 0;
    }

    private static Node toolMethod(Node min,Node prev,int start,Node head){
        min.starttime = start;
        min.endtime = min.starttime + min.runtime;
        min.turntime = min.endtime - min.arrivaltime;
        min.dturntime = (double) min.turntime / (double) min.runtime;
        System.out.println("名字:" + min.name + "、优先级:" + min.priority + "、运行时间:" + min.runtime + "、到达时间" + min.arrivaltime + "、开始时间:" + min.starttime + "、结束时间:" + min.endtime + "、周转时间:" + min.turntime + "、带权周转时间:" + min.dturntime);
        if (prev == null) {
            if (min.nextnode == null) {
                return null;
            }
            return min.nextnode;
        } else {
            prev.nextnode = min.nextnode;
        }
        return head;
    }

    private static Node findMin(Node head){
        Node cur = head;
        Node real = null;
        int mintime = cur.arrivaltime;
        while(cur!=null){
            if(cur.arrivaltime<=mintime){
                mintime = cur.arrivaltime;
                real = cur;
            }
            cur = cur.nextnode;
        }
        return real;
    }

    public void Fcfs(Node head) {
        Node head2 = CreateHead(head);
        while (head2 != null) {
            min = null;
            pre = null;
            Node cur = head2;
            int mintime = cur.arrivaltime;
            while (cur != null) {
                if (cur.arrivaltime <= mintime) {
                    mintime = cur.arrivaltime;
                    prev = pre;
                    min = cur;
                }
                pre = cur;
                cur = cur.nextnode;
            }
            if (min.arrivaltime > start) {
                start = min.arrivaltime;
            }
            head2 = toolMethod(min,prev,start,head2);
            start = start + min.runtime;
            num += min.turntime;
            nums += min.dturntime;
            count++;
        }
        this.endFun();
    }

    public void Priority(Node head){
        Node head2 = CreateHead(head);
        while(head2!=null){
            min = null;
            pre = null;
            Node cur = head2;
            int mintime = 0;
            while(cur!=null){
                if(cur.priority >= mintime && cur.arrivaltime <= start){
                    mintime = cur.priority;
                    prev = pre;
                    min = cur;
                }
                pre = cur;
                cur = cur.nextnode;
            }
            if(min == null){
                min = findMin(head2);
            }
            if(min.arrivaltime > start){
                start = min.arrivaltime;
            }
            head2 = toolMethod(min,prev,start,head2);
            start = start + min.runtime;
            num += min.turntime;
            nums += min.dturntime;
            count++;
        }
        this.endFun();
    }

    public void ShortProcess(Node head){
        Node head2 = CreateHead(head);
        while(head2!=null){
            min = null;
            pre = null;
            Node cur = head2;
            int mintime = 1000;
            while(cur!=null){
                if(cur.runtime <= mintime && cur.arrivaltime <= start){
                    mintime = cur.runtime;
                    prev = pre;
                    min = cur;
                }
                pre = cur;
                cur = cur.nextnode;
            }
            if(min == null){
                min = findMin(head2);
            }
            if(min.arrivaltime > start){
                start = min.arrivaltime;
            }
            head2 = toolMethod(min,prev,start,head2);
            start = start + min.runtime;
            num += min.turntime;
            nums += min.dturntime;
            count++;
        }
        this.endFun();
    }

    private static double resRatio(Node node,int start){
        int waittime = start - node.arrivaltime;
        return (double)waittime/node.runtime;
    }
    public void Hreponse(Node head){
        Node head2 = CreateHead(head);
        while(head2!=null){
            min = null;
            pre = null;
            Node cur = head2;
            double mintime = 0.0;
            while(cur!=null){
                double resratio = resRatio(cur,start);
                if(resratio >= mintime && cur.arrivaltime <= start){
                    mintime = resratio;
                    prev = pre;
                    min = cur;
                }
                pre = cur;
                cur = cur.nextnode;
            }
            if(min == null){
                min = findMin(head2);
            }
            if(min.arrivaltime > start){
                start = min.arrivaltime;
            }
            head2 = toolMethod(min,prev,start,head2);
            start = start + min.runtime;
            num += min.turntime;
            nums += min.dturntime;
            count++;
        }
        this.endFun();
    }

    public static Node QueueHead(Node head){
        Node cur = head;
        Node nodemin = null;
        Node head2 = null;
        int min = 1000;
        int count = 0;
        while(cur!=null){
            count++;
            cur = cur.nextnode;
        }
        while(count!=0) {
            min = 1000;
            cur = head;
            while (cur != null) {
                if (cur.arrivaltime < min && cur.statu == 0) {
                    nodemin = cur;
                    min = cur.arrivaltime;
                }
                cur = cur.nextnode;
            }
            nodemin.statu = 1;
            count--;
            head2 = create.createNode(head2,nodemin.name,nodemin.priority,nodemin.runtime,nodemin.arrivaltime,nodemin.starttime,nodemin.endtime,nodemin.turntime,nodemin.dturntime);
        }
        return head2;
    }

    public static void insert(Node head,Node min){
        Node cur = head;
        Node pre = null;
        while(cur!=null){
            if(cur.arrivaltime > min.newarrival){
                pre.nextnode = min;
                min.nextnode = cur;
                return;
            }
            pre = cur;
            cur = cur.nextnode;
        }
        pre.nextnode = min;
        min.nextnode = cur;
    }

    public void Roundrobin(Node head,int Rtime){
        Node newnode = null;
        Node head2 = QueueHead(head);
        create.check(head2);
        System.out.println(head2.newruntime);
        System.out.println(head2.newarrival);
        while(head2!=null){
            min = head2;
            if(min.arrivaltime > start){
                start = min.arrivaltime;
            }
            if(min.newruntime > Rtime){
                min.newruntime -= Rtime;
                start += Rtime;
                min.newarrival += Rtime;
                newnode = new Node(min.name,min.priority,min.runtime,min.arrivaltime,min.starttime,min.endtime,min.turntime,min.dturntime);
                newnode.newarrival = min.newarrival;
                newnode.newruntime = min.newruntime;
                insert(head2,newnode);
                head2 = min.nextnode;
            }else{
                start += min.newruntime;
                min.endtime = start;
                min.turntime = min.endtime - min.arrivaltime;
                min.dturntime = (double) min.turntime / (double) min.runtime;
                head2 = min.nextnode;
                num += min.turntime;
                nums += min.dturntime;
                count++;
                System.out.println("名字:" + min.name + "、优先级:" + min.priority + "、运行时间:" + min.runtime + "、到达时间" + min.arrivaltime + "、开始时间:" + min.starttime + "、结束时间:" + min.endtime + "、周转时间:" + min.turntime + "、带权周转时间:" + min.dturntime);
            }
        }
        this.endFun();
    }
}

测试代码

    public class Test {
    public static void dispatchMenu(Node head){

        Scanner sc = new Scanner(System.in);
        Algorithm al = new Algorithm();
        int count = 1;
        while(count == 1){
            System.out.println("请选择调度算法:");
            System.out.println("1.先来先服务算法");
            System.out.println("2.短作业优先算法");
            System.out.println("3.高优先级优先算法");
            System.out.println("4.高响应比优先算法");
            System.out.println("5.时间片轮转算法");
            System.out.println("0.退出");
            int num = sc.nextInt();
            switch(num){
                case 1:al.Fcfs(head);
                    break;
                case 2:al.ShortProcess(head);
                    break;
                case 3:al.Priority(head);
                    break;
                case 4:al.Hreponse(head);
                    break;
                case 5:al.Roundrobin(head,1);
                    break;
                case 0:count = 0;
                    break;
                default:System.out.println("输入错误请重新输入");
            }
        }
    }

    public static void mainMenu(){
        Create create = new Create();
        Node head = null;

        Scanner sc = new Scanner(System.in);

        int count1 = 1;
        while(count1 == 1){
            System.out.println("请选择你需要的服务:");
            System.out.println("1.添加新进程");
            System.out.println("2.使用调度算法进行排序");
            System.out.println("3.查看当前进程信息");
            System.out.println("0.退出");
            int num = sc.nextInt();
            switch(num){
                case 1:
                    String name;
                    int priority;
                    int runtime;
                    int arrivaltime;
                    System.out.println("请输入进程名字:");
                    name = sc.next();
                    System.out.println("请输入进程优先级:");
                    priority = sc.nextInt();
                    System.out.println("请输入进行运行时间:");
                    runtime = sc.nextInt();
                    System.out.println("请输入进程到达时间:");
                    arrivaltime = sc.nextInt();
                    head = create.createNode(head,name,priority, runtime,arrivaltime,0,0,0,0);
                    break;
                case 2:Test.dispatchMenu(head);
                    break;
                case 3:create.check(head);
                    break;
                case 0:count1 = 0;
                    break;
                default:System.out.println("输入错误请重新输入");
            }
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Test.mainMenu();
    }
}