本教程教你如何使用Java实现异步调用。

一、创建线程

@Test

public void test0() throws Exception {

  System.out.println("main函数开始执行");

  Thread thread=new Thread(new Runnable() {

    @Override

    public void run() {

      System.out.println("===task start===");

      try {

        Thread.sleep(5000);

      } catch (InterruptedException e) {

        e.printStackTrace();

      }

      System.out.println("===task finish===");

    }

  });

  thread.start();

  System.out.println("main函数执行结束");

}

二、Future

jdk8之前的实现方式，在JUC下增加了Future，从字面意思理解就是未来的意思，但使用起来却着实有点鸡肋，并不能实现真正意义上的异步，获取结果时需要阻塞线程，或者不断轮询。

@Test

public void test1() throws Exception {

    System.out.println("main函数开始执行");

    ExecutorService executor = Executors.newFixedThreadPool(1);

    Future<Integer> future = executor.submit(new Callable<Integer>() {

        @Override

        public Integer call() throws Exception {

            System.out.println("===task start===");

            Thread.sleep(5000);

            System.out.println("===task finish===");

            return 3;

        }

    });

    //这里需要返回值时会阻塞主线程，如果不需要返回值使用是OK的。倒也还能接收

    //Integer result=future.get();

    System.out.println("main函数执行结束");

    System.in.read();

}

三、CompletableFuture

使用原生的CompletableFuture实现异步操作，加上对lambda的支持，可以说实现异步任务已经发挥到了极致。

@Test

public void test2() throws Exception {

    System.out.println("main函数开始执行");

    ExecutorService executor = Executors.newFixedThreadPool(2);

    CompletableFuture<Integer> future = CompletableFuture.supplyAsync(new Supplier<Integer>() {

        @Override

        public Integer get() {

            System.out.println("===task start===");

            try {

                Thread.sleep(5000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println("===task finish===");

            return 3;

        }

    }, executor);

    future.thenAccept(e -> System.out.println(e));

    System.out.println("main函数执行结束");

}

四、Spring的Async注解

使用spring实现异步需要开启注解，可以使用xml方式或者Java config的方式。

xml方式：

<task:annotation-driven executor="executor" />

<task:executor id="executor"

        pool-size="2" 线程池的大小

        queue-capacity="100" 排队队列长度 

        keep-alive="120" 线程保活时间（单位秒）

        rejection-policy="CALLER_RUNS" 对拒绝的任务处理策略 />

java方式：

@EnableAsync

public class MyConfig {

    @Bean

    public TaskExecutor executor(){

        ThreadPoolTaskExecutor executor=new ThreadPoolTaskExecutor();

        executor.setCorePoolSize(10); //核心线程数

        executor.setMaxPoolSize(20);  //最大线程数

        executor.setQueueCapacity(1000); //队列大小

        executor.setKeepAliveSeconds(300); //线程最大空闲时间

        executor.setThreadNamePrefix("fsx-Executor-"); //指定用于新创建的线程名称的前缀。

        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        return executor;

    }

}

（1）@Async

@Test

public void test3() throws Exception {

    System.out.println("main函数开始执行");

    myService.longtime();

    System.out.println("main函数执行结束");

}

 @Async

public void longtime() {

    System.out.println("我在执行一项耗时任务");

    try {

        Thread.sleep(5000);

    } catch (InterruptedException e) {

        e.printStackTrace();

    }

    System.out.println("完成");

}

（2）AsyncResult

如果需要返回值，耗时方法返回值用AsyncResult包装。

@Test

public void test4() throws Exception {

    System.out.println("main函数开始执行");

    Future future=myService.longtime2();

    System.out.println("main函数执行结束");

    System.out.println("异步执行结果："+future.get());

}

 @Async

public Future longtime2() {

    System.out.println("我在执行一项耗时任务");

    try {

        Thread.sleep(8000);

    } catch (InterruptedException e) {

        e.printStackTrace();

    }

    System.out.println("完成");

    return new AsyncResult<>(3);

}