Java中如何在事件调度器中同步Frame并等待菜单操作结果？

你的核心问题是非模态JFrame不会阻塞主线程，导致主线程还没等用户完成菜单操作就继续执行后续代码。下面给你三种实用的解决思路：

方案1：改用模态JDialog（最推荐） #

把Menu从继承JFrame改成继承JDialog，并设置为模态对话框。模态对话框调用setVisible(true)时，会阻塞调用它的线程，直到对话框关闭，完美匹配你主线程等待的需求。

修改Menu类 #

public class Menu extends JDialog {
    private OptionEnum selectedOption;

    public Menu(String imgPath, Window owner) throws ImgException {
        super(owner, "菜单", true); // true设置为模态
        // 保留原有菜单初始化代码
        
        // 按钮点击事件中设置枚举值并关闭对话框
        yourButton.addActionListener(e -> {
            selectedOption = OptionEnum.YOUR_TARGET_OPTION;
            dispose(); // 关闭对话框
        });
        
        setDefaultCloseOperation(DISPOSE_ON_CLOSE);
        pack();
        setLocationRelativeTo(owner);
    }

    public OptionEnum getSelectedOption() {
        return selectedOption;
    }
}

修改main方法 #

public static void main(String args[]) {
    OptionEnum option = null;
    System.out.println(option + " in main");

    // 用invokeAndWait同步执行Swing组件创建逻辑，确保在EDT线程中操作
    try {
        java.awt.EventQueue.invokeAndWait(new Runnable() {
            public void run() {
                try {
                    Menu menu = new Menu(".//resources//img//sfondoMenuTheLastofUS.jpg", null);
                    menu.setVisible(true); // 此处阻塞，直到对话框关闭
                    option = menu.getSelectedOption(); // 获取用户选择的枚举值
                } catch (ImgException ex) {
                    Logger.getLogger(Menu.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        });
    } catch (InterruptedException | InvocationTargetException ex) {
        Logger.getLogger(MainClass.class.getName()).log(Level.SEVERE, null, ex);
    }

    System.out.println(option + " in main2");
}

方案2：用CountDownLatch做线程同步 #

如果不想修改Menu的继承关系，可以用CountDownLatch让主线程等待菜单操作完成信号。

修改Menu类 #

public class Menu extends JFrame {
    private final CountDownLatch latch;
    private OptionEnum selectedOption;

    public Menu(String imgPath, CountDownLatch latch) throws ImgException {
        this.latch = latch;
        // 保留原有菜单初始化代码
        
        // 按钮点击事件中设置枚举值，触发计数减1
        yourButton.addActionListener(e -> {
            selectedOption = OptionEnum.YOUR_TARGET_OPTION;
            dispose();
            latch.countDown(); // 通知主线程可以继续执行
        });
        
        // 处理窗口关闭场景，避免主线程无限等待
        setDefaultCloseOperation(DISPOSE_ON_CLOSE);
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosed(WindowEvent e) {
                if (latch.getCount() > 0) {
                    latch.countDown();
                }
            }
        });
        pack();
        setLocationRelativeTo(null);
    }

    public OptionEnum getSelectedOption() {
        return selectedOption;
    }
}

修改main方法 #

public static void main(String args[]) {
    OptionEnum option = null;
    System.out.println(option + " in main");

    CountDownLatch latch = new CountDownLatch(1); // 计数器初始值设为1
    
    final Menu[] menuHolder = new Menu[1]; // 用数组保存Menu实例，方便后续获取
    java.awt.EventQueue.invokeLater(new Runnable() {
        public void run() {
            try {
                menuHolder[0] = new Menu(".//resources//img//sfondoMenuTheLastofUS.jpg", latch);
                menuHolder[0].setVisible(true);
            } catch (ImgException ex) {
                Logger.getLogger(Menu.class.getName()).log(Level.SEVERE, null, ex);
                latch.countDown(); // 异常场景也要释放计数器
            }
        }
    });

    try {
        latch.await(); // 主线程阻塞，直到计数器归0
    } catch (InterruptedException ex) {
        Thread.currentThread().interrupt();
    }

    option = menuHolder[0].getSelectedOption();
    System.out.println(option + " in main2");
}

方案3：使用回调函数（非阻塞方式） #

如果不想阻塞主线程，可以采用回调模式，在用户完成菜单操作后自动触发后续逻辑。

定义回调接口 #

public interface MenuCallback {
    void onOptionSelected(OptionEnum selectedOption);
}

修改Menu类 #

public class Menu extends JFrame {
    private final MenuCallback callback;

    public Menu(String imgPath, MenuCallback callback) throws ImgException {
        this.callback = callback;
        // 保留原有菜单初始化代码
        
        yourButton.addActionListener(e -> {
            OptionEnum selected = OptionEnum.YOUR_TARGET_OPTION;
            dispose();
            callback.onOptionSelected(selected); // 触发回调逻辑
        });
        
        setDefaultCloseOperation(DISPOSE_ON_CLOSE);
        pack();
        setLocationRelativeTo(null);
    }
}

修改main方法 #

public static void main(String args[]) {
    OptionEnum option = null;
    System.out.println(option + " in main");

    java.awt.EventQueue.invokeLater(new Runnable() {
        public void run() {
            try {
                new Menu(".//resources//img//sfondoMenuTheLastofUS.jpg", selectedOption -> {
                    // 菜单操作完成后执行的逻辑
                    option = selectedOption;
                    System.out.println(option + " in callback");
                    // 在这里编写后续业务代码
                }).setVisible(true);
            } catch (ImgException ex) {
                Logger.getLogger(Menu.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    });

    // 主线程可继续执行其他任务，无需等待
    System.out.println("主线程继续执行其他任务");
}

关键注意点 #

1. Swing组件的创建和更新必须在**AWT事件调度线程（EDT）**中进行，所以推荐用invokeAndWait或invokeLater处理。
2. 方案1完全符合Swing设计规范，代码最简洁，是优先推荐的解决方案。
3. 方案2需要注意处理窗口关闭、异常等边界场景，避免主线程无限阻塞。

内容的提问来源于stack exchange，提问作者DaniloS