我正在 JavaFX 中为一个相当大的 Java 项目构建一个 GUI。该项目有许多不同的工作线程在后台进行一些繁重的计算，我试图在 GUI 中可视化这些工作线程的进度。我所说的进度不仅指纯粹的百分比，还指任务类中未包含的其他变量，例如（例如）：
- 当前文件
- 当前错误计数
- 到目前为止读取的字节数
- ...
由于这些进度变量变化非常快，而且我必须从 JavaFX 线程 (Platform.runLater()) 进行 GUI 更新，因此 JavaFX 事件队列很快就会过载。我试图通过构建一个能够从 JavaFX 线程外部异步更新 GUI 属性的实用程序类来解决此问题。应跳过快速连续更新，以便仅显示最新值，从而避免 JavaFX 事件队列中充满 Runnable。
因此我建立了以下课程GUIUpdater将属性（通常是 GUI 元素，例如标签）绑定到 ObservableValues（例如 SimpleStringProperty）。这个类有两个内部类：
-
PropertyUpdater负责将单个 Property 绑定到单个 ObservableValue 并更新它。
- The
Updater为 Platform.runLater() 提供可重用的 Runnable 对象。
实用程序类：
package main;
import java.util.concurrent.ConcurrentLinkedQueue;
import javafx.application.Platform;
import javafx.beans.property.Property;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
/**
* Class for enabling fast updates of GUI components from outside the JavaFX thread.
* Updating GUI components (such as labels) should be done from the JavaFX thread by using Platform.runLater for example.
* This makes it hard to update the GUI with a fast changing variable as it is very easy to fill up the JavaFX event queue faster than it can be emptied (i.e. faster than it can be drawn).
* This class binds ObservableValues to (GUI) Properties and ensures that quick consecutive updates are ignored, only updating to the latest value.
*/
public class GUIUpdater {
private ConcurrentLinkedQueue<PropertyUpdater<?>> dirtyPropertyUpdaters = new ConcurrentLinkedQueue<>();
private Updater updater = new Updater();
private boolean isUpdating = false;
/**
* Binds an ObservableValue to a Property.
* Updates to the ObservableValue can be made from outside the JavaFX thread and the latest update will be reflected in the Property.
* @param property (GUI) Property to be updated/
* @param observable ObservableValue to update the GUI property to.
*/
public <T> void bind(Property<T> property, ObservableValue<T> observable) {
PropertyUpdater<T> propertyUpdater = new PropertyUpdater<>(property, observable);
observable.addListener(propertyUpdater);
}
/**
* Unbinds the given ObservableValue from the given Property.
* Updates to the ObservableValue will no longer be reflected in the Property.
* @param property (GUI) Property to unbind the ObservableValue from.
* @param observable ObservableValue to unbind from the given Property.
*/
public <T> void unbind(Property<T> property, ObservableValue<T> observable) {
PropertyUpdater<T> tmpPropertyUpdater = new PropertyUpdater<>(property, observable);
observable.removeListener(tmpPropertyUpdater);
}
/**
* Schedules an update to the GUI by using a call to Platform.runLater().
* The updated property is added to the dirtyProperties list, marking it for the next update round.
* Will only submit the event to the event queue if the event isn't in the event queue yet.
* @param updater
*/
private void scheduleUpdate(PropertyUpdater<?> updater) {
this.dirtyPropertyUpdaters.add(updater);
// Make sure the isUpdating var isn't changed concurrently by the Updater thread (on the JavaFX event queue)
synchronized (this) {
if (!this.isUpdating) {
this.isUpdating = true;
Platform.runLater(this.updater);
}
}
}
/**
* Class used for binding a single ObservableValue to a Property and updating it.
*
* @param <T>
*/
private class PropertyUpdater<T> implements ChangeListener<T> {
private boolean isDirty = false;
private Property<T> property = null;
private ObservableValue<T> observable = null;
public PropertyUpdater(Property<T> property, ObservableValue<T> observable) {
this.property = property;
this.observable = observable;
}
@Override
/**
* Called whenever the ObservableValue has changed. Marks this Updater as dirty.
*/
public synchronized void changed(ObservableValue<? extends T> observable, T oldValue, T newValue) {
if (!this.isDirty) {
this.isDirty = true;
GUIUpdater.this.scheduleUpdate(this);
}
}
/**
* Updates the Property to the ObservableValue and marks it as clean again.
* Should only be called from the JavaFX thread.
*/
public synchronized void update() {
T value = this.observable.getValue();
this.property.setValue(value);
this.isDirty = false;
}
@Override
/**
* Two PropertyUpdaters are equals if their Property and ObservableValue map to the same object (address).
*/
public boolean equals(Object otherObj) {
PropertyUpdater<?> otherUpdater = (PropertyUpdater<?>) otherObj;
if (otherObj == null) {
return false;
} else {
// Only compare addresses (comparing with equals also compares contents):
return (this.property == otherUpdater.property) && (this.observable == otherUpdater.observable);
}
}
}
/**
* Simple class containing the Runnable for the call to Platform.runLater.
* Hence, the run() method should only be called from the JavaFX thread.
*
*/
private class Updater implements Runnable {
@Override
public void run() {
// Loop through the individual PropertyUpdaters, updating them one by one:
while(!GUIUpdater.this.dirtyPropertyUpdaters.isEmpty()) {
PropertyUpdater<?> curUpdater = GUIUpdater.this.dirtyPropertyUpdaters.poll();
curUpdater.update();
}
// Make sure we're not clearing the mark when scheduleUpdate() is still setting it:
synchronized (GUIUpdater.this) {
GUIUpdater.this.isUpdating = false;
}
}
}
}
这是一个用于测试的简单类GUIUpdater实用类：
package main;
import javafx.application.Application;
import javafx.beans.property.SimpleStringProperty;
import javafx.concurrent.Task;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.ProgressBar;
import javafx.scene.layout.FlowPane;
import javafx.stage.Stage;
public class JavaFXTest extends Application {
private GUIUpdater guiUpdater = new GUIUpdater();
private Label lblState = new Label();
private ProgressBar prgProgress = new ProgressBar();
public static void main(String args[]) {
JavaFXTest.launch(args);
}
@Override
public void start(Stage primaryStage) throws Exception {
// Init window:
FlowPane flowPane = new FlowPane();
primaryStage.setScene(new Scene(flowPane));
primaryStage.setTitle("JavaFXTest");
// Add a Label and a progressBar:
flowPane.getChildren().add(this.lblState);
flowPane.getChildren().add(this.prgProgress);
// Add button:
Button btnStart = new Button("Start");
btnStart.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event) {
// Create task:
TestTask testTask = new TestTask();
// Bind:
JavaFXTest.this.guiUpdater.bind(JavaFXTest.this.lblState.textProperty(), testTask.myStateProperty());
JavaFXTest.this.prgProgress.progressProperty().bind(testTask.progressProperty()); // No need to use GUIUpdater here, Task class provides the same functionality for progress.
// Start task:
Thread tmpThread = new Thread(testTask);
tmpThread.start();
}
});
flowPane.getChildren().add(btnStart);
// Show:
primaryStage.show();
}
/**
* A simple task containing a for loop to simulate a fast running and fast updating process.
* @author DePhille
*
*/
private class TestTask extends Task<Void> {
private SimpleStringProperty myState = new SimpleStringProperty();
@Override
protected Void call() throws Exception {
// Count:
try {
int maxValue = 1000000;
System.out.println("Starting...");
for(int i = 0; i < maxValue; i++) {
this.updateProgress(i, maxValue - 1);
this.myState.set("Hello " + i);
}
System.out.println("Done!");
} catch(Exception e) {
e.printStackTrace();
}
// Unbind:
JavaFXTest.this.guiUpdater.unbind(JavaFXTest.this.lblState.textProperty(), this.myStateProperty());
return null;
}
public SimpleStringProperty myStateProperty() {
return this.myState;
}
}
}
代码的问题在于，有时 Label 没有更新为最新值（在本例中为 999999）。这似乎主要发生在应用程序启动后，因此启动应用程序，单击“开始”按钮，关闭它并重复此过程应该会在几次尝试后重现问题。据我所知我已经添加了synchronized在需要的地方阻止，这就是为什么我不明白问题来自哪里。
尽管我主要是在寻找所描述问题的解决方案，但我们非常感谢所有建议（即使是那些与问题无关的建议）！我还在代码中添加了注释，因此我希望与上面的信息一起提供有关问题和代码的足够详细信息。
提前致谢！
