Java执行代码中，一个方法里内置调用了A,B，C三个方法，如何保证ABC3个方法顺序执行

在 Java 里，若要在一个方法里确保 A、B、C 三个方法按顺序执行，其实很简单，因为 Java 代码默认就是按顺序逐行执行的。下面为你详细介绍不同情形下的实现方式。

同步方法顺序执行

若 A、B、C 都是同步方法（即执行过程中不会有异步操作），只需在方法里按顺序依次调用这三个方法即可。示例代码如下：

public class SequentialExecution {

    // 方法 A
    public void methodA() {
        System.out.println("执行方法 A");
    }

    // 方法 B
    public void methodB() {
        System.out.println("执行方法 B");
    }

    // 方法 C
    public void methodC() {
        System.out.println("执行方法 C");
    }

    // 主方法，调用 A、B、C 方法
    public void executeSequentially() {
        methodA();
        methodB();
        methodC();
    }

    public static void main(String[] args) {
        SequentialExecution executor = new SequentialExecution();
        executor.executeSequentially();
    }
}

在上述代码中，executeSequentially 方法按顺序依次调用了 methodA、methodB 和 methodC 方法，保证了它们顺序执行。

异步方法顺序执行

若 A、B、C 方法包含异步操作（例如使用 Thread、ExecutorService 或 CompletableFuture），则需要采取额外的手段来确保顺序执行。以下是使用 CompletableFuture 的示例：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class AsyncSequentialExecution {

    // 异步方法 A
    public CompletableFuture<Void> methodA() {
        return CompletableFuture.runAsync(() -> {
            System.out.println("执行方法 A");
            try {
                Thread.sleep(1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }

    // 异步方法 B
    public CompletableFuture<Void> methodB() {
        return CompletableFuture.runAsync(() -> {
            System.out.println("执行方法 B");
            try {
                Thread.sleep(1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }

    // 异步方法 C
    public CompletableFuture<Void> methodC() {
        return CompletableFuture.runAsync(() -> {
            System.out.println("执行方法 C");
            try {
                Thread.sleep(1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }

    // 主方法，保证异步方法顺序执行
    public void executeSequentially() {
        methodA()
           .thenCompose(v -> methodB())
           .thenCompose(v -> methodC())
           .exceptionally(ex -> {
                ex.printStackTrace();
                return null;
            })
           .join();
    }

    public static void main(String[] args) {
        AsyncSequentialExecution executor = new AsyncSequentialExecution();
        executor.executeSequentially();
    }
}

在这个例子中，methodA、methodB 和 methodC 都是异步方法，它们返回 CompletableFuture 对象。借助 thenCompose 方法，可以确保前一个异步任务完成后再执行下一个任务，从而实现顺序执行。

异常处理

无论是同步还是异步方法，都要妥善处理可能出现的异常，避免程序因异常而崩溃。在异步方法中，可使用 exceptionally 方法处理异常。