java实现中断的模拟 中断的发现应该是硬件的工作，这里在函数CPU中加检测PSW的方式来模拟 在CPU（）函数中，每执行一条指令之前，先检查PSW，判断有无中断，若有进行中断处理，然后再运行解释指令。 CPU函数应该不断循环执行的。 可以建立一个闲逛进程idle （语句x=0，gob；gob表示回到第一句//修改pc值，cpu多解释一条语句） 进程进入就绪队列判断正在运行进程是否为idle，是则转向进程调度 进程调度无就绪进程选择时选择闲逛进程idle While(条件） { CPU(); } 模拟中断的种类和中断处理方式： 程序结束（执行指令end形成的中断，软中断）：调用进程撤销原语撤销进程，然后进行进程调度； I/O中断（对应阻塞进程设定时间到）：将输入输出完成的进程唤醒。 时钟中断：进程时间片用完，正在运行的进程转为就绪，重新进程调度 相对时钟的模拟 用相对时钟用于时间片的中断，寄存器TIME 主存的模拟大小512的字符数组或128*4的字符数组

实现中断的模拟需要考虑到多个方面，包括中断的种类、中断的触发方式、中断的处理流程等。以下是一些可能的实现思路和代码示例：

1. 中断种类和触发方式

在模拟中断时，可以考虑三种不同的中断类型：程序结束中断、I/O 中断和时钟中断。其中，程序结束中断是软中断，需要在程序执行结束时显式触发；I/O 中断可以通过设置阻塞进程的等待时间来触发；时钟中断则可以通过设定时间片来触发。

在 CPU() 函数中，可以在每次执行指令之前都检查 PSW 寄存器，确认是否有中断需要处理。如果有，就进行相应的中断处理；否则，继续解释指令。

2. 中断处理流程

中断处理流程需要根据不同类型的中断来定制。例如，程序结束中断需要撤销当前进程并进行进程调度；I/O 中断需要唤醒阻塞的进程，让它们重新进入就绪队列；时钟中断则需要将当前进程转入就绪状态，并进行进程调度。

以下是一个示例代码，展示了如何在 Java 中实现基于相对时钟的进程调度和中断模拟。在这个示例中，使用了一个简单的进程控制块 PCB 类，用于描述进程的状态和属性。另外，定义了一个全局的进程列表 procList，用于存储所有的进程。

// 进程控制块类
class PCB {
    public int pid;  // 进程 ID
    public int pc;  // 程序计数器
    public int timeLeft;  // 剩余时间片
    public int state;  // 进程状态（0：就绪，1：运行，2：阻塞，3：结束）
    
    public PCB(int pid, int pc, int timeLeft, int state) {
        this.pid = pid;
        this.pc = pc;
        this.timeLeft = timeLeft;
        this.state = state;
    }
}

// 进程列表
List<PCB> procList = new ArrayList<>();

// 初始化进程列表
procList.add(new PCB(0, 0, 5, 1));  // 进程0：运行状态，时间片为5
procList.add(new PCB(1, 0, 0, 0));  // 进程1：就绪状态，无时间片
procList.add(new PCB(2, 0, 0, 0));  // 进程2：就绪状态，无时间片
procList.add(new PCB(3, 0, 0, 0));  // 进程3：就绪状态，无时间片

// 中断处理函数
public static void handleInterrupt(int type) {
    switch (type) {
        case 0:  // 程序结束中断
            PCB curProc = procList.get(0);
            curProc.state = 3;  // 结束状态
            procList.remove(0);  // 从进程列表中移除
            schedule();  // 进程调度
            break;
        case 1:  // I/O 中断
            // 唤醒阻塞的进程
            for (PCB pcb : procList) {
                if (pcb.state == 2 && pcb.timeLeft == 0) {
                    pcb.state = 0;  // 就绪状态
                }
            }
            break;
        case 2:  // 时钟中断
            PCB curProc = procList.get(0);
            curProc.timeLeft--;  // 时间片减一
            if (curProc.timeLeft == 0) {
                // 时间片用完，进程转为就绪状态
                curProc.state = 0;
                schedule();  // 进程调度
            }
            break;
        default:
            break;
    }
}

// 进程调度函数
public static void schedule() {
    // 判断当前进程是否为 idle 进程
    if (procList.get(0).pid == -1) {
        // 如果是，直接选择就绪队列中的第一个进程
        procList.remove(0);
        procList.get(0).state = 1;  // 运行状态
        procList.get(0).timeLeft = 5;  // 时间片重置
        return;
    }
    
    // 选择一个就绪进程
    PCB nextProc = null;
    for (PCB pcb : procList) {
        if (pcb.state == 0) {
            nextProc = pcb;
            break;
        }
    }
    if (nextProc == null) {
        // 就绪队列为空，选择 idle 进程
        nextProc = procList.get(0);
        nextProc.timeLeft = 5;  // 时间片重置
    }
    
    // 将当前运行进程转为就绪状态
    procList.get(0).state = 0;
    
    // 将就绪进程移动到队首，并设置为运行状态
    procList.remove(nextProc);
    procList.add(0, nextProc);
    nextProc.state = 1;
}

// CPU 函数
public static void CPU() {
    PCB curProc = procList.get(0);
    int opcode = getOpcode(curProc.pc);
    switch (opcode) {
        case 0:  // end 指令
            handleInterrupt(0);  // 触发程序结束中断
            break;
        case 1:  // I/O 指令
            curProc.timeLeft = 3;  // 设置 I/O 时间
            curProc.state = 2;  // 阻塞状态
            handleInterrupt(1);  // 触发 I/O 中断
            schedule();  // 进程调度
            break;
        default:  // 其他指令
            curProc.pc++;  // 程序计数器加一
            curProc.timeLeft--;  // 时间片减一
            if (curProc.timeLeft == 0) {
                // 时间片用完，进程转为就绪状态
                curProc.state = 0;
                schedule();  // 进程调度
            }
            break;
    }
}

// 主函数
public static void main(String[] args) {
    // 初始化 idle 进程
    procList.add(new PCB(-1, 0, 5, 1));
    
    // 模拟 CPU 循环
    while (true) {
        CPU();
    }
}

在这个示例中，使用了一个相对时钟来实现时间片的中断。在每次 CPU() 函数执行完一条指令后，都会检查当前进程的时间片是否用完。如果用完了，就将当前进程转为就绪状态，并进行进程调度。同时，如果有其他类型的中断需要处理，也会在此时进行处理。另外，进程调度函数 schedule() 会根据当前就绪进程的情况，选择一个进程进行运行。如果就绪进程为空，就会选择一个 idle 进程来运行。