JavaFX Timeline 帧率锁定问题解析与多任务同步方案

public class TickSystem implements EventHandler<ActionEvent> {
    // ... 其他成员变量 ...
    public final Timeline gameLoop = new Timeline(120); // 初始构造函数参数，但实际行为受KeyFrame影响
    public final Duration updateTime = Duration.millis((double)1000/60); // 60次/秒
    public final Duration drawTime = Duration.millis((double)1000/120); // 120次/秒

    public TickSystem(Rectangle r){
        this.r = r;
        // 更新任务：60次/秒
        this.kfU = new KeyFrame(updateTime,"tickKeyUpdate", this::handle);
        // 绘制任务：120次/秒
        this.kfD = new KeyFrame(drawTime,"tickKeyDraw", this::handleDraw);
        // FPS统计任务：1次/秒
        this.kfFPS = new KeyFrame(Duration.seconds(1),"tickKeyFPS", this::handleFPS);

        this.gameLoop.setCycleCount(Timeline.INDEFINITE);
        this.gameLoop.getKeyFrames().add(this.kfU);
        this.gameLoop.getKeyFrames().add(this.kfD);
        this.gameLoop.getKeyFrames().add(this.kfFPS);
    }
    // ... handle, handleDraw, handleFPS 方法 ...
}

import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.event.ActionEvent;
import javafx.scene.shape.Rectangle;
import javafx.util.Duration;

public class TickSystem {
    private KeyFrame kfU; // 更新任务的KeyFrame
    private KeyFrame kfD; // 绘制任务的KeyFrame
    private KeyFrame kfFPS; // FPS统计任务的KeyFrame
    public Rectangle r;
    public int curFrame = 0;
    public int tick = 0;

    // 为不同任务创建独立的Timeline
    public final Timeline gameLoop = new Timeline(); // 用于更新逻辑，60fps
    private final Timeline drawLoop = new Timeline(); // 用于绘制逻辑，120fps
    private final Timeline fpsLoop = new Timeline(); // 用于FPS统计，1fps

    public final Duration updateTime = Duration.millis((double)1000/60); // 60次/秒
    public final Duration drawTime = Duration.millis((double)1000/120); // 120次/秒

    public int fps;
    private int lastFrames = 0;

    public TickSystem(Rectangle r){
        this.r = r;
        // 为每个任务创建对应的KeyFrame，并指定其事件处理器
        this.kfU = new KeyFrame(updateTime,"tickKeyUpdate", this::handleUpdate);
        this.kfD = new KeyFrame(drawTime,"tickKeyDraw", this::handleDraw);
        this.kfFPS = new KeyFrame(Duration.seconds(1),"tickKeyFPS", this::handleFPS);

        // 为每个Timeline设置无限循环
        this.gameLoop.setCycleCount(Timeline.INDEFINITE);
        this.drawLoop.setCycleCount(Timeline.INDEFINITE);
        this.fpsLoop.setCycleCount(Timeline.INDEFINITE);

        // 将KeyFrame添加到各自的Timeline中
        this.gameLoop.getKeyFrames().add(this.kfU);
        this.drawLoop.getKeyFrames().add(this.kfD);
        this.fpsLoop.getKeyFrames().add(this.kfFPS); // FPS统计Timeline只包含一个KeyFrame
    }

    public void start(){
        this.gameLoop.play();
        this.drawLoop.play();
        this.fpsLoop.play();
    }
    public void pause(){
        this.gameLoop.pause();
        this.drawLoop.pause();
        this.fpsLoop.pause();
    }
    public void stop(){
        this.gameLoop.stop();
        this.drawLoop.stop();
        this.fpsLoop.stop();
    }

    public void handleUpdate(ActionEvent ae) { // 更新逻辑
        this.tick++;
    }

    public void handleDraw(ActionEvent ae){ // 绘制逻辑
        this.curFrame++;
        this.r.setWidth(curFrame); // 示例：每次调用宽度增加1
    }

    public void handleFPS(ActionEvent ae) { // FPS统计逻辑
        this.fps = this.curFrame - this.lastFrames;
        this.lastFrames = this.curFrame;
        System.out.println("FPS: " + this.fps); // 打印每秒绘制次数
    }
}

import javafx.animation.Animation;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.shape.Rectangle;
import javafx.util.Duration;

import java.util.ArrayList;
import java.util.List;

public class TickSystem {

    private Rectangle r;
    private int curFrame = 0;
    private int tick = 0;

    private final List<Timeline> timelines = new ArrayList<>(); // 存储所有Timeline实例

    private int fps;
    private int lastFrames = 0;

    public TickSystem(Rectangle r){
        this.r = r;
        // 使用辅助方法创建并添加Timeline
        timelines.add(createTimeline(60, this::handleUpdate)); // 60次/秒更新
        timelines.add(createTimeline(120, this::handleDraw)); // 120次/秒绘制
        timelines.add(createTimeline(1, this::handleFPS));   // 1次/秒统计FPS
    }

    /**
     * 辅助方法：创建一个指定频率和事件处理器的Timeline
     * @param frequency 每秒触发次数
     * @param handler 事件处理器
     * @return 配置好的Timeline实例
     */
    private Timeline createTimeline(int frequency, EventHandler<ActionEvent> handler) {
        Timeline timeline = new Timeline(); // 创建新的Timeline
        // KeyFrame的Duration根据频率计算
        timeline.getKeyFrames().add(new KeyFrame(Duration.millis(1000.0 / frequency), handler));
        timeline.setCycleCount(Animation.INDEFINITE); // 设置无限循环
        return timeline;
    }

    public void start(){
        timelines.forEach(Timeline::play); // 启动所有Timeline
    }
    public void pause(){
        timelines.forEach(Timeline::pause); // 暂停所有Timeline
    }
    public void stop(){
        timelines.forEach(Timeline::stop); // 停止所有Timeline
    }

    public void handleUpdate(ActionEvent ae) { // 更新逻辑
        this.tick++;
    }

    public void handleDraw(ActionEvent ae){ // 绘制逻辑
        this.curFrame++;
        this.r.setWidth(curFrame);
    }

    public void handleFPS(ActionEvent ae) { // FPS统计逻辑
        this.fps = this.curFrame - this.lastFrames;
        this.lastFrames = this.curFrame;
        System.out.println("FPS: " + this.fps);
    }
}