在GUI线程中触发异步事件

小编典典

在GUI线程中触发异步事件

java

TL; DR我正在寻找一种让一个线程在另一个线程中引发事件的方法

编辑：
我说“立即”一词，正如一些评论家指出的那样，这是不可能的。我的意思是，如果gui线程处于空闲状态，则应该在毫秒到十亿分之一秒的范围内相当快地发生（这应该是正确的，如果我做对的话）。

案例示例： 我有一个具有Parent类的项目。该Parent类创建一个子线程“
Gui”，该子线程包含一个javafx应用程序并实现Runnable。Parent和Gui都引用了相同的BlockingQueue。

我想发生的事情：
我希望能够将对象从父类发送到Gui线程，并让Gui接收某种事件，该事件立即调用某种处理函数，因此我知道获得一个或队列中的更多对象，并将它们添加到gui。

“观察者模式”的其他解决方案通常包括一个观察者，该观察者坐在while循环中，检查一些同步队列中是否有新数据。这不适用于我的应用程序，因为Javafx要求仅从gui线程修改gui元素，并且必须很大程度上不占用gui线程，以便它有时间重绘内容并响应用户事件。循环将导致应用程序挂起。

我发现似乎有潜力的一个想法是从父线程中断Gui线程，并触发某种事件，但是我找不到任何办法来实现。

有任何想法吗？这种情况下的最佳做法是什么？

阅读 261

2020-11-30

共1个答案

小编典典

听起来，您实际上真正需要的就是通过调用FX Application
Thread上的UI更新Platform.runLater(...)。这将安排一个更新，该更新将在FX Application
Thread有时间后立即执行，只要您没有过多的请求就可以很快地执行更新。下次出现渲染脉冲时，更新将对用户可见（因此从用户的角度来看，此更新将尽快发生）。

这是一个最愚蠢的示例：产生数据的异步类直接在UI上安排更新。

首先是一个简单的类来保存一些数据。我添加了一些功能来检查数据的“年龄”，即自构造函数被调用以来已经过了多长时间：

MyDataClass.java

public class MyDataClass {

    private final int value ;

    private final long generationTime ;

    public MyDataClass(int value) {
        this.value = value ;
        this.generationTime = System.nanoTime() ;
    }

    public int getValue() {
        return value ;
    }

    public long age() {
        return System.nanoTime() - generationTime ;
    }
}

这是一个简单的UI，显示接收到的所有数据，以及数据的“年龄”和所有数据的平均值：

import javafx.beans.property.DoubleProperty;
import javafx.beans.property.SimpleDoubleProperty;
import javafx.scene.Parent;
import javafx.scene.control.Label;
import javafx.scene.control.TextArea;
import javafx.scene.layout.BorderPane;

public class UI {

    private final TextArea textArea ;
    private final Parent view ;
    private long total ;
    private long count ;
    private final DoubleProperty average = new SimpleDoubleProperty(0);


    public UI() {
        textArea = new TextArea();

        Label aveLabel = new Label();
        aveLabel.textProperty().bind(average.asString("Average: %.3f"));

        view = new BorderPane(textArea, null, null, aveLabel, null);
    }

    public void registerData(MyDataClass data) {
        textArea.appendText(String.format("Data: %d (received %.3f milliseconds after generation)%n", 
                data.getValue(), data.age()/1_000_000.0)); 
        count++;
        total+=data.getValue();
        average.set(1.0*total / count);
    }

    public Parent getView() {
        return view ;
    }
}

这是一类（异步地）睡眠很多并产生随机数据的类（有点像我的实习生…）。目前，它仅具有对UI的引用，因此可以直接安排更新：

import java.util.Random;

import javafx.application.Platform;

public class DataProducer extends Thread {

    private final UI ui ;

    public DataProducer(UI ui) {
        this.ui = ui ;
        setDaemon(true);
    }

