RxFlowable wait for concurrent processing to finish

ReactiveTest.java

import io.reactivex.rxjava3.core.Flowable;
import io.reactivex.rxjava3.core.Maybe;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.core.Scheduler;
import io.reactivex.rxjava3.parallel.ParallelFlowable;
import io.reactivex.rxjava3.schedulers.Schedulers;
import org.apache.commons.lang3.tuple.ImmutablePair;

import java.time.LocalTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ReactiveTest {
    public static <T> T intenseCalculation(T value) throws InterruptedException {
        Thread.sleep(ThreadLocalRandom.current().nextInt(50));
        return value;
    }

    public static void flow1() throws InterruptedException {
        Flowable<Integer> vals = Flowable.range(1, 50);
        ParallelFlowable<ImmutablePair<Integer, Double>> parallelFlowable = vals.parallel(6) //.parallel()
                .runOn(Schedulers.io())
                .map(i -> {
                    intenseCalculation(i);
                    out.println(Thread.currentThread().getName() + " Processing: " + i);
                    return new ImmutablePair<>(i, i * Math.random());
                });
        Flowable<ImmutablePair<Integer, Double>> seqFlow = parallelFlowable.sequential();
        seqFlow
                .observeOn(Schedulers.computation())
                .blockingStream()
                .forEach(out::println);
    }

    public static void main(String[] args) throws InterruptedException {
        flow1();
    }
}