进程调度模拟（操作系统实验，java，优先级抢占式时间片轮转进程调度）

 优先级抢占式时间片轮转进程调度（这里只贴了调度过程中时间分配和CPU执行方面的模拟代码，没有贴对应可视化的代码，但最下面贴了两张可视化展示图）

1、PriorTest.java文件：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;

/**
 * @Author: tengsen
 * @description: 优先级抢占式时间片轮转进程调度, 运行后的进程优先级降低，等待的进程优先级提高，
 * 无论运行中的进程优先级多高，这里设置为接下来调取的进程从等待的进程中选。用进程睡眠模拟进程运行时间。
 */
public class PriorTest {
    /*记录时第几次运行*/
    int number = 0;
    static Queue<PriorProject> finish = null;
    static LinkedList<PriorProject> priorProjects =null;

    public static void main(String[] args) throws Exception {
        /*已完成队列*/
         finish = new LinkedList();

        /*就绪队列*/
        priorProjects = new LinkedList();


        PriorTest priorTest = new PriorTest();

        /*用数组集合存从文件读取来的进程信息*/
        String filePath = "/priorProjectDetails.txt";
        ArrayList<String> projectDetails;
        projectDetails = priorTest.readFromTextFile(filePath);

        /*进程数量，规定了每两行字符串分别含进程信息的进程标识符和运行时间,数组集合大小除2即得进程数量*/
        int num = projectDetails.size() / 2;

        /*maxPrior存就绪队列中的最高优先级*/
        int maxPrior = 0;
        /*now存运行的进程索引*/
        int now = 0;

        System.out.println("加载所有程序:  ");
        for (int i = 0; i < num; i++) {
            PriorProject priorProject = new PriorProject();
            priorProject.setName(projectDetails.get(i * 2));
            priorProject.setRound(5);/*时间片设为5s,可修改为任意合适的值*/
            priorProject.setCputime(Integer.parseInt(projectDetails.get(i * 2 + 1)));
            priorProject.setNeentime(priorProject.getCputime());
            priorProject.setState("ready");/*初始化状态为就绪*/

            /*初始进程优先数定为一个较大的数（这里是50）减去进程运行所需要的时间*/
            priorProject.setPrior(50 - priorProject.getNeentime());
            priorProject.setCount(0);/*进程初始运行次数设为0*/
            priorProjects.add(i, priorProject);/*将初始化好的进程放入链表集合中*/
            System.out.println(priorProject.toString() + "已就绪");
            if (maxPrior < priorProject.getPrior()) {
                maxPrior = priorProject.getPrior();
                now = i;
            }
        }
        System.out.println("-----------------------------------------------------------------------------------------");

        while (finish.size() < num) {
            /*运行now标识的当前最高优先程序,然后运行当前程序*/
            PriorProject nowPriorProject = priorProjects.get(now);
            priorTest.runProject(nowPriorProject);
            boolean flag = true;/*利用flag标记,如果运行的进程还没运行完，最后运行结束要将其改回ready状态*/

            /*把运行完的程序添入完成队列*/
            if (nowPriorProject.getNeentime() == 0) {
                priorProjects.remove(nowPriorProject);
                nowPriorProject.setState("finished");/*将进程设置为完成状态*/
                finish.add(nowPriorProject);
                flag = false;
                System.out.println(nowPriorProject.getName() + "已完成,已移动至finish队列");
                System.out.println(nowPriorProject);
                System.out.println("-----------------------------------------------------------------------------------------");
            }
            if (finish.size() == num) {
                break;/*如果全部进程已执行完毕，跳出循环*/
            }
            /*增加就绪队列中进程的优先级*/
            for (int i = 0; i < num - finish.size(); i++) {
                if (priorProjects.get(i).getState().equals("ready")) {
                    PriorProject priorProject = priorProjects.get(i);
                    priorProject.setPrior(priorProject.getPrior() + priorProject.getRound());
                }
            }

            maxPrior = 0;

            /*从就绪队列中找到优先级最高的进程*/
            for (int i = 0; i < num - finish.size(); i++) {
                if (priorProjects.get(i).getState().equals("ready")) {
                    PriorProject priorProject = priorProjects.get(i);
                    if (maxPrior < priorProject.getPrior()) {
                        maxPrior = priorProject.getPrior();
                        now = i;
                    }
                }
            }

            /*将运行完的程序的状态设回就绪*/
            if (flag) {
                nowPriorProject.setState("ready");
            }
        }
        System.out.println("全部进程已运行结束，已完成进程按完成顺序排列:");
        while (finish.size() > 0) {
            System.out.print("第" + (num - finish.size() + 1) + "个:");
            PriorProject priorProject = finish.remove();
            System.out.println(priorProject.toString());
        }

    }

