键盘类中的布尔变量是否需设为volatile？有无替代方案？

首先明确结论：直接给UP/LEFT等静态变量加volatile无法解决根本问题，你的代码核心问题是keys数组的跨线程读写没有可见性保障，需要针对性处理。

问题分析 #

你的代码存在两处跨线程操作：

• EDT线程（Java Swing的事件调度线程）在keyPressed/keyReleased回调中修改keys数组的元素；
• 游戏线程（Window类run方法所在的线程）在keyboard.update()中读取keys数组，再赋值给静态变量，随后Player的update方法在同一个游戏线程内读取这些静态变量。

由于keys是普通boolean数组，Java无法保证EDT写入的最新值能被游戏线程及时读取到——游戏线程可能会缓存数组元素的旧值，导致键盘输入延迟或失效。而UP等静态变量的赋值和读取都在同一个游戏线程内，本身不需要volatile，但如果keys数组读不到最新值，这些静态变量也会是旧状态。

一、需要用volatile的正确方式 #

如果要用到volatile，不能只给静态变量加，需要解决keys数组的可见性问题。但Java无法直接声明数组元素为volatile，所以更可靠的方式是用原子类数组替代普通数组：

public class Keyboard implements KeyListener {
    private AtomicBoolean[] keys = new AtomicBoolean[256];
    public static boolean UP, LEFT, RIGTH, SHOOT;

    public Keyboard() {
        // 初始化原子布尔数组
        for (int i = 0; i < keys.length; i++) {
            keys[i] = new AtomicBoolean(false);
        }
        UP = false;
        LEFT = false;
        RIGTH = false;
        SHOOT = false;
    }

    public void update() {
        // 通过原子类方法读取最新值
        UP = keys[KeyEvent.VK_UP].get();
        LEFT = keys[KeyEvent.VK_LEFT].get();
        RIGTH = keys[KeyEvent.VK_RIGHT].get();
        SHOOT = keys[KeyEvent.VK_P].get();
    }

    @Override
    public void keyTyped(KeyEvent e) {}

    @Override
    public void keyPressed(KeyEvent e) {
        int keyCode = e.getKeyCode();
        if (keyCode >= 0 && keyCode < keys.length) {
            keys[keyCode].set(true);
        } else {
            System.out.println("Tecla fuera de rango: " + keyCode);
        }
    }

    @Override
    public void keyReleased(KeyEvent e) {
        int keyCode = e.getKeyCode();
        if (keyCode >= 0 && keyCode < keys.length) {
            keys[keyCode].set(false);
        } else {
            System.out.println("Tecla fuera de rango: " + keyCode);
        }
    }
}

AtomicBoolean的get()和set()方法自带可见性保障，能确保EDT写入的状态被游戏线程及时读取。此时UP等静态变量因为在同一个线程内读写，不需要加volatile。

二、不使用volatile的替代方案 #

1. 用同步锁保证可见性 #

给keys数组的读写操作包裹synchronized块，同步锁既保证互斥，也能保证线程间的可见性：

public class Keyboard implements KeyListener {
    private boolean[] keys = new boolean[256];
    public static boolean UP, LEFT, RIGTH, SHOOT;

    public Keyboard() {
        UP = false;
        LEFT = false;
        RIGTH = false;
        SHOOT = false;
    }

    public void update() {
        synchronized (this) {
            UP = keys[KeyEvent.VK_UP];
            LEFT = keys[KeyEvent.VK_LEFT];
            RIGTH = keys[KeyEvent.VK_RIGHT];
            SHOOT = keys[KeyEvent.VK_P];
        }
    }

    @Override
    public void keyTyped(KeyEvent e) {}

    @Override
    public void keyPressed(KeyEvent e) {
        int keyCode = e.getKeyCode();
        if (keyCode >= 0 && keyCode < keys.length) {
            synchronized (this) {
                keys[keyCode] = true;
            }
        } else {
            System.out.println("Tecla fuera de rango: " + keyCode);
        }
    }

    @Override
    public void keyReleased(KeyEvent e) {
        int keyCode = e.getKeyCode();
        if (keyCode >= 0 && keyCode < keys.length) {
            synchronized (this) {
                keys[keyCode] = false;
            }
        } else {
            System.out.println("Tecla fuera de rango: " + keyCode);
        }
    }
}

线程释放锁时会把修改刷新到主存，获取锁时会从主存读取最新值，以此保证状态同步。

2. 事件队列集中处理（游戏开发常用方案） #

把EDT线程收到的键盘事件放到线程安全队列中，游戏线程在update阶段批量处理事件，让所有状态修改和读取都在同一个线程内完成，彻底避免跨线程问题：

public class Keyboard implements KeyListener {
    private boolean[] keys = new boolean[256];
    public static boolean UP, LEFT, RIGTH, SHOOT;
    // 线程安全的事件队列
    private Queue<KeyEvent> eventQueue = new ConcurrentLinkedQueue<>();

    public Keyboard() {
        UP = false;
        LEFT = false;
        RIGTH = false;
        SHOOT = false;
    }

    public void update() {
        // 批量处理队列中的所有键盘事件
        KeyEvent event;
        while ((event = eventQueue.poll()) != null) {
            int keyCode = event.getKeyCode();
            if (keyCode >= 0 && keyCode < keys.length) {
                // 根据事件类型更新按键状态
                keys[keyCode] = event.getID() == KeyEvent.KEY_PRESSED;
            } else {
                System.out.println("Tecla fuera de rango: " + keyCode);
            }
        }
        // 同步到静态变量
        UP = keys[KeyEvent.VK_UP];
        LEFT = keys[KeyEvent.VK_LEFT];
        RIGTH = keys[KeyEvent.VK_RIGHT];
        SHOOT = keys[KeyEvent.VK_P];
    }

    @Override
    public void keyTyped(KeyEvent e) {}

    @Override
    public void keyPressed(KeyEvent e) {
        eventQueue.add(e);
    }

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

这种方式不需要volatile或同步锁，所有状态操作都在游戏线程内完成，是游戏开发中比较高效的做法，还能避免多线程同步带来的开销。

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