如何在Java中通过并行代码实现简易帧率限制器稳定游戏速度

要让游戏不受帧率和硬件性能波动影响，核心是把逻辑计算与渲染完全分离到独立线程：逻辑线程以固定时间步长稳定运行，渲染依托Swing的事件调度线程（EDT）根据计算结果更新画面，两者通过线程安全的方式同步状态。

关键实现要点 #

• 逻辑计算单独开线程，用固定时间步长执行，确保游戏速度稳定
• 用线程安全机制同步逻辑状态与渲染状态（如volatile关键字）
• 渲染操作严格在EDT中执行，避免UI线程被逻辑计算阻塞

完整代码示例 #

import javax.swing.*;
import java.awt.*;

public class GamePanel extends JPanel implements Runnable {
    // 线程安全标记：是否有新的逻辑计算结果可用于渲染
    private volatile boolean logicUpdated = false;
    // 逻辑线程运行控制标记
    private volatile boolean running = true;
    // 固定逻辑步长：每16ms执行一次（约60次/秒，可根据需求调整）
    private static final long LOGIC_STEP = 16_000_000; // 单位：纳秒

    // 示例游戏状态数据（可替换为你的游戏变量）
    private volatile int playerX = 0;
    private volatile int playerY = 0;

    public GamePanel() {
        // 启动逻辑计算线程
        new Thread(this).start();
        setPreferredSize(new Dimension(800, 600));
    }

    @Override
    public void run() {
        long lastLogicTime = System.nanoTime();
        while (running) {
            long currentTime = System.nanoTime();
            long elapsedTime = currentTime - lastLogicTime;

            // 达到固定步长时执行逻辑计算
            if (elapsedTime >= LOGIC_STEP) {
                updateGameLogic();
                // 修正时间误差，避免累积延迟
                lastLogicTime = currentTime - (elapsedTime % LOGIC_STEP);
                logicUpdated = true;
                repaint(); // 请求EDT触发渲染
            }

            // 短暂休眠降低CPU占用
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    // 游戏逻辑计算：替换为你的实际游戏逻辑
    private void updateGameLogic() {
        // 模拟玩家循环移动
        playerX += 1;
        if (playerX > getWidth()) playerX = 0;
        playerY += 1;
        if (playerY > getHeight()) playerY = 0;
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        // 仅当逻辑更新后才渲染新状态
        if (logicUpdated) {
            // 清空画布
            g.setColor(Color.BLACK);
            g.fillRect(0, 0, getWidth(), getHeight());
            // 绘制玩家（示例）
            g.setColor(Color.RED);
            g.fillOval(playerX, playerY, 50, 50);
            logicUpdated = false; // 重置标记，等待下一次逻辑更新
        }
    }

    // 停止逻辑线程，用于窗口关闭时清理
    public void stop() {
        running = false;
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("Stable Game");
        GamePanel panel = new GamePanel();
        frame.add(panel);
        frame.pack();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);

        // 窗口关闭时停止逻辑线程
        frame.addWindowListener(new java.awt.event.WindowAdapter() {
            @Override
            public void windowClosing(java.awt.event.WindowEvent windowEvent) {
                panel.stop();
            }
        });
    }
}

代码说明 #

1. 逻辑线程：通过Runnable实现，用System.nanoTime()精确控制时间步长，确保逻辑计算频率稳定，不受渲染速度影响。
2. 线程安全同步：用volatile修饰共享变量，保证线程间状态的可见性，避免竞态条件。
3. 渲染控制：仅在逻辑更新完成后才绘制新状态，避免重复渲染旧数据，同时保证渲染操作在EDT中执行，符合Swing的UI线程规范。
4. CPU优化：逻辑线程中加入短暂休眠，避免无意义的空循环占用过多CPU资源。

为什么计时器方案不可靠？ #

Swing的Timer运行在EDT中，如果逻辑计算耗时较长，会直接阻塞UI线程导致渲染卡顿。而单独的逻辑线程与EDT并行执行，从根本上分离了逻辑与渲染的依赖，避免相互影响。

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