Question

我需要创建一个服务（使用Java），该服务接受任务图并并行执行它们，同时考虑这些任务之间的依赖性。

例如，让我们执行6个任务：A，B，C，D，E，F。

依赖项是：

A-> C

B-> C，D

C-> F

D-> E

E-> F

这将创建（可能的）并行执行组：A + B，C + D，E，F。

如果任务执行不成功（返回错误），则将不执行其相关任务。

另一个要求是对任务执行（或失败）产生副作用：将其通知其他服务（这意味着我们也必须将失败任务的依赖项也视为失败？）。

在处理完所有任务（直接成功或失败+依赖失败）后，我想将此“批”标记为已完成（调用另一个服务）。

由于它的异步特性，我考虑过采用反应性方法来使用RxJava。

我对这种方法还很陌生，虽然zip / switchMap与doOnComplete / doOnError结合似乎是一个不错的方向，但我不确定如何在这种情况下使用它们。

很高兴在这里获得一些建议：）

Answer 1

对于根据依存关系图（严格来说是非依赖性非循环图）运行Observable的查询，可以使用concat()和merge()运算符来组成可观察物，以按照给定图运行（DAG）。

在您的示例中，这是如何构建可观察的DAG来并行执行它们的：

package rxtest;

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import rx.Observable;
import rx.schedulers.Schedulers;


public class ReactiveDagTest {
    private static final Logger logger = LoggerFactory.getLogger(ReactiveDagTest.class);
    private static Executor customExecutor = Executors.newFixedThreadPool(20);

    @Test
    public void stackOverflowTest() {
        Observable<Character> a = createObservable('A', 100);
        Observable<Character> b = createObservable('B', 150);
        Observable<Character> c = createObservable('C', 500);
        Observable<Character> d = createObservable('D', 200);
        Observable<Character> e = createObservable('E', 300);
        Observable<Character> f = createObservable('F', 400);

        logger.info("BEGIN");

        // As Observable for B is referred at two places in the graph, it needs to be cached to not to execute twice
        Observable<Character> bCached = b.cache();

        Observable.concat(
                Observable.merge(
                        Observable.concat(
                                Observable.merge(a, bCached),
                                c),
                        Observable.concat(bCached, d, e)),
                f)
                .toBlocking()
                .subscribe(i -> logger.info("Executed : " + i));

        logger.info("END");
    }

    private Observable<Character> createObservable(char c, int sleepMs) {
        Observable<Character> single = Observable.just(c)
                .flatMap(i -> Observable.<Character> create(s -> {
                    logger.info("onSubscribe Start Executing : {}", i);
                    sleep(sleepMs);
                    s.onNext(Character.valueOf(i));
                    s.onCompleted();
                }).subscribeOn(Schedulers.from(customExecutor)));
        return single;
    }

    private void sleep(int ms) {
        try {
            Thread.sleep(ms);
        }
        catch (InterruptedException e) {
        }
    }
}

输出将为

22:19:22.107 [main] INFO rxtest.ReactiveDagTest BEGIN
22:19:22.181 [pool-1-thread-1] INFO rxtest.ReactiveDagTest onSubscribe Start Executing : A
22:19:22.181 [pool-1-thread-2] INFO rxtest.ReactiveDagTest onSubscribe Start Executing : B
22:19:22.284 [main] INFO rxtest.ReactiveDagTest Executed : A
22:19:22.333 [main] INFO rxtest.ReactiveDagTest Executed : B
22:19:22.333 [main] INFO rxtest.ReactiveDagTest Executed : B
22:19:22.333 [pool-1-thread-3] INFO rxtest.ReactiveDagTest onSubscribe Start Executing : C
22:19:22.334 [pool-1-thread-4] INFO rxtest.ReactiveDagTest onSubscribe Start Executing : D
22:19:22.534 [main] INFO rxtest.ReactiveDagTest Executed : D
22:19:22.534 [pool-1-thread-5] INFO rxtest.ReactiveDagTest onSubscribe Start Executing : E
22:19:22.833 [main] INFO rxtest.ReactiveDagTest Executed : C
22:19:22.835 [main] INFO rxtest.ReactiveDagTest Executed : E
22:19:22.835 [pool-1-thread-6] INFO rxtest.ReactiveDagTest onSubscribe Start Executing : F
22:19:23.236 [main] INFO rxtest.ReactiveDagTest Executed : F
22:19:23.236 [main] INFO rxtest.ReactiveDagTest END

如果任务执行不成功（返回错误），则将不执行其相关任务。

在上述解决方案中这是隐式的，如果图形中的任何节点出现故障，则不会执行图形中的其他节点。

依赖图的反应式执行

1 个答案: