清除具有大量形状/多线程的组的最快方法

Question

在我的 JavaFX 项目中，我使用了很多形状（例如 1 000 000）来表示地理数据（例如地块轮廓、街道等）。它们存储在一个组中，有时我必须清除它们（例如，当我加载包含新地理数据的新文件时）。 问题：清除/删除它们需要很多时间。 所以我的想法是在一个单独的线程中删除形状，由于 JavaFX 单线程，这显然不起作用。

这是我正在尝试做的简化代码：

HelloApplication.java

package com.example.javafxmultithreading;

import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.shape.Line;
import javafx.stage.Stage;

import java.io.IOException;

public class HelloApplication extends Application {

    public static Group group = new Group();

    @Override
    public void start(Stage stage) throws IOException {
        FXMLLoader fxmlLoader = new FXMLLoader(HelloApplication.class.getResource("hello-view.fxml"));
        Scene scene = new Scene(fxmlLoader.load());
        stage.setTitle("Hello!");
        stage.setScene(scene);
        stage.show();

        for (int i = 0; i < 1000000; i++) {
            group.getChildren().add(new Line(100, 200, 200, 300));
        }
        HelloController.helloController = fxmlLoader.getController();
        HelloController.helloController.pane.getChildren().addAll(group);
    }

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

HelloController.java

public class HelloController {

    public static HelloController helloController;
    @FXML
    public Pane pane;
    public VBox vbox;

    @FXML
    public void onClearShapes() throws InterruptedException {
        double start = System.currentTimeMillis();
        HelloApplication.group.getChildren().clear();
        System.out.println(System.currentTimeMillis() - start);

        Service<Boolean> service = new Service<>() {
            @Override
            protected Task<Boolean> createTask() {
                return new Task<>() {
                    @Override
                    protected Boolean call() {
                        // Try to clear the children of the group in this thread
                        return true;
                    }
                };
            }
        };
        service.setOnSucceeded(event -> {
            System.out.println("Success");
        });
        service.start();
    }
}

你好-view.fxml

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.geometry.*?>
<?import javafx.scene.control.*?>
<?import javafx.scene.layout.*?>

<VBox fx:id="vbox" alignment="CENTER" prefHeight="465.0" prefWidth="711.0" spacing="20.0"
      xmlns="http://javafx.com/javafx/11.0.2" xmlns:fx="http://javafx.com/fxml/1"
      fx:controller="com.example.javafxmultithreading.HelloController">
    <padding>
        <Insets bottom="20.0" left="20.0" right="20.0" top="20.0"/>
    </padding>
    <Pane fx:id="pane" prefHeight="200.0" prefWidth="200.0"/>
    <Button mnemonicParsing="false" onAction="#onClearShapes" text="Clear shapes"/>
</VBox>

我用group.getChildren().clear()测量了从组中删除不同数量的孩子所花费的时间：

amount of children    |   time
100                       2ms = 0,002s
1 000                     4ms = 0,004s
10 000                    38ms = 0,038s
100 000                   1273ms = 1,2s
1 000 000                 149896ms = 149,896s = ~2,5min

如您所见，所需时间呈指数级增长。 现在想象一下，您必须在 UI 中清除子项，而用户必须等待 2.5 分钟等待应用程序冻结。 此外，在这个简化的示例中，它只是一条简单的线，在“真实”应用程序中，它是一个更复杂的几何图形 -> 需要更多时间。

因此，另一个想法是将组与它的父级窗格“解除绑定”。 因为当它解除绑定时，我可以在另一个线程中删除它。这意味着 1. 用户界面不会冻结 2. 它会更快。 这是尝试：

pane.getChildren().remove(group); // or clear()
// and then clear the group in another thread like above

问题：这种“解除绑定”也需要很多时间。不是 2.5 分钟，而是 0.5 分钟，这仍然是太多了。

另一个想法是创建多个组，因为如您所见，具有 10 000 或 100 000 个元素的组被清除得更快。 这也失败了，因为几个组突然需要更长的时间并且被删除的速度呈指数级增长。 例如，第一个需要 20 秒，第二个需要 10 秒，第三个需要 5 秒等。

长话短说

有没有机会在单独的线程中删除该组的孩子，或者比group.getChildren().clear() 更快？我尝试了所有想到的...

如果我只能在删除时显示一个加载栏，那比仅仅冻结表面并等待 2 分钟要好...

我感谢每一个想法/帮助。

编辑，见 cmets 没有 FXML 的简单示例：

import javafx.scene.Group;
import javafx.scene.shape.Line;

public class Test {

    public static void main(String[] args) {
        Group group = new Group();
        System.out.println("adding lines");
        for (int i = 0; i < 1000000; i++) {
            group.getChildren().add(new Line(100, 200, 200, 300));
        }
        System.out.println("adding done");

        System.out.println("removing starts");
        double start = System.currentTimeMillis();
        group.getChildren().clear();
        System.out.println("removing done, needed time: " + (System.currentTimeMillis() - start));
    }
}

Answer 1

执行时间长的原因是Parent 的每个子对象都使用Parent 的disabled 和treeVisible 属性注册了一个侦听器。 JavaFX 当前的实现方式，这些监听器存储在一个数组中（即一个列表结构）。 添加监听器的成本相对较低，因为新监听器只是简单地插入到数组的末尾，偶尔会调整数组的大小。但是，当您从其Parent 中删除一个子项并删除侦听器时，需要线性搜索数组，以便找到并删除正确的侦听器。这会发生在每个被移除的孩子身上。

因此，当您清除 Group 的子列表时，您将触发对这两个属性的 1,000,000 次线性搜索，总共会产生 2,000,000 次线性搜索。更糟糕的是，删除的子节点可能是从添加的第一个子节点到最后添加的子节点的处理过程，这意味着被删除的侦听器可能始终位于数组的末尾。所以不仅是 2,000,000 次线性搜索，而且是 2,000,000 次最坏情况线性搜索。

至少有两种解决方案/变通方法：

1. 不要显示 1,000,000 个节点。如果可以，请尝试仅显示用户实际可以看到的数据的节点。例如，ListView 和TableView 等虚拟化控件在任何给定时间仅显示大约 1-20 个单元格。

2. 不要清除Group 的子代。相反，只需将旧的Group 替换为新的Group。如果需要，您可以在后台线程中准备新的Group。

   这样做，我用了 3.5 秒的时间在我的电脑上创建了另一个有 1,000,000 个孩子的Group，然后用新的Group 替换旧的Group。但是，由于需要一次渲染所有新节点，因此仍然存在一些延迟峰值。

   如果您不需要填充新的Group，那么您甚至不需要线程。在这种情况下，我的计算机上的交换大约需要 0.27 秒。