    @Override
    public void run()  {
        Random rng = new Random();
        try {
            while (true) {
                MyDataClass data = new MyDataClass(rng.nextInt(100));
                Platform.runLater(() -> ui.registerData(data));
                Thread.sleep(rng.nextInt(1000) + 250);
            } 
        } catch (InterruptedException e) {
            // Ignore and allow thread to exit
        }
    }
}

最后是应用程序代码：

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.stage.Stage;

public class AsyncExample extends Application {

    @Override
    public void start(Stage primaryStage) {
        UI ui = new UI();
        DataProducer producer = new DataProducer(ui);
        producer.start();
        Scene scene = new Scene(ui.getView(), 600, 600);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

运行此命令，我会在生成数据后约0.1毫秒内看到UI正在处理的数据，这符合您的要求。（第一个或第二个将花费更长的时间，因为它们是在start方法完成之前和物理显示UI之前生成的，因此对它们的调用Platform.runLater(...)将需要等待该工作完成。）

这段代码的问题当然是，它DataProducer与UI和JavaFX紧密耦合（Platform直接使用该类）。您可以通过授予一般消费者处理数据的方式来删除此耦合：

import java.util.Random;
import java.util.function.Consumer;

public class DataProducer extends Thread {

    private final Consumer<MyDataClass> dataConsumer ;

    public DataProducer(Consumer<MyDataClass> dataConsumer) {
        this.dataConsumer = dataConsumer ;
        setDaemon(true);
    }

    @Override
    public void run()  {
        Random rng = new Random();
        try {
            while (true) {
                MyDataClass data = new MyDataClass(rng.nextInt(100));
                dataConsumer.accept(data);
                Thread.sleep(rng.nextInt(1000) + 250);
            } 
        } catch (InterruptedException e) {
            // Ignore and allow thread to exit
        }
    }
}

然后

import javafx.application.Application;
import javafx.application.Platform;
import javafx.scene.Scene;
import javafx.stage.Stage;

public class AsyncExample extends Application {

    @Override
    public void start(Stage primaryStage) {
        UI ui = new UI();
        DataProducer producer = new DataProducer(d -> Platform.runLater(() -> ui.registerData(d)));
        producer.start();
        Scene scene = new Scene(ui.getView(), 600, 600);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

请注意，在Consumer此处设置a
与提供事件处理程序非常相似：每当生成数据元素时，都会“通知”或“触发”使用者。List<Consumer<MyDataClass>>如果您想通知多个不同的视图，可以轻松地将其扩展为一个，然后将使用者添加/删除到该列表中。数据类型MyDataClass扮演事件对象的角色：它包含有关发生的确切信息。Consumer是通用的功能接口，因此可以通过您选择的任何类或lambda表达式（如本例中所做的那样）来实现。

作为此版本的一个变体，您可以通过将a
抽象化为（这只是运行s的东西）来将的Platform.runLater(...)执行与执行分离开：Consumer``Platform.runLater(...)``java.util.concurrent.Executor``Runnable

import java.util.Random;
import java.util.concurrent.Executor;
import java.util.function.Consumer;

public class DataProducer extends Thread {

    private final Consumer<MyDataClass> dataConsumer ;
    private final Executor updateExecutor ;

    public DataProducer(Consumer<MyDataClass> dataConsumer, Executor updateExecutor) {
        this.dataConsumer = dataConsumer ;
        this.updateExecutor = updateExecutor ;
        setDaemon(true);
    }

    @Override
    public void run()  {
        Random rng = new Random();
        try {
            while (true) {
                MyDataClass data = new MyDataClass(rng.nextInt(100));
                updateExecutor.execute(() -> dataConsumer.accept(data));
                Thread.sleep(rng.nextInt(1000) + 250);
            } 
        } catch (InterruptedException e) {
            // Ignore and allow thread to exit
        }
    }
}

和

import javafx.application.Application;
import javafx.application.Platform;
import javafx.scene.Scene;
import javafx.stage.Stage;

public class AsyncExample extends Application {

    @Override
    public void start(Stage primaryStage) {
        UI ui = new UI();
        DataProducer producer = new DataProducer(ui::registerData, Platform::runLater);
        producer.start();
        Scene scene = new Scene(ui.getView(), 600, 600);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

解耦类的另一种方法是使用a
BlockingQueue传输数据。它具有可以限制队列大小的功能，因此，如果有太多待处理数据，则数据生成线程将阻塞。此外，您可以在UI类中“批量处理”许多数据更新，这在您以足够快的速度生成它们以使FX
Application
Thread充满太多更新时非常有用（我在这里没有显示该代码；您需要使用a中的数据，AnimationTimer并进一步放松“立即”的概念。这个版本看起来像：

import java.util.Random;
import java.util.concurrent.BlockingQueue;

public class DataProducer extends Thread {

    private final BlockingQueue<MyDataClass> queue ;

    public DataProducer(BlockingQueue<MyDataClass> queue) {
        this.queue = queue ;
        setDaemon(true);
    }

    @Override
    public void run()  {
        Random rng = new Random();
        try {
            while (true) {
                MyDataClass data = new MyDataClass(rng.nextInt(100));
                queue.put(data);
                Thread.sleep(rng.nextInt(1000) + 250);
            } 
        } catch (InterruptedException e) {
            // Ignore and allow thread to exit
        }
    }
}

UI需要做更多的工作：它需要一个线程来重复从队列中取出元素。请注意，queue.take()在没有可用元素之前，这些块将阻塞：

import java.util.concurrent.BlockingQueue;

import javafx.application.Platform;
import javafx.beans.property.DoubleProperty;
import javafx.beans.property.SimpleDoubleProperty;
import javafx.scene.Parent;
import javafx.scene.control.Label;
import javafx.scene.control.TextArea;
import javafx.scene.layout.BorderPane;

public class UI {

    private final TextArea textArea ;
    private final Parent view ;
    private long total ;
    private long count ;
    private final DoubleProperty average = new SimpleDoubleProperty(0);


    public UI(BlockingQueue<MyDataClass> queue) {
        textArea = new TextArea();

        Label aveLabel = new Label();
        aveLabel.textProperty().bind(average.asString("Average: %.3f"));

        view = new BorderPane(textArea, null, null, aveLabel, null);

        // thread to take items from the queue and process them:

        Thread queueConsumer = new Thread(() -> {
            while (true) {
                try {
                    MyDataClass data = queue.take();
                    Platform.runLater(() -> registerData(data));
                } catch (InterruptedException exc) {
                    // ignore and let thread exit
                }
            }
        });
        queueConsumer.setDaemon(true);
        queueConsumer.start();
    }

    public void registerData(MyDataClass data) {
        textArea.appendText(String.format("Data: %d (received %.3f milliseconds after generation)%n", 
                data.getValue(), data.age()/1_000_000.0)); 
        count++;
        total+=data.getValue();
        average.set(1.0*total / count);
    }

    public Parent getView() {
        return view ;
    }
}

然后你就做

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.stage.Stage;

public class AsyncExample extends Application {

    private final int MAX_QUEUE_SIZE = 10 ;

    @Override
    public void start(Stage primaryStage) {

        BlockingQueue<MyDataClass> queue = new ArrayBlockingQueue<>(MAX_QUEUE_SIZE);
        UI ui = new UI(queue);
        DataProducer producer = new DataProducer(queue);
        producer.start();
        Scene scene = new Scene(ui.getView(), 600, 600);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

同样，所有这些版本都可以通过Platform.runLater(...)计划更新来工作（存在各种将类解耦的机制）。至少从概念上讲，这实际上是将可运行对象放入一个无界队列中。FX
Application Thread从此队列中获取元素并运行它们（在该线程上）。因此，只要FX Application
Thread有机会，就立即执行runnable，这实际上是您可以实现的。

听起来好像不需要生成数据的线程才能阻塞数据，直到处理完数据为止，但是如果需要也可以实现（例如，只需将队列大小设置为1）。

2020-11-30