Question

我经常发现自己遇到了控件的两个（相关）值更新的问题，并且两者都会触发昂贵的操作，或者控件可能会暂时处于不一致状态。

例如，考虑一个数据绑定，其中两个值（x，y）相互减去，最终结果用作其他属性z的除数：

z /（x - y）

如果x和y绑定到某个外部值，那么一次更新一个可能导致意外除零错误，具体取决于首先更新哪个属性以及其他属性的旧值是什么。更新属性z的代码只是监听x和y的变化 - 它无法预先知道另一个属性的另一个更新。

现在这个问题很容易避免，但还有其他类似的情况，比如设置宽度和高度......我是否会立即调整窗口大小或等待另一个更改？我是否立即为指定的宽度和高度分配内存，还是等待？如果宽度和高度是1和1百万，然后更新到1百万和1，那么暂时我的宽度和高度为1百万x 1百万......

这可能是一个相当普遍的问题，虽然对我来说特别适用于JavaFX Bindings。我对如何处理这些情况感兴趣，而不会遇到未定义的行为或执行需要在另一个绑定更改后重做的昂贵操作。

到目前为止我为避免这些情况所做的事情是在设置新值之前首先清除绑定到已知值，但这对代码更新它真正不应该知道的绑定负担。

Answer 1

我现在才学习JavaFX，所以请耐心等待这个答案......欢迎任何更正。我对此感兴趣，所以进行了一些研究。

无效监听器

这个问题的答案部分是InvalidationListener。您可以详细阅读文档here，但实质是ChangeLister会立即传播更改，而InvalidationListener会注意到值无效但会将计算延迟到需要。一个基于“z /（x - y）”计算证明这两种情况的例子：

首先，琐碎的事情：

import javafx.beans.InvalidationListener;
import javafx.beans.Observable;
import javafx.beans.binding.DoubleBinding;
import javafx.beans.binding.NumberBinding;
import javafx.beans.property.SimpleDoubleProperty;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableNumberValue;
import javafx.beans.value.ObservableValue;

public class LazyExample
{
    public static void main(String[] args) {
        changeListenerCase();
        System.out.println("\n=====================================\n");
        invalidationListenerCase();
    }
    ...
}

2个案例（更改和失效侦听器）将设置3个变量x，y，z，计算表达式z / (x - y)和相应的侦听器。然后他们调用manipulate()方法来更改值。记录所有步骤：

    public static void changeListenerCase() {
        SimpleDoubleProperty x = new SimpleDoubleProperty(1);
        SimpleDoubleProperty y = new SimpleDoubleProperty(2);
        SimpleDoubleProperty z = new SimpleDoubleProperty(3);

        NumberBinding nb = makeComputed(x,y,z);

        nb.addListener(new ChangeListener<Number>() {
            @Override public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
                System.out.println("ChangeListener: " + oldValue + " -> " + newValue);
            }
        });

        // prints 3 times, each after modification
        manipulate(x,y,z);

        System.out.println("The result after changes with a change listener is: " + nb.doubleValue());
    }

    public static void invalidationListenerCase() {
        SimpleDoubleProperty x = new SimpleDoubleProperty(1);
        SimpleDoubleProperty y = new SimpleDoubleProperty(2);
        SimpleDoubleProperty z = new SimpleDoubleProperty(3);

        NumberBinding nb = makeComputed(x,y,z);

        nb.addListener(new InvalidationListener() {
            @Override public void invalidated(Observable observable) {
                System.out.println("Invalidated");
            }
        });

        // will print only once, when the result is first invalidated
        // note that the result is NOT calculated until it is actually requested
        manipulate(x,y,z);

        System.out.println("The result after changes with an invalidation listener is: " + nb.doubleValue());
    }

常用方法：

    private static NumberBinding makeComputed(final ObservableNumberValue x, final ObservableNumberValue y, final ObservableNumberValue z) {
        return new DoubleBinding() {
            {
                bind(x,y,z);
            }
            @Override protected double computeValue() {
                System.out.println("...CALCULATING...");
                return z.doubleValue() / (x.doubleValue()-y.doubleValue());
            }
        };
    }

    private static void manipulate(SimpleDoubleProperty x, SimpleDoubleProperty y, SimpleDoubleProperty z) {
        System.out.println("Changing z...");
        z.set(13);
        System.out.println("Changing y...");
        y.set(1);
        System.out.println("Changing x...");
        x.set(2);
    }

这个输出是：

...CALCULATING...
Changing z...
...CALCULATING...
ChangeListener: -3.0 -> -13.0
Changing y...
...CALCULATING...
ChangeListener: -13.0 -> Infinity
Changing x...
...CALCULATING...
ChangeListener: Infinity -> 13.0
The result after changes with a change listener is: 13.0

