java 代码异步执行_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(300);

                                } 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 future =
                executor.submit(
                        new Callable() {
                            @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的支持，可以说实现异步任务已经发挥到了极致。

// 两个线程的线程池
ExecutorService executor = Executors.newFixedThreadPool(2);
// jdk1.8之前的实现方式
CompletableFuture<String> future =
        CompletableFuture.supplyAsync(
                new Supplier<String>() {
                    @Override
                    public String get() {
                        System.out.println("开始执行任务!");
                        try {
                            // 模拟耗时操作
                            Thread.sleep(20000);
                            System.out.println("我是一个特别耗时的任务");
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        return "耗时任务结束完毕!";
                    }
                },
                executor);

// 采用lambada的实现方式
future.thenAccept(e -> System.out.println(e + " ok"));

System.out.println("不等上面了，我先跑了"); //

四、Spring的Async注解

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

xml方式：

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);

}