Java 操作系统实验 时间片轮转法

学校布置作业，敲了好久代码，真的好累！

这里把时间片定为2 大家有需要的就参考参考 本人学艺不精.....

Main函数 调用方法

public class Main {
    public static void main(String[] args) {
        cal RR = new cal();
        RR.input();
    }
}

程序块类

public class pcb {
    private String name;
    private int needtime;

    int arrivetime = 0;
    private Integer cputime = 0;
    private String state;
    private int round = 0;
    private int count = 0;

    public pcb() {
    }

    public pcb(String name, int needtime) {
        this.name = name;
        this.needtime = needtime;

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNeedtime() {
        return needtime;
    }

    public void setNeedtime(int needtime) {
        this.needtime = needtime;
    }

    public Integer getCputime() {
        return cputime;
    }

    public void setCputime(Integer cputime) {
        this.cputime = cputime;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public int getRound() {
        return round;
    }

    public void setRound(int round) {
        this.round = round;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }





}

方法类

public class cal {
    public static void input() {
        Scanner sc = new Scanner(System.in);
        System.out.println("please input the number of processes:");
        int input = sc.nextInt();
        pcb[] pcb1 = new pcb[input];//创建pcb数组

        List Wait = new ArrayList<String>();     //创建等待队列

        List Ready = new ArrayList<String>();     //创建就绪队列

        List Done = new ArrayList<String>(); //创建完成队列

        List Sout = new ArrayList<String>();  //定义一个列表 用于排序

        System.out.println("input name and needtime:");
        int round = 2;//创建时间片大小
        int i;
        for (i = 0; i < input; i++) {
            String a = sc.next();//输入名字
            Sout.add(a);
            int b = sc.nextInt();//输入需要的时间
            pcb1[i] = new pcb(a, b);//创建数组  按照input的数量
        }

        pcb temp = new pcb();
        for (i = 0; i < input - 1; i++) {    //排列，按照arrivetime 先到达的排在前面
            int j;
            for (j = 0; j < input - 1 - i; j++) {
                if (pcb1[j].arrivetime > pcb1[j + 1].arrivetime)//冒泡排序
                {
                    temp = pcb1[j];
                    pcb1[j] = pcb1[j + 1];
                    pcb1[j + 1] = temp;
                }
            }
        }

        int nowtime = pcb1[0].arrivetime;  //现在的时间--直接从第一个pcb块到达的时间开始

        for (i = 0; i < input; i++) {
            if (pcb1[i].arrivetime >= nowtime) {         //如果现在的时间大于到达时间就进入就绪队列
                Ready.add(pcb1[i].getName());  //往就绪队列中添加名字
                pcb1[i].setState("W");//就绪队列的W
            } else {                                      //否则进入等待队列
                Wait.add(pcb1[i].getName());   //往等待队列中添加名字 String类型
                pcb1[i].setState("W");//等待队列的W
            }
        }

        //运行的次数等于？
        //当大家需要的时间都为0的时候，结束循环.
        while(true){
            check(input,Ready,Done,Sout,pcb1,round);
            int c = 0;//这是一个伟大的算法 先定义一个变量用于计数
            for (int j = 0; j < input; j++) {
                if(pcb1[j].getNeedtime()==0){
                    c+=1;//如果所有的时间块的needtime都为0了，就可以结束了
                }//顶级理解
            }

            if(c==input){
                break;
            }
        }





    }

    public static void check(int input,List Ready,List Done,List Sout,pcb[] pcb1,int round) {


        int r1 = 0;//把就绪队列中第一个抽出来 用于进入运行态
        int j;
        for (j = 0; j < input; j++) {
            if (Ready.get(0).equals(pcb1[j].getName())) {
                r1 = j;
            }


        }
        pcb1[r1].setState("R");//把状态设为R
        System.out.println("Name  cputime  needtime  count  round  state");   //输出排序后的进程
        for (j = 0; j < input; j++) {
            for (int i = 0; i < input; i++) {//遍历一下 取出与排列数组索引对应的程序块
                if (Sout.get(j).equals(pcb1[i].getName())){
                    System.out.print("  " + pcb1[i].getName() + "     ");//获取名字
                    System.out.print(pcb1[i].getCputime() + "      ");//获取占用cpu的时间
                    System.out.print(pcb1[i].getNeedtime() + "        ");//获取需要使用的时间
                    System.out.print(pcb1[i].getCount() + "         ");//获取使用cpu的轮数
                    System.out.print(round + "         ");//输出时间片
                    System.out.println(pcb1[i].getState());
                }
            }
        }

        Ready.remove(pcb1[r1].getName());//删除掉 就绪 队列中第一个
        Sout.remove(pcb1[r1].getName());//删除掉 排列 队列中对应就绪的元素 因为这个环节要用到他 后续要把它拿到第一位
        if(Ready.size()!=0){
            Sout.remove(Ready.get(0));//先把下一个要进入使用的删除
        }


        Integer realtime = 0;//定义一个变量 用于判断如果时间片没用完进程块就结束的情况 实际占用cpu的时间
        if (pcb1[r1].getNeedtime() - round >= 0) {
            realtime = round;
        } else if (pcb1[r1].getNeedtime() - round < 0) {
            realtime = pcb1[r1].getNeedtime();
        }

        pcb1[r1].setNeedtime(pcb1[r1].getNeedtime() - realtime);//设置还需要的时间 减去时间片

        if (realtime == round) {
            pcb1[r1].setCputime(pcb1[r1].getCputime() + round);

        } else if (realtime == 1) {                //设置Cpu占用时间
            pcb1[r1].setCputime(pcb1[r1].getCputime() + realtime);
        }


        if (pcb1[r1].getNeedtime() > 0) {
            Ready.add(pcb1[r1].getName());//如果需要时间仍然大于0 就重新添加回就绪队伍
            pcb1[r1].setState("W");
        } else {
            pcb1[r1].setState("F");
            Ready.remove(pcb1[r1].getName());
            Done.add(pcb1[r1].getName());
        }

        pcb1[r1].setCount(pcb1[r1].getCount() + 1);

        Sout.add(pcb1[r1].getName());
        if(Ready.size()!=0){
            Sout.add(0,Ready.get(0));//添加回去
        }



        System.out.println("就绪队列:" + Ready);
        System.out.println("完成队列:" + Done);

        if (Ready.size() == 0) {

            System.out.println("\n");
            System.out.println("最终结果:");
            System.out.println("Name  cputime  needtime  count  round  state");   //输出排序后的进程
            for (j = 0; j < input; j++) {
                for (int i = 0; i < input; i++) {//遍历一下 取出与排列数组索引对应的程序块
                    if (Sout.get(j).equals(pcb1[i].getName())){
                        System.out.print("  " + pcb1[i].getName() + "     ");//获取名字
                        System.out.print(pcb1[i].getCputime() + "      ");//获取占用cpu的时间
                        System.out.print(pcb1[i].getNeedtime() + "        ");//获取需要使用的时间
                        System.out.print(pcb1[i].getCount() + "         ");//获取使用cpu的轮数
                        System.out.print(round + "         ");//输出时间片
                        System.out.println(pcb1[i].getState());
                    }
                }
            }

            System.out.println("就绪队列:" + Ready);
            System.out.println("完成队列:" + Done);

        }
    }