Java中如何实现两段异步代码顺序执行及后续收尾？

这个问题在Java的UI场景里确实容易懵，毕竟UI线程的任务调度有自己的规则，我给你几个简洁靠谱的实现方式，按需选择：

方案一：利用UI线程消息队列的天然顺序性（最简洁） #

因为post()方法会把Runnable加入UI线程的消息队列，队列里的任务是严格按顺序执行的，所以我们可以在操作1的最后一个任务执行完毕后，直接启动操作2；再在操作2的最后一个任务里触发收尾代码。

修改后的代码如下：

// 启动操作1
private void startOperation1() {
    int operationCnt = 10;
    for (int i = 0; i < operationCnt; i++) {
        final int curOperation = i;
        post(new Runnable() {
            @Override
            public void run() {
                // 执行操作1的UI逻辑
                // 比如更新控件、绘制内容等

                // 当执行到操作1的最后一个任务时，启动操作2
                if (curOperation == operationCnt - 1) {
                    startOperation2();
                }
            }
        });
    }
}

// 启动操作2
private void startOperation2() {
    int operationCnt2 = 10;
    for (int i = 0; i < operationCnt2; i++) {
        final int curOperation = i;
        post(new Runnable() {
            @Override
            public void run() {
                // 执行操作2的UI逻辑
                // 比如刷新数据、重置状态等

                // 当执行到操作2的最后一个任务时，执行收尾代码
                if (curOperation == operationCnt2 - 1) {
                    finishAllTasks();
                }
            }
        });
    }
}

// 最终收尾代码
private void finishAllTasks() {
    // 这里写两段操作都完成后的逻辑
    // 比如弹出提示、释放资源等
}

优点： #

• 不需要额外的同步工具，代码极简
• 完全贴合UI线程的调度规则，没有线程阻塞问题

适用场景： #

• 操作1的所有任务是连续post到UI队列的，中间不会插入其他优先级更高的UI任务

方案二：用CountDownLatch做可靠同步（适合复杂场景） #

如果你的场景中，操作1的任务可能被其他UI任务打断插入，或者需要严格保证所有操作1任务执行完毕后再启动操作2，可以用CountDownLatch来做同步：

// 启动操作1
private void startOperation1() {
    int operationCnt = 10;
    CountDownLatch operation1Latch = new CountDownLatch(operationCnt);

    for (int i = 0; i < operationCnt; i++) {
        post(new Runnable() {
            @Override
            public void run() {
                // 执行操作1的UI逻辑
                // ...

                // 任务完成，计数器减1
                operation1Latch.countDown();
            }
        });
    }

    // 在后台线程等待操作1全部完成
    new Thread(() -> {
        try {
            operation1Latch.await(); // 阻塞直到计数器归0
            // 操作1完成，回到UI线程启动操作2
            post(this::startOperation2);
        } catch (InterruptedException e) {
            // 处理中断，恢复线程中断状态
            Thread.currentThread().interrupt();
        }
    }).start();
}

// 启动操作2
private void startOperation2() {
    int operationCnt2 = 10;
    CountDownLatch operation2Latch = new CountDownLatch(operationCnt2);

    for (int i = 0; i < operationCnt2; i++) {
        post(new Runnable() {
            @Override
            public void run() {
                // 执行操作2的UI逻辑
                // ...

                // 任务完成，计数器减1
                operation2Latch.countDown();
            }
        });
    }

    // 在后台线程等待操作2全部完成
    new Thread(() -> {
        try {
            operation2Latch.await();
            // 操作2完成，回到UI线程执行收尾
            post(this::finishAllTasks);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }).start();
}

// 最终收尾代码
private void finishAllTasks() {
    // 两段操作完成后的逻辑
    // ...
}

优点： #

• 绝对保证操作1全部完成后才启动操作2，不受其他UI任务干扰
• 逻辑清晰，适合复杂的多任务调度场景

注意事项： #

• 后台线程只是用来等待，不会阻塞UI线程，避免ANR
• 记得处理中断异常，保证线程状态正确

总结 #

如果是普通的UI顺序任务，方案一足够简洁好用；如果是需要强同步的复杂场景，方案二更可靠。你可以根据自己的业务需求选择~

内容的提问来源于stack exchange，提问作者SudoPlz