Java调用的4种实现方法：采用的异步方法

目录 2.用于执行的异步方法（无返回值） 3.使用的异步方法+接收返回值 4.方法引用

1.使用多线程直接new线程

Thread t = new Thread(){
  @Override
  public void run() {
    longTimeMethod();
  }
};

使用线程池

private ExecutorService executor = Executors.newCachedThreadPool() ;
    public void fun() throws Exception {
        executor.submit(new Runnable(){
            @override
                public void run() {
   编程客栈                 try {
                     //要执行的业务代码，我们这里没有写方法，可以让线程休息几秒进行测试
                        Thread.sleep(10000);
              编程客栈          System.out.print("睡够啦~");
                    }catch(Exception e) {
                        throw new RuntimeException("报错啦！！");
                    }
                }
        });
    }

2.用于执行的异步方法（无返回值）

在启动类或配置类中添加@注解。

package me.deweixu.aysncdemo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
imppiEhqtYYVDort org.springframework.scheduling.annotation.EnableAsync;
@EnableAsync
@SpringBootApplication
public class AysncDemoApplication {
 public static void main(String[] args) {
  SpringApplication.run(AysncDemoApplication.class, args);
 }
}

首先封装异步方法，这个方法一定要写在管理类中，注意注解@Async

@Async 注解可以用在方法上，也可以用在类上，用在类上，作用于类中的所有方法

@Service
public class AsynchronousService{
  @Async
  public void springAsynchronousMethod(){
    longTimeMethod();
  }
}

其他类调用此方法。 这里注意一定要调用其他的类。 如果在同一个类中调用，是不会生效的。具体原因可以去学习AOP的原理

@Autowired
private AsynchronousService asynchronousService;
public void useAsynchronousMethod(){
  //我们需要执行的代码1
  asynchronousService.springAsynchronousMethod();
 //我们需要执行的代码2
}

3.使用的异步方法+接收返回值

先封装到异步方法中，这个异步方法的返回值是一个实例。 这个方法一定要写在托管类中，注意注解@Async。

@Service
public class AsynchronousService{
  @Async
  public Future springAsynchronousMethod(){
    Integer result = longTimeMethod();
    return new AsyncResult(result);
  }
}

其他类调用此方法。 这里注意一定要调用其他的类。 如果在同一个类中调用，则不会生效。

如果调用后收到返回值，如果不对返回值进行操作，则为异步操作，如果进行操作，则转为同步操作。 对返回值的操作完成后，主流程下面的流程会继续进行。

@Autowired
private AsynchronousService asynchronousService;
public void useAsynchronousMethod(){
    Future future = asynchronousService.springAsynchronousMethod();
    future.get(1000, TimeUnit.MILLISECONDS);
}

4.原生方法

//我们需要执行的代码1
Future future = longTimeMethod2();
//我们需要执行的代码2
Integer result = future.get();

可以看出，我们调用返回一个对象（注意，当然不是上面的），然后处理“我们需要执行的代码2”，需要返回结果的时候直接调用.get即可() 得到返回值。 让我们看看如何去做。

private Future longTimeMethod2() {
  //创建线程池
  ExecutorService threadPool = Executors.newCachedThreadPool();
  //获取异步Future对象
  Future future编程客栈 = threadPool.submit(new Callable() {
    @Override
    public Integer call() throwsException {
        return longTimeMethod();
    }
  });
  return future;
}

参考

原文链接：

Java异步调用的四种实现方法，本文到此结束。 更多关于Java异步调用的内容，请搜索我们之前的文章或者继续浏览下面的相关文章。 希望大家以后多多支持！

本文标题：java异步调用的4种实现方法