从 JavaFX 中的不同线程更新 UI

Question

我正在开发一个应用程序，其中包含多个需要更新TextField对象以反映相关后端属性中的更改。TextField不可编辑，只有后端可以更改其内容。

据我了解，正确的方法是在单独的线程上运行繁重的计算，以免阻塞 UI。我使用 javafx.concurrent.Task 执行此操作，并使用 updateMessage() 将单个值传达回 JavaFX 线程，效果很好。但是，我需要更新多个值，因为后端会进行处理。

由于后端值存储为 JavaFX 属性，因此我尝试简单地将它们绑定到每个 GUI 元素的textProperty，然后让绑定完成工作。但是，这不起作用;运行片刻后，即使后端任务仍在运行，TextField也会停止更新。没有提出任何例外。

我还尝试使用 Platform.runLater() 主动更新TextField而不是绑定。这里的问题是runLater()任务的调度速度比平台运行它们的速度快，因此 GUI 变得迟钝，即使在后端任务完成后也需要时间来"赶上"。

我在这里发现了几个问题：

转换为 UI 的记录器条目会随着时间的推移停止更新

JavaFX 中的多线程会挂起 UI

但我的问题仍然存在。

总结：我有一个后端对属性进行更改，我希望这些更改显示在 GUI 上。后端是一种遗传算法，因此其操作被分解为离散的世代。我希望TextField在代际之间至少刷新一次，即使这会延迟下一代。GUI 响应良好比 GA 运行速度更快更重要。

如果我没有明确问题，我可以发布一些代码示例。

更新

我设法按照James_D的建议做到了。为了解决后端必须等待控制台打印的问题，我实现了某种缓冲控制台。它将要打印的字符串存储在StringBuffer中，并在调用flush()方法时实际将它们附加到TextArea。我使用了一个 AtomicBoolean 来防止下一代发生，直到刷新完成，因为它是由可运行的Platform.runLater()完成的。另请注意，此解决方案非常慢。

Answer 1

不确定我是否完全理解，但我认为这可能会有所帮助。

为此，使用 Platform.runLater(...) 是一种合适的方法。

避免泛洪 FX 应用程序线程的诀窍是使用原子变量来存储您感兴趣的值。在 Platform.runLater 方法中，检索它并将其设置为哨兵值。在后台线程中，更新 Atomic 变量，但仅在将其设置回其哨兵值时才发出新Platform.runLater。

我通过查看Task的源代码来弄清楚这一点。看看 updateMessage 方法（撰写本文时为 1131 行）是如何实现的。

下面是一个使用相同技术的示例。这只有一个（繁忙的）后台线程，它尽可能快地计数，更新IntegerProperty。观察者监视该属性并使用新值更新AtomicInteger。如果AtomicInteger的当前值为 -1，则调度Platform.runLater。

在Platform.runLater中，我检索AtomicInteger的值并使用它来更新Label，在此过程中将值设置回-1。这表明我已经准备好进行另一个 UI 更新。

import java.text.NumberFormat;
import java.util.concurrent.atomic.AtomicInteger;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.beans.property.IntegerProperty;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
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.layout.AnchorPane;
import javafx.stage.Stage;
public class ConcurrentModel extends Application {
  @Override
  public void start(Stage primaryStage) {
    
    final AtomicInteger count = new AtomicInteger(-1);
    
    final AnchorPane root = new AnchorPane();
    final Label label = new Label();
    final Model model = new Model();
    final NumberFormat formatter = NumberFormat.getIntegerInstance();
    formatter.setGroupingUsed(true);
    model.intProperty().addListener(new ChangeListener<Number>() {
      @Override
      public void changed(final ObservableValue<? extends Number> observable,
          final Number oldValue, final Number newValue) {
        if (count.getAndSet(newValue.intValue()) == -1) {
          Platform.runLater(new Runnable() {
            @Override
            public void run() {
              long value = count.getAndSet(-1);
              label.setText(formatter.format(value));
            }
          });          
        }
      }
    });
    final Button startButton = new Button("Start");
    startButton.setOnAction(new EventHandler<ActionEvent>() {
      @Override
      public void handle(ActionEvent event) {
        model.start();
      }
    });
    AnchorPane.setTopAnchor(label, 10.0);
    AnchorPane.setLeftAnchor(label, 10.0);
    AnchorPane.setBottomAnchor(startButton, 10.0);
    AnchorPane.setLeftAnchor(startButton, 10.0);
    root.getChildren().addAll(label, startButton);
    Scene scene = new Scene(root, 100, 100);
    primaryStage.setScene(scene);
    primaryStage.show();
  }
  public static void main(String[] args) {
    launch(args);
  }
  public class Model extends Thread {
    private IntegerProperty intProperty;
    public Model() {
      intProperty = new SimpleIntegerProperty(this, "int", 0);
      setDaemon(true);
    }
    public int getInt() {
      return intProperty.get();
    }
    public IntegerProperty intProperty() {
      return intProperty;
    }
    @Override
    public void run() {
      while (true) {
        intProperty.set(intProperty.get() + 1);
      }
    }
  }
}

