Java实现异步的几种方法

一、异步概念

Java是一门面向对象编程语言，对于一个对象或一个方法，如果它需要执行一个比较长的操作可能会阻塞程序，导致程序变慢，用户体验不好。这时我们就需要将这个操作放到另一个线程中去执行，让主程序继续执行下面的逻辑代码，这样就可以实现多线程异步执行。异步执行是一种对资源占用率比较低，提高程序运行效率的方式。

二、Future 异步

Future 是 Java 中并发包里的一个类，可以用来实现异步回调。Future 的特点是，执行 Future.get() 方法时，如果异步操作已经完成，就直接返回结果；如果异步操作没有完成，那么它会等待操作完成再返回结果。

import java.util.concurrent.*;

public class FutureDemo {
    public static void main(String[] args) throws Exception {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        
        Future future = threadPool.submit(() -> {
            // 模拟异步操作
            Thread.sleep(1000);
            return 100;
        });
        
        Integer result = future.get();
        
        System.out.println(result);
        
        threadPool.shutdown();
    }
}

  

三、CompletableFuture 异步

CompletableFuture 是 Java 8 中新增的异步操作类，是对 Future 的增强，支持异步回调、回滚、组合等操作。它的异步任务可以自由地与其他任务组合执行。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {
    public static void main(String[] args) throws Exception {
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            // 模拟异步操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 100;
        });
        
        future.thenAccept((result) -> {
            System.out.println(result);
        });
        
        // 阻塞等待异步任务执行完成
        future.join();
    }
}

  

四、回调函数 Callback

回调函数是指我们预先定义一个方法，然后将这个方法传给异步任务执行，异步任务执行完成后再执行我们预先定义好的回调方法。

public class CallbackDemo {
    public static void main(String[] args) throws Exception {
        asyncMethod((result) -> {
            System.out.println(result);
        });
        
        System.out.println("Main Thread End...");
    }
    
    private static void asyncMethod(Callback callback) {
        new Thread(() -> {
            // 模拟异步操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            callback.onFinish(100);
        }).start();
    }
}

interface Callback {
    void onFinish(Integer result);
}

五、CompletableFuture 组合异步

CompletableFuture 可以与其他 CompletableFuture 对象进行组合异步操作，实现更加复杂的异步操作。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureComposeDemo {
    public static void main(String[] args) throws Exception {
        CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
            // 模拟异步操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 100;
        });
        
        CompletableFuture
    future2 = CompletableFuture.supplyAsync(() -> {
            // 模拟异步操作
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello";
        });
        
        CompletableFuture
     future3 = future1.thenCompose((result) -> {
            return CompletableFuture.supplyAsync(() -> {
                return result + " World";
            });
        });
        
        CompletableFuture
      future4 = future2.thenCombine(future3, (result1, result2) -> {
            return result1 + " " + result2;
        });
        
        future4.thenAccept((result) -> {
            System.out.println(result);
        });
        
        future4.join();
    }
}