Question

我知道.net，我可以在任务中做这样的事情，

task.ContinueWith((v) =>
        {
            Operation1();
        })

            .ContinueWith((V) =>
            {
                Operation2();
            },  

            Cancel.Token, TaskContinuationOptions.None, Scheduler);
        return task;

或使用Aysnc / Await功能逐一执行操作。

我怎样才能用Java做到这一点？

我已经阅读了AsyncTask的材料，但是在doInBackground中完成操作之后，仍然会同步调用onPostExecute（Result）中的方法。

所以我的问题是如何逐个操作一系列不同的功能？

Answer 1

你可以覆盖onPostExecute(result)，这与C＃相比似乎很尴尬。您可以选择使用lambdas作为Java 8的早期适配器，因此您可以实现相同的语法：

.ContinueWith(v -> operation1())

Answer 2

如果您对Rx感到满意，可以使用RxJava。它不漂亮，但它有效：

final ExecutorService executor = Executors.newCachedThreadPool();

final ConnectableObservable<?> result = Observable.concat(
    Observable.defer(
        new Func0<Observable<?>>() {
            @Override
            public Observable<?> call() {
                return Observable.from(
                    executor.submit(
                        new Runnable() {
                            @Override public void run() { task(1); }
                        }
                    )
                );
            }
        }
    ),
    Observable.defer(
        new Func0<Observable<?>>() {
            @Override
            public Observable<?> call() {
                return Observable.from(
                    executor.submit(
                        new Runnable() {
                            @Override public void run() { task(2); }
                        }
                    )
                );
            }
        }
    )
).replay();

result.connect();

可能有更好的方法，但我不太了解RxJava API，因为我使用自己的Rx for Java实现。

要点是：

concat()运算符以串行方式连接多个可观察序列。在这种情况下，每个序列只是一个元素：任务的结果。
defer()运算符可防止在有人订阅之前安排每项任务。在这种情况下，当前面的任务/序列终止时会发生这种情况。
from()运算符会将Future<?>转换为Observable<?>。
replay()运算符创建一个可连接的observable，确保任务序列只执行一次，即使有多个订阅者也是如此。结果将被捕获，因此后期订阅者仍将收到它。
调用connect()启动任务序列。

如何逐个操作一系列不同的功能？

2 个答案: