位置：首页-资讯-后端开发

Java 异步编程：如何提升程序的并发能力？

2023-09-29 01:20

短信预约 -IT技能 免费直播动态提醒

在当今的软件开发中，提高程序的并发能力是至关重要的。随着业务量的增加，单线程处理任务的能力将会受到限制，这时候就需要采用异步编程的方式来提高程序的并发能力。

Java 作为一种面向对象的编程语言，也提供了一些异步编程的机制。在本文中，我们将会介绍一些 Java 中常用的异步编程方式，以及如何利用这些方式来提升程序的并发能力。

一、Java 异步编程的方式

回调函数

回调函数是 Java 中最常用的一种异步编程方式。回调函数是指将一个函数作为参数传递给另一个函数，当另一个函数执行完毕后，回调函数会被调用。在 Java 中，回调函数通常使用接口来实现。

下面是一个简单的示例代码：

public interface Callback {
    void onSuccess(String result);
    void onFailure(Throwable throwable);
}

public class Worker {
    public void doWork(Callback callback) {
        new Thread(() -> {
            try {
                Thread.sleep(5000);
                callback.onSuccess("Work done!");
            } catch (InterruptedException e) {
                callback.onFailure(e);
            }
        }).start();
    }
}

public class Main {
    public static void main(String[] args) {
        Worker worker = new Worker();
        worker.doWork(new Callback() {
            @Override
            public void onSuccess(String result) {
                System.out.println(result);
            }

            @Override
            public void onFailure(Throwable throwable) {
                throwable.printStackTrace();
            }
        });
        System.out.println("Main thread continues running...");
    }
}

在上面的代码中，我们定义了一个回调接口 Callback，并在 Worker 类中实现了一个 doWork() 方法，该方法接受一个 Callback 对象作为参数。在 doWork() 方法中，我们开启了一个新的线程，并在其中休眠了 5 秒钟，然后调用了 onSuccess() 方法，将结果返回给回调函数。

在 Main 类中，我们实例化了一个 Worker 对象，并调用了它的 doWork() 方法，并传入一个匿名的 Callback 对象。在回调函数中，我们打印了工作完成的消息。在这个过程中，主线程会继续运行，直到工作完成后回调函数才会被调用。

回调函数是一种简单而有效的异步编程方式，但是当需要进行多次异步操作时，回调函数的嵌套会使代码变得非常复杂和难以维护。

Future

Future 是 Java 中另一种常用的异步编程方式。Future 是一个接口，它代表了一个异步操作的结果。

下面是一个示例代码：

public class Worker implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(5000);
        return "Work done!";
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<String> future = executorService.submit(new Worker());
        System.out.println("Main thread continues running...");
        String result = future.get();
        System.out.println(result);
        executorService.shutdown();
    }
}

在上面的代码中，我们定义了一个 Worker 类，它实现了 Callable 接口，并重写了 call() 方法。在 call() 方法中，我们休眠了 5 秒钟，并返回了一个字符串。

在 Main 类中，我们使用 ExecutorService 来创建一个单线程的线程池，并使用 submit() 方法将 Worker 对象提交给线程池。submit() 方法返回了一个 Future 对象，该对象代表了异步操作的结果。

在主线程中，我们可以继续执行其他的操作，直到需要异步操作的结果时，我们可以使用 get() 方法来获取异步操作的结果。在获取结果时，如果异步操作还没有完成，get() 方法会一直阻塞，直到操作完成。

Future 是一种简单而有效的异步编程方式，但是它并不能解决回调函数嵌套的问题。

CompletableFuture

CompletableFuture 是 Java 8 中新增的一个类，它提供了一种更加灵活和强大的异步编程方式。CompletableFuture 可以链式地组合多个异步操作，从而避免了回调函数嵌套的问题。

下面是一个示例代码：

public class Main {
    public static void main(String[] args) throws Exception {
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(5000);
                return "Work done!";
            } catch (InterruptedException e) {
                return "Work interrupted!";
            }
        }).thenAccept(result -> System.out.println(result));
        System.out.println("Main thread continues running...");
        Thread.sleep(6000);
    }
}

在上面的代码中，我们使用了 CompletableFuture.supplyAsync() 方法来创建一个异步操作。在 supplyAsync() 方法中，我们开启了一个新的线程，并在其中休眠了 5 秒钟，然后返回了一个字符串。

在 thenAccept() 方法中，我们定义了一个消费者函数，它接受异步操作的结果，并打印了结果。在这个过程中，主线程可以继续运行，直到异步操作完成后，消费者函数才会被调用。

CompletableFuture 可以链式地组合多个异步操作，从而避免了回调函数嵌套的问题。例如，我们可以使用 thenApply() 方法来将一个异步操作的结果传递给另一个异步操作，从而形成一个操作链。

二、Java 异步编程的注意事项

在使用 Java 异步编程时，需要注意以下几点：