Java实现异步的四种方式

Posted 2022-11-27 黄 坤

目录

• • 1、开线程
  • 2、Future
  • 3、CompletableFuture
  • 4、Async注解

1、开线程

/**
 * 开线程
 */
public class ThreadTest 

    public void test() 
        new Thread(() -> 
            //做处理
            try 
                Thread.sleep(1000);
             catch (InterruptedException e) 
                e.printStackTrace();
            
        ).start();
    

2、Future

/**
 * Future
 */
public class FutureTest 
    public void test() throws ExecutionException, InterruptedException 
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        Future<String> submit = executorService.submit(new Callable<String>() 
            @Override
            public String call() throws Exception 
                //做处理
                Thread.sleep(1000);
                return "hello";
            
        );

        //如果需要返回值的话，会阻塞主线程。
        String s = submit.get();
    

3、CompletableFuture

/**
 * CompletableFuture
 */
public class CompletableFutureTest 
    public void test() 
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        CompletableFuture<String> c = CompletableFuture.supplyAsync(new Supplier<String>() 
            @Override
            public String get() 
                //做处理
                try 
                    Thread.sleep(1000);
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
                return "hello";
            
        , executorService);

        c.thenAccept(item -> System.out.println(item));
    

4、Async注解

/**
 * Async注解：要在Spring中使用。
 * 1、首先在启动类上开启注解@EnableAsync
 * 2、然后需要异步操作的方法上加上@Async
 */
public class AsyncTest 
    @Async
    public void test() throws InterruptedException 
        //做处理
        Thread.sleep(1000);
    

    /**
     * 如果需要返回值的话，通过AsyncResult进行封装
     */
    @Async
    public Future<String> testReturn() throws InterruptedException 
        //做处理
        Thread.sleep(1000);
        return new AsyncResult<>("hello");
    

原文链接