=====================================

...CALCULATING...
Changing z...
Invalidated
Changing y...
Changing x...
...CALCULATING...
The result after changes with an invalidation listener is: 13.0

因此，在第一种情况下，存在过多的计算和infinity个案例。第二次，数据在第一次更改时标记无效，然后仅在需要时重新计算。

The Pulse

如何绑定图形属性，例如某事物的宽度和高度（如你的例子）？似乎JavaFX的基础结构不立即对图形属性应用更改，但根据称为Pulse的信号。脉冲是异步调度的，并且在执行时，将根据节点属性的当前状态更新UI。动画中的每个帧以及UI属性的每次更改都将安排要运行的脉冲。

我不知道你的示例情况会发生什么，初始宽度= 1px且高度= 10 ⁶ px，代码设置宽度= 10 ⁶ px（在一个步骤中，调度脉冲）然后高度= 1px（第二步）。如果第一步没有被处理，第二步是否会发出另一个脉冲？从JavaFX的角度来看，合理的做法是管道只处理1个脉冲事件，但我需要一些参考。但是，即使处理了两个事件，第一个应该处理整个状态变化（宽度和高度），因此在一个可视步骤中发生变化。

开发人员必须对我认为的架构感到满意。假设一个单独的任务（伪代码）：

width = lengthyComputation();
Platform.runLater(node.setWidth(width));
height = anotherLengthyComputation();
Platform.runLater(node.setHeight(height));

我猜测如果第一个脉冲事件有机会运行，那么用户将看到宽度的变化 - 暂停 - 高度的变化。最好把它写成（再次，总是在后台任务中）（伪代码）：

width = lengthyComputation();
height = anotherLengthyComputation();
Platform.runLater(node.setWidth(width));
Platform.runLater(node.setHeight(height));

更新（来自john16384的评论）：根据this，不可能直接听脉冲。但是，可以扩展每个脉冲运行一次的javafx.scene.Parent的某些方法并获得相同的效果。因此，如果不需要更改子树，则可以扩展layoutChildren()，如果子树将被修改，则扩展computePrefHeight(double width) / computePrefWidth(double height)。

Answer 2

这些案例表明数据绑定无法在任何地方使用。它基于事件，因此您最终可以通过竞争条件等事件驱动架构获得所有麻烦......

所以我要说：不要在副作用难以预测和致命的情况下使用它。例如，在您的情况下，坚持使用一种基本方法，该方法根据彼此设置两个属性，并且可以在安全时间调用旧值，甚至可以定期调用，即使是脏检查值。如果你可以一起完成这两个操作，这是一个很小的计算，所以它不应该是一个问题。

数据绑定很棒，但不适用于所有内容。它不是宗教（仍然是一个伟大的工具）。不要过度使用它：聪明的简单性应该适用于此，不要破解它，它会变得很快变得无法辨认。

Answer 3

根据我之前的回答进一步抓取事情，我提出了一些代码，我认为这些代码可以解决问题。它需要改进，因为它只是为了证明原则。

不花费很长时间的昂贵操作

这将是内存分配的情况。它不会（？）花费很长时间，但它很昂贵，从某种意义上说，你不希望发生过多的分配。响应维度更改而运行的代码在主线程中运行（这可能不正确，请更正我）。

