精华内容
下载资源
问答
  • java异步调用方法
    千次阅读
    2021-02-26 19:52:24

    我一直在看着

    Go’s goroutines最近,认为在Java有类似的东西会很好。就我已经搜索的常见方法并行化方法调用是做类似的:

    final String x = "somethingelse";

    new Thread(new Runnable() {

    public void run() {

    x.matches("something");

    }

    }).start();

    这不是很优雅。有没有更好的方法这样做?我需要这样的解决方案在项目中,所以我决定实现我自己的包装类周围的异步方法调用。

    我在J-Go发布了我的包装类。但我不知道它是否是一个很好的解决方案。用法很简单:

    SampleClass obj = ...

    FutureResult res = ...

    Go go = new Go(obj);

    go.callLater(res, "intReturningMethod", 10); //10 is a Integer method parameter

    //... Do something else

    //...

    System.out.println("Result: "+res.get()); //Blocks until intReturningMethod returns

    或更少verbose:

    Go.with(obj).callLater("myRandomMethod");

    //... Go away

    if (Go.lastResult().isReady()) //Blocks until myRandomMethod has ended

    System.out.println("Method is finished!");

    在内部,我使用一个实现Runnable的类,并做一些反射工作,以获得正确的方法对象和调用它。

    我想要一些关于我的小库和关于在Java中做这样的异步方法调用的意见。它是安全吗?是否已经有一个更简单的方法?

    更多相关内容
  • java异步调用方法

    千次阅读 2021-11-01 21:15:56
    使用原生的CompletableFuture实现异步操作,加上对lambda的支持,可以说实现异步任务已经发挥到了极致。 @Test public void test2() throws Exception { System.out.println(“main函数开始执行”); ExecutorService...

    1.CompletableFuture

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

    @Test
    public void test2() throws Exception {
    System.out.println(“main函数开始执行”);
    ExecutorService executor = Executors.newFixedThreadPool(2);
    CompletableFuture future = CompletableFuture.supplyAsync(new Supplier() {
    @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函数执行结束”);
    }

    ExecutorService executor = Executors.newFixedThreadPool(2);
    2是线程的个数

    2.新建配置类

    @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使用
    在这里插入图片描述
    启动类上增加@EnableAsync
    方法上增加@Async即可
    在这里插入图片描述

    展开全文
  • 本文给大家分享java多线程实现异步调用方法,感兴趣的朋友跟着脚本之家小编一起学习吧
  • 你知道java异步调用方法都有哪些吗?下面的文章内容,就对这方面的问题做了一下整理,一起来看看java异步调用的方法吧!1、利用Spring的异步方法去执行注:没有返回值在启动类又或者是配置类加上@EnableAsync注解。...

    你知道java异步调用方法都有哪些吗?下面的文章内容,就对这方面的问题做了一下整理,一起来看看java异步调用的方法吧!

    1、利用Spring的异步方法去执行

    注:没有返回值

    在启动类又或者是配置类加上@EnableAsync注解。package me.deweixu.aysncdemo;

    import org.springframework.boot.SpringApplication;

    import org.springframework.boot.autoconfigure.SpringBootApplication;

    import org.springframework.scheduling.annotation.EnableAsync;

    @EnableAsync

    @SpringBootApplication

    public class AysncDemoApplication

    {

    public static void main(String[] args)

    {

    SpringApplication.run(AysncDemoApplication.class, args);

    }

    }

    先将longTimeMethod封装到Spring的异步方法当中。

    这样的方法必须要写在Spring管理的类当中。

    还要注意注解@Async。

    @Async注解能够在方法上使用,也能够在类上,用在类上,对类当中的所有方法起作用。@Servicepublic class AsynchronousService{  @Async

    public void springAsynchronousMethod(){

    longTimeMethod();

    }

    }

    其他类调用该方法。

    注意了,一定要其他的类,假如,在同类中调用,那么是不会生效的。

    至于为什么会这样,大家对Spring AOP的实现原理进行一下了解。@Autowired

    private AsynchronousService asynchronousService;

    public void useAsynchronousMethod()

    {

    //我们需要执行的代码1

    asynchronousService.springAsynchronousMethod();

    //我们需要执行的代码2

    }

    二、原生Future方法//我们需要执行的代码1

    Future future = longTimeMethod2();

    //我们需要执行的代码2

    Integer result = future.get();

    调用longTimeMethod2返回一个Future对象,之后处理需要执行的代码2,到需要返回结果时,直接调用future.get(),就可以获取到返回值。

    再一起来看看如何实现longTimeMethod2。private Future longTimeMethod2()

    {

    //创建线程池

    ExecutorService threadPool = Executors.newCachedThreadPool();

    //获取异步Future对象

    Future future = threadPool.submit(new Callable()

    {

    @Override

    public Integer call() throwsException

    {

    return longTimeMethod();

    }

    });

    return future;

    }

    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("报错啦!!");

    }

    }

    });

    }

    四、Spring的异步方法和Future接收返回值

    将longTimeMethod封装到Spring的异步方法当中。

    这里的异步方法的返回值是Future的实例。

    这个方法必须要写在Spring管理的类当中。

    注意注解@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);

    }

    java异步调用方法你都了解了吧,更多相关内容,请继续来奇Q工具网的java架构师栏目进行了解吧。

    推荐阅读:

    展开全文
  • Java实现异步调用

    2019-03-22 01:34:14
    NULL 博文链接:https://zhaoshijie.iteye.com/blog/798544
  • 主要介绍了Java异步调用转同步方法实例详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java平台,实现异步调用的角色主要三种角色:调用者、取货凭证、真实数据。本篇文章给大家介绍java实现异步调用实例代码,需要的朋友可以参考下
  • Java接口异步调用

    2020-08-26 00:11:43
    主要介绍了Java接口异步调用,下面我们来一起学习一下吧
  • java异步调用的几种方式

    千次阅读 2022-05-24 21:21:40
    一、通过创建新线程 public static void main(String[] args) throws Exception{ System.out.println("主线程 =====>... System.out.println("异步线程 =====> 开始 =====> " + System.currentTim

    一、通过创建新线程

    public static void main(String[] args) throws Exception{
    
        System.out.println("主线程 =====> 开始 =====> " + System.currentTimeMillis());
    
        new Thread(() -> {
            System.out.println("异步线程 =====> 开始 =====> " + System.currentTimeMillis());
            try{
                Thread.sleep(5000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("异步线程 =====> 结束 =====> " + System.currentTimeMillis());
        }).start();
    
        Thread.sleep(2000);
    
        System.out.println("主线程 =====> 结束 =====> " + System.currentTimeMillis());
        
    }
    
    主线程 =====> 开始 =====> 1627893837146
    异步线程 =====> 开始 =====> 1627893837200
    主线程 =====> 结束 =====> 1627893839205
    异步线程 =====> 结束 =====> 1627893842212
    

    我们通过线程休眠来达成主线程执行时间2秒左右,异步线程执行5秒左右的效果。通过打印出来的时间戳倒数第四位(秒位)我们可以看出,两个的线程执行总时间为5秒左右,符合异步执行的特征

    二、通过线程池

    因为异步任务的实现本质的由新线程来执行任务,所以通过线程池的也可以实现异步执行。写法同我们利用线程池开启多线程一样。但由于我们的目的不是执行多线程,而是异步执行任务,所以一般需要另外一个线程就够了。

    因此区别于执行多线程任务的我们常用的newFixedThreadPool,在执行异步任务时,我们用newSingleThreadExecutor 来创建一个单个线程的线程池

    public static void main(String[] args) throws Exception{
    
        System.out.println("主线程 =====> 开始 =====> " + System.currentTimeMillis());
    
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.submit(()->{
            System.out.println("异步线程 =====> 开始 =====> " + System.currentTimeMillis());
            try{
                Thread.sleep(5000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("异步线程 =====> 结束 =====> " + System.currentTimeMillis());
        });
        executorService.shutdown(); // 回收线程池
    
        Thread.sleep(2000);
    
        System.out.println("主线程 =====> 结束 =====> " + System.currentTimeMillis());
        
    }
    
    
    主线程 =====> 开始 =====> 1627895467578
    异步线程 =====> 开始 =====> 1627895467635
    主线程 =====> 结束 =====> 1627895469644
    异步线程 =====> 结束 =====> 1627895472649
    

    三、通过@Async注解

    使用起来也非常简单,将要异步执行的代码封装成一个方法,然后用@Async注解该方法,然后在主方法中直接调用就行

    @Test
    public void mainThread() throws Exception{
    
        System.out.println("主线程 =====> 开始 =====> " + System.currentTimeMillis());
        collectionBill.asyncThread();
        Thread.sleep(2000);
        System.out.println("主线程 =====> 结束 =====> " + System.currentTimeMillis());
    
        Thread.sleep(4000); // 用于防止jvm停止,导致异步线程中断
    }
    @Async
    public void asyncThread(){
        System.out.println("异步线程 =====> 开始 =====> " + System.currentTimeMillis());
        try{
            Thread.sleep(5000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("异步线程 =====> 结束 =====> " + System.currentTimeMillis());
    }
    
    主线程 =====> 开始 =====> 1627897539948
    异步线程 =====> 开始 =====> 1627897539956
    主线程 =====> 结束 =====> 1627897541965
    异步线程 =====> 结束 =====> 1627897544966
    

    有以下两点需要注意:

    1.类似@Tranctional注解,@Async注解的方法与调用方法不能在同一个类中,否则不生效
    2.JUnit框架的设计不考虑多线程场景,所以主线程退出后,子线程也会跟着立即退出,所以可以在后面加多线程休眠时间来观察异步线程的执行情况

    四、通过CompletableFuture

    CompletableFuture是JDK1.8的新特性,是对Future的扩展。CompletableFuture实现了CompletionStage接口和Future接口,增加了异步回调、流式处理、多个Future组合处理的能力

    public static void main(String[] args) throws Exception{
    
        System.out.println("主线程 =====> 开始 =====> " + System.currentTimeMillis());
    
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        CompletableFuture.runAsync(() ->{
            System.out.println("异步线程 =====> 开始 =====> " + System.currentTimeMillis());
            try{
                Thread.sleep(5000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("异步线程 =====> 结束 =====> " + System.currentTimeMillis());
        },executorService);
        executorService.shutdown(); // 回收线程池
    
        Thread.sleep(2000);
    
        System.out.println("主线程 =====> 结束 =====> " + System.currentTimeMillis());
        
    }
    
    主线程 =====> 开始 =====> 1627898354914
    异步线程 =====> 开始 =====> 1627898354977
    主线程 =====> 结束 =====> 1627898356980
    异步线程 =====> 结束 =====> 1627898359979
    
    展开全文
  • 说说Java异步调用的几种方式

    千次阅读 2022-03-17 15:59:09
    这里就涉及的Java异步调用的一个知识。下面本文尝试将Java异步调用的多种方式进行归纳。 一、通过创建新线程 首先的我们得认识到,异步调用的本质,其实是通过开启一个新的线程来执行。如以下例子: public ...
  • Java实现异步调用方法(jdk1.8)

    千次阅读 2020-10-26 16:38:23
    点击上方“秋秋秋影影影”,并“星标置顶” 喜欢我的都关注我了 阅读本文大约需要 30秒 jdk1.8开始的Future 很多时候,我们需要调用一个耗时方法,但是我们并不需要等待它执行完,才继续后面的...
  • JAVA中的异步调用

    千次阅读 2021-03-10 16:17:34
    1.什么是异步调用 异步调用简单理解,就是不阻塞主线程,再开辟另一个线程异步执行 main{ //前置语句 costTime(); //后置语句 } 在上述代码中,主线程按顺序,需要依次执行前置语句,调用costTime函数,该函数...
  • 主要为大家详细介绍了SpringBoot异步调用方法并接收返回值,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要介绍了如何基于回调实现Java异步调用,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java异步方法调用且获取返回结果

    千次阅读 2021-12-23 21:40:41
    目前就只学了一种方法,看了很多,能看明白的好少,自己总结一下: 导包: import org.springframework.beans.factory.annotation.Autowired;...类1:写正常逻辑,含异步方法调用 @Autowired private A
  • java异步调用外部接口

    千次阅读 2020-12-24 14:42:35
    通过SpringBoot-RestTemplate方式调用 1.RestTemplate工具类 package com.singhand.companyadressredis.main.config; import org.apache.http.impl.client.CloseableHttpClient; import org.springframework....
  • java async 异步融合模块,将IO同步多线程处理转换为 单线程异步处理。(使用第三方IO框架的异步模式实现)
  • Java异步调用转同步的5种方式

    千次阅读 2021-02-13 02:14:08
    1、异步和同步的概念同步调用:调用方在调用过程中,持续等待返回结果。...3、异步调用转同步的5种方式1、使用wait和notify方法2、使用条件锁3、Future4、使用CountDownLatch5、使用CyclicBarrier4、...
  • java异步调用方法

    万次阅读 2012-09-20 09:45:48
      1.3更新 优化代码 新增任务持久与恢复功能 任务调用和回调做为一个整体 例子: 1.调用普通方法方法 public static void main(String[] args) { // 初始化异步工作服务
  • Java异步方法调用

    千次阅读 2021-02-12 09:54:57
    很多时候,我们需要调用一个耗时方法,但是我们并不需要等待它执行完,才继续后面的工作,阻塞在这里是一个非常浪费时间的事,那么我们有没有办法解决呢?有!让它异步执行!首先我们先来看看不异步执行的方案,下面...
  • java异步执行多个方法

    万次阅读 2020-02-21 17:06:04
    public static void forget(String name) { for (int i = 0; i < 5; i++) { System.out.println(name + "执行" + i + "次"); } } public static void main(String[] args) { Thread thread = new Thr...
  • java 代码异步执行_Java实现异步调用

    千次阅读 2021-11-25 16:59:32
    // 四、Spring的Async注解 使用spring实现异步需要开启注解,可以使用xml方式或者java config的方式。 xml方式: pool-size="2" 线程池的大小 queue-capacity="100" 排队队列长度 keep-alive="120" 线程保活时间...
  • Java多线程实现异步调用实例。运行Main可以看到结果。main是主线程,另有A,B,C三个线程用不同的时间跑完。
  • java实现异步调用

    万次阅读 2020-07-21 17:21:02
    1、使用线程池的逻辑实现异步调用 package com.ourlang.dataextract.controller; import com.google.common.util.concurrent.ThreadFactoryBuilder; import com.ourlang.dataextract.common.CommonResult; import ...
  • 主要介绍了java 三种调用机制(同步、回调、异步),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 330,968
精华内容 132,387
关键字:

java异步调用方法