    /*读取文件，获取进程名和运行时间*/
    public ArrayList<String> readFromTextFile(String pathname) throws IOException {
        ArrayList<String> strArray = new ArrayList<String>();
        //PriorTest.class.getResourceAsStream(pathname)
        //PriorTest.class.getResourceAsStream(pathname)
        InputStreamReader reader = new InputStreamReader(PriorTest.class.getResourceAsStream(pathname));
        BufferedReader br = new BufferedReader(reader);
        String line = "";
        line = br.readLine();
        while (line != null) {
            strArray.add(line);
            line = br.readLine();
        }
        reader.close();/*关闭输入流*/
        return strArray;
    }

    public void runProject(PriorProject priorProject) throws Exception {
        priorProject.setState("running");
        System.out.println("第" + (++number) + "次运行进程，本次运行的进程是：" + priorProject.getName() + "(" + priorProject.getState() + ")");
        System.out.print("运行前： ");
        priorProject.setState("beforeRunning");
        System.out.println(priorProject.toString());

        /*如果运行后时间>=0则按正常处理，如果<0说明时间片用不完，应提前终止*/
        /*用actualRunTime记录实际运行时间*/
        int actualRunTime = (priorProject.getNeentime() - priorProject.getRound()) >= 0 ? priorProject.getRound() : priorProject.getNeentime();
        priorProject.setNeentime(priorProject.getNeentime() - actualRunTime);

        /*通过线程睡眠模拟实际运行实间*/
        System.out.println("运行中: running------" + "实际运行时间:" + actualRunTime + "s");
        Thread.sleep(actualRunTime * 1000);
        priorProject.setCount(priorProject.getCount() + 1);

        /*修改当前进程的优先级*/
        priorProject.setPrior(priorProject.getPrior() - priorProject.getRound());
        System.out.print("运行后:  ");
        priorProject.setState("afterRunning");
        System.out.println(priorProject.toString());

//        PriorKeShiHuaJava priorKeShiHuaJava = new PriorKeShiHuaJava.ClassTemp().backBorderPane();
//        Stage stage = new PriorKeShiHuaJava.StageTemp().backStage();
//        Scene scene = new PriorKeShiHuaJava.SceneTemp().backScene();
//        priorKeShiHuaJava.repaint(stage,scene,new BackClass().backData());
//        PriorKeShiHuaJava priorKeShiHuaJava = new PriorKeShiHuaJava.ClassTemp().backBorderPane();
//        priorKeShiHuaJava.repaint(new BackClass().backData());
        System.out.println("-----------------------------------------------------------------------------------------");
    }

    static class BackClass{
        LinkedList<PriorProject> backProjects=null;
        public BackClass(){
            backProjects = new LinkedList<>();
            Iterator<PriorProject> iterator = finish.iterator();
            Iterator<PriorProject> iterator1 = priorProjects.iterator();

            while (iterator.hasNext()){
                backProjects.add(iterator.next());
            }
            while (iterator1.hasNext()){
                backProjects.add(iterator1.next());
            }
        }
        public LinkedList<PriorProject> backData(){

            return backProjects;
        }
    }
}

/*当前pcb,输出pcb内容,更改*/
class PriorProject {
    private String name; /*进程标识符*/
    private int prior; /*进程优先级*/
    private int round; /*进程时间片轮转时间片*/
    private int cputime; /*进程占用CPU所需要的时间*/
    private int neentime; /*进程到完成还需要的时间*/
    private int count; /*计数器*/
    private String state;/*ready就绪,running运行，beforeRunning运行前,afterRunning运行后,finished完成*/

    public String getName() {
        return name;
    }

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

    public int getPrior() {
        return prior;
    }

    public void setPrior(int prior) {
        this.prior = prior;
    }

    public int getRound() {
        return round;
    }

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

    public int getCputime() {
        return cputime;
    }

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

    public int getNeentime() {
        return neentime;
    }

    public void setNeentime(int neentime) {
        this.neentime = neentime;
    }

    public int getCount() {
        return count;
    }

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

    public String getState() {
        return state;
    }

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

    @Override
    public String toString() {
        return "Project{" +
                "name='" + name + '\'' +
                ", 当前优先级: " + prior +
                ", 时间片: " + round + "s" +
                ", CPU总共需执行时间: " + cputime + "s" +
                ", 还需要的执行时间: " + neentime + "s" +
                ", 已执行的次数: " + count +
                ", 进程状态: '" + state + '\'' +
                '}';
    }
}

2、 priorProjectDetails.txt文件：

Project1
12
Project2
10
Project3
15
Project4
5

 

3、 运行结果截图：

 4、可视化效果图