Java 如何在不停应用的情况下创造一段时间（真实）

我有一个应用程序，它有两个类（表单和执行）和两个按钮。使用第一个按钮，我将执行我希望执行的整个函数，我希望第二个按钮执行函数的一部分。更确切地说，在我按下第二个按钮后，它将完成部分功能，然后它将输入一个while true并等待再次按下第二个按钮。问题是。。。当我按下第二个按钮时，我所有的程序都停止了

表格类别：

   new Thread() {
        @Override
        public void run() {
            debugChecker = 1;
            exection(microCode);
            debugChecker = 2;
        }
    }.start();

执行类：

   public static void exection(List<List<String>> microCode) {
   for (int i = 0; i < microCode.size(); i++) {
        OUTER:
        for (int j = 0; j < microCode.get(i).size(); j++) {
            STEP:
            {
                aluValue.setText(microCode.get(i).get(2));
                String curentFunction = microCode.get(i).get(j);
                switch (curentFunction) {
                    case "IF":
                        try {
                            check = true;

                            Method m = Registers.class.getMethod(microCode.get(i).get(j + 1));
                            boolean condition = (boolean) m.invoke(new Registers());
                            if (condition) {
                                if (!microCode.get(i).get(j + 2).equals("STEP")) {
                                    String adr2 = microCode.get(i).get(j + 3);
                                    String jump_adr = JUMPI(adr2);
                                    microCode = UCODE.get(jump_adr);

                                    if (jump_adr.matches("INT|CALL|NOT_RD|RET|RETI|IM_D|IM_S")) {
                                        memoryOffset = offset;
                                    } else {
                                        memoryOffset = 0;
                                    }
                                    exection(microCode);
                                    return;
                                } else if (microCode.get(i).get(j + 2).equals("STEP")) {
                                    i++;
                                    j = -1;
                                    break STEP;
                                }
                            }
                            if (microCode.get(i).get(j + 2).equals("STEP")) {
                                j = j + 2;
                            } else {
                                j = j + 3;
                            }
                        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
                            Logger.getLogger(ExecutionMicroInstruction.class.getName()).log(Level.SEVERE, null, ex);
                        }
                        break;
                    case "ELSE":
                        if (microCode.get(i).get(j + 1).equals("STEP")) {
                            j += 1;
                            break OUTER;
                        } else if (JMP(microCode.get(i).get(j + 2)).equals("IFCH")) {
                            return;
                        } else {
                            String adr3 = microCode.get(i).get(j + 2);
                            String jump_adr3 = JUMPI(adr3);
                            microCode = UCODE.get(jump_adr3);

                            getCurentOperation(jump_adr3);

                            exection(microCode);
                            return;
                        }
                    case "STEP":
                        check = true;
                        break;
                    case "JUMPI":
                        check = true;
                        String instr2 = microCode.get(i).get(j + 1);
                        String address = JUMPI(instr2);
                        microCode = UCODE.get(address);

                        getCurentOperation(address);
                        if (address.matches("INT|CALL|NOT_RD|RET|RETI|IM_D|IM_S")) {
                            memoryOffset = offset;
                        } else {
                            memoryOffset = 0;
                        }
                        exection(microCode);
                        return;
                    case "JMP":
                        check = true;
                        if (JMP(microCode.get(i).get(j + 1)).equals("IFCH")) {
                            return;
                        }
                        microCode = UCODE.get(JMP(microCode.get(i).get(j + 1)));

                        getCurentOperation(JMP(microCode.get(i).get(j + 1)));
                        System.out.println("---" + JMP(microCode.get(i).get(j + 1)) + "---");

                        exection(microCode);
                        return;
                    default:
                        switch (debugChecker) {
                            case 0: {
                                String instruction = microCode.get(i).get(j);
                                List<String> list = microCode.get(i);
                                try {
                                    if (check) {
                                        mergeImagesByName(list);
                                        check = false;
                                    }
                                    Method instr = Registers.class.getMethod(instruction);
                                    instr.invoke(new Registers());
                                } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
                                    Logger.getLogger(ExecutionMicroInstruction.class.getName()).log(Level.SEVERE, null, ex);
                                }
                                break;
                            }
                            case 1: {
                                String instruction = microCode.get(i).get(j);
                                try {
                                    mergeJustOneElemOnTime(instruction);
                                    Method instr = Registers.class.getMethod(instruction);
                                    instr.invoke(new Registers());
                                    debugChecker = 2;
                                    System.out.println(instruction);

                                } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
                                    Logger.getLogger(ExecutionMicroInstruction.class.getName()).log(Level.SEVERE, null, ex);
                                }
                                break;
                            }
                            case 2: {
                                while (debugChecker == 2) {
                                }
                            }
                            default:
                                break;
                        }
                        break;
                }
            }
        }
    }
}

公共静态无效执行（列表微码）{
对于（int i=0；i