操作系统课程设计（包含进程调度和存储管理和详细注释等）

• 最终结果
  
  在每次的运行中，控制台会打印详细的执行信息，如下图
  

下面是代码

• 页面代码

public class Frame {
    //    private final int MEMORY_BLOCK_NUM = 100;
//    private final Memory[] memories = new Memory[MEMORY_BLOCK_NUM];
//    private final Vector LRUQueue = new Vector<>();
    // 每个页面的指令数量
    private final int INST_NUM_PER_PAGE = 3;
    // 指令总数
    private int allInstNums = 0;
    // 缺页次数
    private int lastPageNums = 0;
    // 内存分配指针
    private int memory_index = 0;

    private final JButton[] jButton = new JButton[5];
    private final JTextField[] addField = new JTextField[20];
    private final JFrame jFrame = new JFrame("进程调度和存储管理");
    // 面板
    JPanel jPanel1 = new JPanel();
    // 运行按钮
    private final JButton runButton = new JButton("运行选中进程");


    
// 初始化各个显示面板
    public void init() {
        jFrame.setSize(750, 600);
        jFrame.setLayout(null);
        jFrame.setLocationRelativeTo(null);
        initJPanel1();
        initJPanel2();
        initJPanel3();
        initJPanel4();
        initJPanel5();
        initJPanel6();
        runButton.addActionListener(event-> run());
        jFrame.add(jPanel1);
        jFrame.add(jPanel2);
        jFrame.add(jPanel3);
        jFrame.add(jPanel4);
        jFrame.add(jPanel5);
        jFrame.add(jPanel6);
        jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jFrame.setVisible(true);
    }
// 初试化面板一
    public void initJPanel1()
    public void initJPanel2 ()
    public void initJPanel3()
    public void initJPanel4()
    public void initJPanel6()
// 设置进程指令
    public void setInst(int num, PCB process)
// 给进程分配内存
    public void setMemoryForProcess(PCB process, int instNum)
//添加到队列中
    public void addQueue(String actionCommand)
// 结束进程
    public void endProcess()
// 改变运行进程中的数据
    public void changeRunProcessData()
// 清除页表数据
    public void clearPageTable()
// 刷新内存数据
    public void flushMemoryModel()
// 刷新页面数据
    public void flushPageTableModel()
// 刷新运行进程模型
    public void flushRunModel() {
    }
// 刷新就绪进程模型
    public void flushReadyModel()
// 刷新阻塞进程模型
    public void flushBlockModel()
    // 找到空闲内存
    public Memory isContainsAnyEmptyMemory()
// 显示内存
    public void showMemories()
// 查看当前内存
    public Memory findCurrMemory(PCB process, int page_number)
// 找到优先级最大的进程
    public PCB findMaxProcess()
// 检查阻塞队列
    public void checkBlock(String s)
// 运行指令
    public void runInst()
// 运行操作系统
    public void run() {
        for (int i = 0; i < blockQueue.size(); i++) {
            PCB blockProcess = blockQueue.get(i);
            Integer blockTime = blockProcess.getBlockTime();
            if (blockTime -1 == 0) {
                System.out.println("移除");
                System.out.println(readyQueue.size());
                readyQueue.add(blockProcess);
                System.out.println(readyQueue.size());
                blockQueue.remove(blockProcess);
            } else {
                blockProcess.setBlockTime(blockTime - 1);
            }
        }
        if (runProcess == null && readyQueue.size() == 0) {
            flushBlockModel();
            System.out.println("暂无可运行进程");
            return;

        }

//         找到最高优先级进程
        PCB pcb = findMaxProcess();
        if (pcb != null) {
            if (runProcess == null) {
                runProcess = pcb;
                readyQueue.remove(pcb);
            } else if (runProcess.getPriority() < pcb.getPriority()) {
                // 队列交换 start
                readyQueue.add(runProcess);
                readyQueue.remove(pcb);
                runProcess = pcb;
                // end
            }
        }
        Integer instNum = runProcess.getInstNum();
        if (instNum == 0) {
            System.out.println("指令执行完毕");
            endQueue.addElement(runProcess);
            runProcess = findMaxProcess();
            readyQueue.remove(runProcess);

        } else {
            for (PCB block : blockQueue) {
                if (block == runProcess) {
                    runProcess = findMaxProcess();
                    readyQueue.remove(runProcess);
                }
            }
        }
        System.out.println(““);
    }
}

• 指令代码

public class Instructions {
    public  List<String> instructions;
    public Instructions() {
        instructions = new ArrayList<>();
        instructions.add("READ");
        instructions.add("WRITE");
        instructions.add("INPUT");
        instructions.add("OUTPUT");

    }
    public List<String> getInstructions() {
        return instructions;
    }
}

• 内存代码

public class Memory {
    int id;
    int page;
    int state;
}

• 进程代码

public class PCB {
    // 进程唯一标识符
    private String id;
    // 进程优先级
    private Integer priority;
    // 进程需要的运行时间
    private Integer time;
    // 进程当前的指令数目
    private Integer instNum;
    // 进程总共的指令数目
    private Integer allInstNum;
    // 当进程进入阻塞状态后，阻塞的时间
    private Integer blockTime;
    // 进程的指令集
    private List<String> instList;
    // 进程的状态
    private String state;
    // 进程的页表
    private Map<Integer, Integer> pageTable;
    // 进程分配的内存块
    private Memory[] memories;
    // 用于LRU替换算法的队列
    private Vector<Memory> LRUQueue;
}

注：上面的代码由Java编写，由于篇幅限制，代码不完整，需要的评论区留言，可教学