import javafx.application.Application;
import javafx.application.Platform;
import javafx.beans.InvalidationListener;
import javafx.beans.Observable;
import javafx.beans.binding.ObjectBinding;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Dimension2D;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class ExpensiveQuickCalculationExample extends Application
{
    @Override
    public void start(final Stage primaryStage) {
        primaryStage.setTitle("Lazy Example");

        Button btn = new Button();
        btn.setText("Manipulate");
        btn.setOnAction(new EventHandler<ActionEvent>() {
            @Override public void handle(ActionEvent event) {
                //////////////////////////////////
                // DIMENSIONS MANIPULATION HERE //
                //////////////////////////////////
                primaryStage.setHeight(150);
                primaryStage.setWidth(150);
            }
        });

        StackPane root = new StackPane();
        root.getChildren().add(btn);
        primaryStage.setScene(new Scene(root, 300, 250));
        primaryStage.show();


        final ObjectBinding<Dimension2D> stageDimBinding = makeWindowDimensionsBinding(primaryStage);
        stageDimBinding.addListener(new InvalidationListener() {
            @Override public void invalidated(Observable observable) {
                System.out.println("---> Dimensions INVALIDATED");
                Platform.runLater(new Runnable() {
                    @Override public void run() {
                        expensiveQuickCalculation(stageDimBinding.get());
                    }
                });
            }
        });
    }

    private ObjectBinding<Dimension2D> makeWindowDimensionsBinding(final Stage stage) {
        return new ObjectBinding<Dimension2D>() {
            {
                bind(stage.widthProperty(), stage.heightProperty());
            }
            @Override
            protected Dimension2D computeValue() {
                System.out.println("Dimensions computed");
                return new Dimension2D(stage.widthProperty().doubleValue(), stage.heightProperty().doubleValue());
            }
        };
    }

    private void expensiveQuickCalculation(Dimension2D d) {
        System.out.println("-=< EXPENSIVE CALCULATION >=-");
    }

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

昂贵，缓慢的操作

与上述情况相反，操作缓慢。我们不想阻止UI线程，因此我们使用javafx.concurrent.Service。使用Thread.sleep()模拟慢速操作，因此请观察控制台并耐心等待：）

import javafx.application.Application;
import javafx.beans.InvalidationListener;
import javafx.beans.Observable;
import javafx.beans.binding.ObjectBinding;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.SimpleObjectProperty;
import javafx.concurrent.Service;
import javafx.concurrent.Task;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Dimension2D;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class ExpensiveSlowCalculationExample extends Application
{
    private static class SlowCalculationTask extends Task<Void>
    {
        private Dimension2D dimension;

        public SlowCalculationTask(Dimension2D dimension) {
            this.dimension = dimension;
        }

        @Override
        protected Void call() throws Exception {
            expensiveSlowCalculation();
            if( !isCancelled() ) {
                /////////////////////////////////////
                //        UPDATE STATE HERE        //
                // I would use Platform.runLater() //
                /////////////////////////////////////
                System.out.println("-=< UPDATING STATE >=-");
            }
            return null;
        }

        private void expensiveSlowCalculation() {
            System.out.println("-=< EXPENSIVE SLOW CALCULATION STARTED " + dimension + ">=-");
            try {
                Thread.sleep(5000);
                System.out.println("-=< EXPENSIVE SLOW CALCULATION DONE >=-");
            }
            catch (InterruptedException e) {
                if( isCancelled() ) System.out.println("-=< EXPENSIVE SLOW CALCULATION *CANCELLED* >=-");
                else throw new RuntimeException(e);
            }
        }
    }

    private static class SlowCalculationService extends Service<Void>
    {
        private ObjectProperty<Dimension2D> dimensions = new SimpleObjectProperty<>();
        public void setDimensions(Dimension2D dimensions) { this.dimensions.set(dimensions); }

        @Override
        protected Task<Void> createTask() {
            return new SlowCalculationTask(dimensions.get());
        }
    }



    private SlowCalculationService calculationService;


    @Override
    public void start(final Stage primaryStage) {
        primaryStage.setTitle("Lazy Example");

        Button btn = new Button();
        btn.setText("Manipulate");
        btn.setOnAction(new EventHandler<ActionEvent>() {
            @Override public void handle(ActionEvent event) {
                //////////////////////////////////
                // DIMENSIONS MANIPULATION HERE //
                //////////////////////////////////
                primaryStage.setHeight(150);
                primaryStage.setWidth(150);
            }
        });

        StackPane root = new StackPane();
        root.getChildren().add(btn);
        primaryStage.setScene(new Scene(root, 300, 250));
        primaryStage.show();


        final ObjectBinding<Dimension2D> stageDimBinding = makeWindowDimensionsBinding(primaryStage);
        stageDimBinding.addListener(new InvalidationListener() {
            @Override public void invalidated(Observable observable) {
                System.out.println("---> Dimensions INVALIDATED");
                startService(stageDimBinding.get());
            }
        });
    }

    private ObjectBinding<Dimension2D> makeWindowDimensionsBinding(final Stage stage) {
        return new ObjectBinding<Dimension2D>() {
            {
                bind(stage.widthProperty(), stage.heightProperty());
            }
            @Override
            protected Dimension2D computeValue() {
                System.out.println("Dimensions computed");
                return new Dimension2D(stage.widthProperty().doubleValue(), stage.heightProperty().doubleValue());
            }
        };
    }

    private void startService(Dimension2D d) {
        if( calculationService == null ) calculationService = new SlowCalculationService();
        calculationService.setDimensions(d);
        calculationService.restart();
    }

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

测试

启动应用程序，然后按按钮。尽管操作取决于宽度和高度，但消息“昂贵的慢速计算启动”，“昂贵的慢速计算完成”出现一次。

然后手动调整窗口大小。您将不可避免地获得更多“昂贵的慢速计算开始”消息。但所有这些操作都将被取消，只有最后一个才能完成。

如何处理相关的数据绑定？

3 个答案:

无效监听器

The Pulse

不花费很长时间的昂贵操作

昂贵，缓慢的操作

测试