如何用停止应用做一段时间(真实)

时间:2016-05-10 19:39:53

标签: java multithreading

我有一个应用程序,它有2个类(表单和执行)和2个按钮。使用第一个按钮,我将执行我想要执行的整个功能,我希望第二个按钮执行一部分功能。更确切地说,在我按下第二个按钮后,它将完成一部分功能,之后它将进入一段时间,并等待再次按下第二个按钮。那里的问题......当我按下第二个按钮时,我的所有程序都停止了。

表格类:

   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;
                }
            }
        }
    }
}

编辑:

我已尝试使用线程,但这不是我想要的。因为如果我将使用线程,它将执行整个功能。我需要的是......当我按下secondButton时,我想首先迈出这一步,我想在我再次按下它之后做j=j+1它会做到这一点再次j=j+1,依此类推。在它完成J之后它将需要我,依此类推。所有我想要的只是按时增加一个。只是它。并且线程不会帮助我。

2 个答案:

答案 0 :(得分:1)

您通过在主线程中运行来阻止执行。您需要将while循环移动到后台线程中。听起来您需要了解有关进程和线程如何工作的更多信息。我附上了Oracle的教程。

The Java Tutorials: Concurrency

答案 1 :(得分:0)

  

认真的家伙,我不知道如何解决它......

你必须以不同的方式构建程序。

您的secondButton(...)函数是事件处理程序。当您的应用程序启动时,它会创建一个名为事件调度线程(EDT)的新线程。 EDT运行循环;

  • 从操作系统接受键盘或鼠标输入(例如,事件),
  • 了解您的哪些处理人员对该事件感兴趣,
  • 调用您的处理程序,然后
  • 回去等待下一次活动。

在处理程序返回之前,EDT无法响应下一个事件。如果seconButton(...)永不返回(<{1}}中没有,那么您的程序永远不会能够响应另一次按键或鼠标点击。

你希望你的“第二个按钮”在第一次按下时启动,然后在第二次按下时完成。你要做的就是写你的case 2处理程序,知道它被按下了多少次,也许,知道是否该接受第二次按下。

如果第二次按下可能来得太早,那么你要么必须弄清楚用什么样的反馈给用户过早按,否则你会想要第一次按下禁用按钮,然后让其他线程重新启用它,当用户第二次按下按钮是有意义的。