回调函数和future对比

异步返回结果后，主线程怎么获取

在异步编程中，主线程需要等待异步操作完成后才能获取结果。有多种方式可以实现这个目标，下面介绍两种常见的方式：

回调函数

回调函数是一种常见的异步编程模式，可以在异步操作完成后自动调用指定的函数。在回调函数中，可以将异步操作的结果传递给主线程，以便主线程获取结果。

以下是一个使用回调函数获取异步操作结果的示例代码：
1.定义callback接口，其中含有onComplete方法，作用是接收子线程的执行结果
2.定义doAsync方法，用于新建子线程和调用

public class AsyncExample {
    public static void main(String[] args) {
        AsyncOperation asyncOperation = new AsyncOperation();
        asyncOperation.doAsync(new Callback() {
            @Override
            public void onComplete(String result) {
                System.out.println("异步操作完成，结果为：" + result);
            }
        });

        // 主线程可以继续执行其他操作
        System.out.println("主线程继续执行其他操作");

        // 等待异步操作完成
        // ...
    }
}

class AsyncOperation {
    public void doAsync(Callback callback) {
        new Thread(() -> {
            // 模拟异步操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 返回结果
            String result = "Hello, world!";
            callback.onComplete(result);
        }).start();
    }
}

interface Callback {
    void onComplete(String result);
}

在上面的示例代码中，首先创建了一个异步操作对象AsyncOperation，并调用其doAsync方法执行异步操作。在doAsync方法中，创建了一个新线程模拟异步操作，并在操作完成后调用回调函数onComplete，将结果传递给主线程。

在主线程中，可以继续执行其他操作，而不必等待异步操作完成。当异步操作完成后，回调函数会自动被调用，主线程就可以在回调函数中获取异步操作的结果。

Future对象

Future对象是另一种常见的异步编程模式，可以在异步操作完成后获取结果。Future对象表示一个异步操作的未来结果，可以在主线程中使用get方法等待异步操作完成，并获取操作的结果。

以下是一个使用Future对象获取异步操作结果的示例代码：

public class AsyncExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        AsyncOperation asyncOperation = new AsyncOperation();
        Future<String> future = asyncOperation.doAsync();

        // 主线程可以继续执行其他操作
        System.out.println("主线程继续执行其他操作");

        // 等待异步操作完成
        String result = future.get();
        System.out.println("异步操作完成，结果为：" + result);
    }
}

class AsyncOperation {
    public Future<String> doAsync() {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(() -> {
            // 模拟异步操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 返回结果
            return "Hello, world!";
        });

        executor.shutdown();
        return future;
    }
}

在上面的示例代码中，首先创建了一个异步操作对象AsyncOperation，并调用其doAsync方法执行异步操作。在doAsync方法中，创建了一个线程池，并使用submit方法提交一个异步任务，返回一个Future对象表示异步操作的结果。

在主线程中，可以继续执行其他操作，而不必等待异步操作完成。当需要获取异步操作的结果时，可以调用Future对象的get方法等待异步操作完成，并获取操作的结果。需要注意的是，调用get方法会阻塞主线程，直到异步操作完成。如果异步操作未完成，get方法会一直阻塞。因此，在使用Future对象时，需要谨慎处理阻塞问题。

callback和future各自优点和使用场景

回调函数和Future对象都是常见的异步编程模式，用于在异步操作完成后获取结果。它们各有优点和适用场景，下面分别介绍。

回调函数的优点：

1. 灵活性高：回调函数可以在异步操作完成后自动调用，不需要等待主线程获取结果。这使得回调函数非常灵活，可以在异步操作完成后执行任意代码。

2. 可读性好：回调函数可以将异步操作的结果直接传递给主线程，使得代码结构清晰，易于理解。

3. 适用于多个异步操作：如果需要执行多个异步操作，并在所有操作完成后执行某些代码，可以使用回调函数实现。

回调函数的适用场景：

1. 异步操作完成后需要执行复杂的逻辑。

2. 需要同时执行多个异步操作，并在所有操作完成后执行某些代码。

3. 需要在异步操作完成后立即获取结果。

Future对象的优点：

1. 可控性高：Future对象可以在主线程中使用get方法等待异步操作完成，并获取操作的结果。这使得Future对象的控制性非常高，可以精确控制异步操作的执行和结果的获取。

2. 可组合性好：Future对象可以通过thenApply、thenCompose等方法组合多个异步操作，形成复杂的异步操作链。

3. 可取消性好：Future对象可以通过cancel方法取消异步操作，避免不必要的资源浪费。

Future对象的适用场景：

1. 异步操作完成后需要立即获取结果。

2. 需要组合多个异步操作，形成复杂的异步操作链。

3. 需要精确控制异步操作的执行和结果的获取。

总的来说，回调函数和Future对象都是常见的异步编程模式，各有优点和适用场景。在实际开发中，可以根据具体的需求选择合适的模式。如果需要执行复杂的逻辑或同时执行多个异步操作，可以使用回调函数；如果需要精确控制异步操作的执行和结果的获取，可以使用Future对象。