Java异步调用的探究

一、使用Future实现异步调用

Java中提供了Future接口及其实现类FutureTask。使用Future和FutureTask，能够在调用一个方法时立即返回，不必等待方法执行完毕，可以通过Future对象获得方法执行结果。这就是常见的异步调用。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class FutureDemo {
    public static void main(String[] args) {
        Callable callable = () -> {
            Thread.sleep(2000);//休眠2秒模拟耗时任务
            return 100;
        };
        FutureTask
    futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();
        try {
            System.out.println("异步调用返回结果:" + futureTask.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

   
  

上述代码中，通过Callable创建一个耗时任务。FutureTask的作用是将Callable封装成一个Future实例，通过Future实例能够获得异步调用结果。

二、使用CompletableFuture实现异步调用

JDK1.8之后，Java提供了新的异步编程API——CompletableFuture，用来处理异步编程中的复杂场景。

CompletableFuture是Future的实现，而且它提供了更多的操作方法，如组合、转化和聚合等。

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

public class CompletableFutureDemo {
    public static void main(String[] args) {
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);//休眠2秒模拟耗时任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 100;
        });
        try {
            System.out.println("异步调用返回结果:" + future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

  

上述代码中，使用CompletableFuture.supplyAsync()方法创建异步任务，该方法会在ForkJoinPool.commonPool()线程池中执行，返回一个CompletableFuture实例。

三、异步调用异常处理

在异步调用过程中，异常的处理要比同步调用更复杂。异步调用的结果是Future或者CompletableFuture实例，需要使用try...catch方法，捕获执行过程中可能发生的异常。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class FutureDemo {
    public static void main(String[] args) {
        Callable callable = () -> {
            if (Math.random() < 0.5) {
                throw new RuntimeException("调用失败");
            } else {
                Thread.sleep(2000);//休眠2秒模拟耗时任务
                return 100;
            }
        };
        FutureTask
    futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();
        try {
            System.out.println("异步调用返回结果:" + futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
            System.out.println("调用失败原因:" + e.getCause().getMessage());
        }
    }
}

   
  

上述代码中，Callable随机抛出了一个RuntimeException异常。由于异步执行结果在get()方法处才返回，因此get()方法需要捕获ExecutionException异常，并且通过getCause()方法获取原始的RuntimeException异常。

四、使用线程池实现异步调用

在异步调用中，如果需要大量地创建线程，可能会引起线程创建过多的问题。在这种情况下，可以使用线程池优化资源消耗和性能问题。

import java.util.concurrent.*;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(1);

        Future future = executorService.submit(() -> {
            try {
                Thread.sleep(2000);//休眠2秒模拟耗时任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 100;
        });

        executorService.shutdown();

        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
            System.out.println("调用失败原因:" + e.getCause().getMessage());
        }
    }
}

  

上述代码中，使用Executors.newFixedThreadPool()方法创建线程池，之后使用submit()方法创建异步任务。submit()方法返回的是Future实例，可以通过get()方法获取异步任务执行结果。

五、使用注解实现异步调用

Spring中提供了@Async注解支持异步方法执行，只需在需要异步执行的方法上加上@Async注解，就可以异步执行该方法。

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {
    @Async
    public void asyncMethod() {
        try {
            Thread.sleep(2000);//休眠2秒模拟耗时任务
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("异步方法执行完成。");
    }
}

上述代码中，@Async注解表示异步方法执行。在Spring容器中，异步方法会在新的线程中执行，不会阻塞其他任务的执行。

六、结语

本文介绍了Java中异步调用的多种方式，包括使用Future、CompletableFuture、线程池、注解等。异步调用能够提高系统的并发处理能力，避免了阻塞线程等问题，但是也需要开发者注意异常处理等问题，以便保证系统的高可用性。