java - 如何等到所有一系列嵌套的 CompletableFuture 都完成？

Question

我有一个增强现实应用程序，其中ARObject有一个 POJO：

  class ARObject {
    CompletableFuture<Texture> texture;
    CompletableFuture<Material> material;
    ModelRenderable renderable;

    void setTexture(CompletableFuture<Texture> texture) {
      this.texture = texture;
    }

    CompletableFuture<Texture> getTexture() {
      return texture;
    }

    void setMaterial(CompletableFuture<Material> material) {
      this.material = material;
    }

    CompletableFuture<Material> getMaterial() {
      return material;
    }
  }

场景是实时合成的。在该过程中，Texture需要构建对象，然后Material基于对象构建Texture对象。一旦Material准备就绪，就ShapeFactory可以使用 来生成实际的 AR 对象（作为 form Renderable）。这意味着构建逻辑包含两个CompletableFuture相互嵌套的 AR 对象：

for (ARObject arObject : arObjects) {
  Texture.Builder textureBuilder = Texture.builder();
  textureBuilder.setSource(context, arObject.resourceId);
  CompletableFuture<Texture> texturePromise = textureBuilder.build();  // Future #1
  arObject.setTexture(texturePromise);
  texturePromise.thenAccept(texture -> {
    CompletableFuture<Material> materialPromise =
            MaterialFactory.makeOpaqueWithTexture(context, texture);  // Future #2
    arObject.setMaterial(materialPromise);
  });
}

完成场景构建的一种方法是等到所有的CompletableFutures 都完成后，ShapeFactory才能进入该步骤。

我尝试.get()在Futures 上使用，但这不仅会完全破坏异步调用提供的并行性，而且还会锁定应用程序，因为我认为它会导致 UI 线程上的等待。

Arrays.stream(arObjectList).forEach(a -> {
  try {
    a.getTexture().get();
  } catch (ExecutionException | InterruptedException e) {
    Log.e(TAG, "Texture CompletableFuture waiting problem " + e.toString());
  }
});
Arrays.stream(arObjectList).forEach(a -> {
  try {
    a.getMaterial().get();
  } catch (ExecutionException | InterruptedException e) {
    Log.e(TAG, "Material CompletableFuture waiting problem " + e.toString());
  }
});

我将构建过程分解为几个在调用链中相互调用的函数。链条如下：

1. populateScene
2. afterTexturesLoaded
3. afterTexturesSet
4. waitForMaterials
5. afterMaterialsLoaded

  private void afterMaterialsLoaded() {
    // Step 3: composing scene objects
    // Get a handler that can be used to post to the main thread
    Handler mainHandler = new Handler(context.getMainLooper());
    for (ARObject arObject : arObjectList) {
      try {
        Material textureMaterial = arObject.getMaterial().get();

        RunnableShapeBuilder shapeBuilder = new RunnableShapeBuilder(arObject, this, textureMaterial);
        mainHandler.post(shapeBuilder);
      }
      catch (ExecutionException | InterruptedException e) {
        Log.e(TAG, "Scene populating exception " + e.toString());
      }
    }
  }

  private Long waitForMaterials() {
    while (!Stream.of(arObjectList).allMatch(arObject -> arObject.getMaterial() != null)) {
      try {
        Thread.sleep(100);
      } catch (InterruptedException e) {
      }
    }
    return 0L;
  }

  private void afterTexturesSet() {
    boolean materialsDone = Stream.of(arObjectList).allMatch(arObject -> arObject.getMaterial() != null && arObject.getMaterial().isDone());
    // If any of the materials are not loaded, then recurse until all are loaded.
    if (!materialsDone) {
      CompletableFuture<Texture>[] materialPromises =
        Stream.of(arObjectList).map(ARObject::getMaterial).toArray(CompletableFuture[]::new);

      CompletableFuture.allOf(materialPromises)
        .thenAccept((Void aVoid) -> afterMaterialsLoaded())
        .exceptionally(
          throwable -> {
            Log.e(TAG, "Exception building scene", throwable);
            return null;
          });
    } else {
      afterMaterialsLoaded();
    }
  }

  private void afterTexturesLoaded() {
    // Step 2: material loading
    CompletableFuture materialsSetPromise = CompletableFuture.supplyAsync(this::waitForMaterials);
    CompletableFuture.allOf(materialsSetPromise)
      .thenAccept((Void aVoid) -> afterTexturesSet())
      .exceptionally(
        throwable -> {
          Log.e(TAG, "Exception building scene", throwable);
          return null;
        });
  }

  /**
   * Called when the AugmentedImage is detected and should be rendered. A Sceneform node tree is
   * created based on an Anchor created from the image.
   */
  @SuppressWarnings({"AndroidApiChecker", "FutureReturnValueIgnored"})
  void populateScene() {
    // Step 1: texture loading
    boolean texturesDone = Stream.of(arObjectList).allMatch(arObject -> arObject.getTexture() != null && arObject.getTexture().isDone());
    // If any of the textures are not loaded, then recurse until all are loaded.
    if (!texturesDone) {
      CompletableFuture<Texture>[] texturePromises =
        Stream.of(arObjectList).map(ARObject::getTexture).toArray(CompletableFuture[]::new);

      CompletableFuture.allOf(texturePromises)
        .thenAccept((Void aVoid) -> afterTexturesLoaded())
        .exceptionally(
          throwable -> {
            Log.e(TAG, "Exception building scene", throwable);
            return null;
          });
    } else {
      afterTexturesLoaded();
    }
  }

这有几个问题。首先：它仍然有点搞砸异步性质。在理想情况下，相应的材质纹理对将独立加载并从其他对生成。在这个最新版本中，执行流程中有很多会合点，这与理想的独立场景并不对应。第二：我什至无法避免waitForMaterials我丑陋的一步Thread.sleep()。第三：代码总体上仍然失败，因为在最后一步从加载的纹理和材料最终构建形状时，我遇到了错误java.lang.IllegalStateException: Must be called from the UI thread.。因此，我提出了另一个转折：RunnableShapeBuilder. 没有例外，但场景中仍然没有显示任何内容，而代码变得更加复杂。

  class RunnableShapeBuilder implements Runnable {
    ARObject arObject;
    AnchorNode parentNode;
    Material textureMaterial;

    RunnableShapeBuilder(ARObject arObject, AnchorNode parentNode, Material textureMaterial) {
      this.arObject = arObject;
      this.parentNode = parentNode;
      this.textureMaterial = textureMaterial;
    }

    @Override
    public void run() {
      arObject.renderable = ShapeFactory.makeCube(
        new Vector3(0.5f, 1, 0.01f),
        new Vector3(0.0f, 0.0f, 0.0f),
        textureMaterial
      );
      ...
    }
  }

标签： javaasynchronouscompletable-future

Answer 1

答案是：我不必等待这些嵌套CompletableFuture的 s。虽然我的场景变得更加复杂，但我认为我必须等到 3D 材质和纹理的构建完成。问题出在一个离题的地方：虽然我设置了 AR 对象的锚点。AR 对象的锚点来自命中测试，我需要将锚点的父级设置为 AR 场景。这最后一步在一些重构过程中丢失了，如果发生这种情况，没有任何警告，只是 AR 场景上没有任何显示。

专注于问题本身：我强烈不建议尝试等待任何问题，因为它只会导致痛苦和痛苦。寻求不同的解决方案。