跳过 Java KeyEvents

Question

我有一个程序，用户可以按一个键来执行操作。这一个事件只需要很少的时间。用户还可以按住该键并连续多次执行该操作。问题在于 keyPress() 事件的排队速度比事件的处理速度快。这意味着用户释放按键后，用户先前按住按键时排队的事件将继续得到处理。我还注意到，直到处理最终的 keyPress 事件之后，无论何时实际释放了键， keyRelease 事件都不会发生。我希望能够 1. 检测按键释放事件并忽略未来的 keyPress 事件，直到用户实际再次按下该键。 2. 在第一个完成之前不执行后续的 keyPress 事件，然后检测何时未按下该键，然后停止。

有谁知道该怎么做？

Answer 1

免责声明：我感觉不舒服，所以这段代码很可怕，好像……它也病了。

我想要发生的事情：访问 DirectInput 以获取键盘状态，而不是事件。但这远远超出了这个问题的范围。所以我们会维持自己的action状态。

您遇到的问题是您正在 UI 线程中执行操作。您需要生成一个工作线程并忽略后续事件，直到您的操作完成。

在我给出的示例中，当按下或按住字母“a”时，我开始一个新操作。在第一个操作完成之前，它不会生成另一个操作。该操作会更新表单上的标签，显示在完成之前还剩多少个“周期”。

还有另一个标签显示到目前为止已发生的操作数量。

生成新操作

重要的是让所有 UI 按键事件发生，而不是在 UI 线程中阻塞导致它们排队。

public void keyPressed(KeyEvent e) {
    char keyChar = e.getKeyChar();
    System.out.println("KeyChar: " + keyChar);
    // Press a to start an Action
    if (keyChar == 'a') {
        if (!mAction.isRunning()) {
            mTotalActions.setText("Ran " + (++mTotalActionsRan) + " actions.");
            System.out.println("Starting new Action");
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    mAction.run();
                }
            });
            thread.start();
        }
    }
}

UI 线程更新

如果您的操作对用户界面执行任何类型的更新，则需要使用 SwingUtilities.invokeLater 方法。此方法会将您的代码排队以在 UI 线程中运行。您不能在 UI 线程以外的线程中修改用户界面。另外，仅使用 SwingUtilities 来更新 UI 组件。任何不调用组件上的方法的计算、处理等都可以在 SwingUtilities.invokeLater 的范围之外完成。

完整代码列表

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package stackoverflow_4589538;

import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Random;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingUtilities;

public class Main extends JFrame {

    private JLabel mActionLabel;
    private JLabel mTotalActions;
    private int mTotalActionsRan;

    private class MyAction {

        private boolean mIsRunning = false;

        public void run() {
            // Make up a random wait cycle time
            final int cycles = new Random().nextInt(100);
            for (int i = 0; i < cycles; ++i) {
                final int currentCycle = i;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException ex) {
                }
                SwingUtilities.invokeLater(new Runnable() {
                    public void run() {
                            mActionLabel.setText("Cycle " + currentCycle + " of " + cycles);
                    }
                });
            }
            completed();
        }

        public synchronized void start() {
            mIsRunning = true;
        }

        public synchronized void completed() {
            mIsRunning = false;
        }

        public synchronized boolean isRunning() {
            return mIsRunning;
    }
}
    private MyAction mAction = new MyAction();

    public Main() {
        setLayout(null);
        setBounds(40, 40, 800, 600);
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        addKeyListener(new KeyAdapter() {

            @Override
            public void keyPressed(KeyEvent e) {
                char keyChar = e.getKeyChar();
                System.out.println("KeyChar: " + keyChar);
                // Press A to start an Action
                if (keyChar == 'a') {
                if (!mAction.isRunning()) {
                        mTotalActions.setText("Ran " + (++mTotalActionsRan) + " actions.");
                        System.out.println("Starting new Action");
                        Thread thread = new Thread(new Runnable() {

                            public void run() {
                                mAction.run();
                            }
                        });
                        // I had this within the run() method before
                        // but realized that it is possible for another UI event
                        // to occur and spawn another Action before, start() had
                        // occured within the thread
                        mAction.start();
                        thread.start();
                    }
                }
            }

        @Override
            public void keyReleased(KeyEvent e) {
            }
        });

        mActionLabel = new JLabel();
        mActionLabel.setBounds(10, 10, 150, 40);

        mTotalActions = new JLabel();
        mTotalActions.setBounds(10, 50, 150, 40);

        add(mActionLabel);
        add(mTotalActions);
    }    

    public static void main(String[] args) {
        new Main().setVisible(true);
    }
}

Answer 2

我还注意到，无论何时实际释放按键，直到处理最终的 keyPress 事件之后，才会发生 keyRelease 事件

这取决于您所使用的操作系统。这是 Windows 上的行为（这对我来说很有意义）。在 Unix 或 Mac 上，我相信您会收到多个 keyPressed、keyReleased 事件。因此，您的解决方案不应基于 keyReleased 事件。

我有一个程序，用户可以按一个键来执行操作。

那么您应该使用键绑定，而不是 KeyListener。阅读 Swing 教程中有关如何使用键绑定的部分了解更多信息。

当调用该操作时，您可以将其禁用。我不确定这是否会阻止 KeyStroke 再次工作，或者您是否仍然需要检查操作的启用状态。然后，当操作代码执行完毕后，您可以重新启用该操作。

此外，这个长时间运行的代码不应在 EDT 上执行。请阅读 Swing 教程中关于并发的部分，以获取有关此问题和解决方案的更多信息。

Answer 3

您必须选择选项 1。一旦开始较长的流程，请设置一个布尔值，以指示您正在处理该流程，并丢弃其他传入的相同请求。完成该过程后，将布尔值设置回原值并允许其他事件。