java 代码异步执行_Java实现异步调用

布满荆棘的人生 2023-10-02 16:42 103阅读 0赞

一、创建线程

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