如果您真的想从 UI "驱动"后端：即限制后端实现的速度，以便您看到所有更新，请考虑使用 AnimationTimer 。AnimationTimer有一个handle(...)，每帧渲染调用一次。因此，您可以阻止后端实现（例如，通过使用阻塞队列），并在每次调用 handle 方法时释放一次它。handle(...) 方法在 FX 应用程序线程上调用。

handle(...) 方法采用一个参数，该参数是一个时间戳（以纳秒为单位），因此如果每帧一次太快，您可以使用它进一步减慢更新速度。

例如：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import javafx.animation.AnimationTimer;
import javafx.application.Application;
import javafx.beans.property.LongProperty;
import javafx.beans.property.SimpleLongProperty;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.TextArea;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;

public class Main extends Application {
    @Override
    public void start(Stage primaryStage) {
        
        final BlockingQueue<String> messageQueue = new ArrayBlockingQueue<>(1);
        
        TextArea console = new TextArea();
        
        Button startButton = new Button("Start");
        startButton.setOnAction(event -> {
            MessageProducer producer = new MessageProducer(messageQueue);
            Thread t = new Thread(producer);
            t.setDaemon(true);
            t.start();
        });
        
        final LongProperty lastUpdate = new SimpleLongProperty();
        
        final long minUpdateInterval = 0 ; // nanoseconds. Set to higher number to slow output.
        
        AnimationTimer timer = new AnimationTimer() {
            @Override
            public void handle(long now) {
                if (now - lastUpdate.get() > minUpdateInterval) {
                    final String message = messageQueue.poll();
                    if (message != null) {
                        console.appendText("n" + message);
                    }
                    lastUpdate.set(now);
                }
            }
            
        };
        
        timer.start();
        
        HBox controls = new HBox(5, startButton);
        controls.setPadding(new Insets(10));
        controls.setAlignment(Pos.CENTER);
        
        BorderPane root = new BorderPane(console, null, null, controls, null);
        Scene scene = new Scene(root,600,400);
        primaryStage.setScene(scene);
        primaryStage.show();
    }
    
    private static class MessageProducer implements Runnable {
        private final BlockingQueue<String> messageQueue ;
        
        public MessageProducer(BlockingQueue<String> messageQueue) {
            this.messageQueue = messageQueue ;
        }
        
        @Override
        public void run() {
            long messageCount = 0 ;
            try {
                while (true) {
                    final String message = "Message " + (++messageCount);
                    messageQueue.put(message);
                }
            } catch (InterruptedException exc) {
                System.out.println("Message producer interrupted: exiting.");
            }
        }
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}

Answer 2

执行此操作

的最佳方法是在 JavaFx 中使用 Task。这是迄今为止我在 JavaFx 中更新 UI 控件的最佳技术。

Task task = new Task<Void>() {
    @Override public Void call() {
        static final int max = 1000000;
        for (int i=1; i<=max; i++) {
            updateProgress(i, max);
        }
        return null;
    }
};
ProgressBar bar = new ProgressBar();
bar.progressProperty().bind(task.progressProperty());
new Thread(task).start();