精华内容
下载资源
问答
  • 前言 先来说一下对异步和同步的理解: ...我们主要来说一下 Java 如何将异步调用转为同步。换句话说,就是需要在异步调用过程中,持续阻塞至获得调用结果。 不卖关子,先列出五种方法,然后一一举例说明...

    前言

    先来说一下对异步和同步的理解:

    同步调用:调用方在调用过程中,持续等待返回结果。
    异步调用:调用方在调用过程中,不直接等待返回结果,而是执行其他任务,结果返回形式通常为回调函数。

    其实,两者的区别还是很明显的,这里也不再细说,

    我们主要来说一下 Java 如何将异步调用转为同步。换句话说,就是需要在异步调用过程中,持续阻塞至获得调用结果。
    不卖关子,先列出五种方法,然后一一举例说明:

    1. 使用 wait 和 notify 方法
    2. 使用条件锁
    3. Future
    4. 使用 CountDownLatch
    5. 使用 CyclicBarrier

    构造一个异步调用

    首先,写 demo 需要先写基础设施,这里的话主要是需要构造一个异步调用模型。异步调用类:

    AsyncCall.java

    package AsyncCalltoSynchro;
    
    import java.util.Random;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    
    //异步调用类
    public class AsyncCall {
        //生成随机数
        private Random random = new Random(System.currentTimeMillis());
        //执行器
        private ExecutorService tp = Executors.newSingleThreadExecutor();
    
        //demo1,2,4,5调用方法
        public void call(BaseDemo demo){
    
            //开启线程
            new Thread(()->{
                //0-10随机数
                long res = random.nextInt(10);
    
                try {
                    Thread.sleep(res*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
                //异步调用
                demo.callback(res);
            }).start();
    
    
        }
    
        //demo3调用方法
        public Future<Long> futureCall(){
    
            return tp.submit(()-> {
                long res = random.nextInt(10);
    
                try {
                    Thread.sleep(res*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return res;
            });
    
        }
    
        //关闭线程池
        public void shutdown(){
    
            tp.shutdown();
    
        }
    
    }

    我们主要关心 call( ) 方法,这个方法接收了一个 demo 参数,并且开启了一个线程,在线程中执行具体的任务,并利用 demo callback( ) 方法进行回调函数的调用。大家注意到了这里的返回结果就是一个 [0,10) 的长整型,并且结果是几,就让线程 sleep 多久 —— 这主要是为了更好地观察实验结果,模拟异步调用过程中的处理时间。
    至于 futureCall( ) shutdown( ) 方法,以及线程池 tp 都是为了 demo3 利用 Future 来实现做准备的。
    demo 的基类: BaseDemo.java

    package AsyncCalltoSynchro;
    
    public abstract class BaseDemo {
    
        //异步调用类实例
        protected AsyncCall asyncCall = new AsyncCall();
    
        //抽象
        public abstract void callback(long response);
    
        //发起异步调用
        public void call(){
            System.out.println("发起调用");
            asyncCall.call(this);
            System.out.println("调用返回");
        }
    
    }
    

    BaseDemo 非常简单,里面包含一个异步调用类的实例,另外有一个 call( ) 方法用于发起异步调用,当然还有一个抽象方法 callback( ) 需要每个 demo 去实现的 —— 主要在回调中进行相应的处理来达到异步调用转同步的目的。

     使用 wait 和 notify 方法

    这个方法其实是利用了锁机制,直接贴代码:

    package AsyncCalltoSynchro;
    
    /**
     * 锁机制
     */
    public class Demo1 extends BaseDemo {
    
        private final Object lock = new Object();
    
        @Override
        public void callback(long response) {
            System.out.println("得到结果");
            System.out.println(response);
            System.out.println("调用结束");
    
            synchronized (lock) {
                //唤醒正在等待的所有线程
                lock.notifyAll();
            }
    
        }
    
        public static void main(String[] args) {
    
            Demo1 demo1 = new Demo1();
    
            demo1.call();
    
            synchronized (demo1.lock){
                try {
                    demo1.lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
            System.out.println("主线程内容");
    
        }
    }

    可以看到在发起调用后,主线程利用 wait( ) 进行阻塞,等待回调中调用 notify( ) 或者 notifyAll( ) 方法来进行唤醒。注意,和大家认知的一样,这里 wait( ) notify( ) 都是需要先获得对象的锁的。在主线程中最后我们打印了一个内容,这也是用来验证实验结果的,如果没有 wait( ) notify( ),主线程内容会紧随调用内容立刻打印;而像我们上面的代码,主线程内容会一直等待回调函数调用结束才会进行打印。
    没有使用同步操作的情况下,打印结果:

    而使用了同步操作后:

    使用条件锁

    和方法一的原理类似:

    package AsyncCalltoSynchro;
    
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * 条件锁finally
     */
    public class Demo2 extends BaseDemo {
    
        private final Lock lock = new ReentrantLock();
    
        private final Condition con = lock.newCondition();
    
        @Override
        public void callback(long response) {
    
            System.out.println("得到结果");
            System.out.println(response);
            System.out.println("调用结束");
    
            lock.lock();
            
            try {
                //线程唤醒
                con.signal();
            }finally {
                lock.unlock();
            }
    
        }
    
        public static void main(String[] args) {
    
            Demo2 demo2 = new Demo2();
    
            demo2.call();
    
            demo2.lock.lock();
    
            try {
                //Causes the current thread to wait until it is signalled or interrupted.
                demo2.con.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                demo2.lock.unlock();
            }
            System.out.println("主线程内容");
        }
    }

    基本上和方法一没什么区别,只是这里使用了条件锁,两者的锁机制有所不同。

    实验结果

    Future

    使用 Future 的方法和之前不太一样,我们调用的异步方法也不一样。

    package AsyncCalltoSynchro;
    
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.Future;
    
    public class Demo3 {
    
        private AsyncCall asyncCall = new AsyncCall();
    
        public Future<Long> call(){
    
            Future<Long> future = asyncCall.futureCall();
    
            asyncCall.shutdown();
    
            return future;
    
        }
    
        public static void main(String[] args) {
    
            Demo3 demo3 = new Demo3();
    
            System.out.println("发起调用");
            Future<Long> future = demo3.call();
            System.out.println("返回结果");
    
            while (!future.isDone() && !future.isCancelled());
    
            try {
                System.out.println(future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
    
            System.out.println("主线程内容");
    
        }
    }

    我们调用 futureCall( ) 方法,方法中会想线程池 tp 提交一个 Callable( ),然后返回一个 Future,这个 Future 就是我们 demo3 call 中得到的,得到 future 对象之后就可以关闭线程池啦,调用 asyncCall( ) shutdown( ) 方法。关于关闭线程池这里有一点需要注意,我们回过头来看看 asyncCall( ) shutdown( ) 方法:

        //关闭线程池
        public void shutdown(){
    
            tp.shutdown();
    
        }

    发现只是简单调用了线程池的 shutdown( ) 方法,然后我们说注意的点,这里最好不要用 tp shutdownNow( ) 方法,该方法会试图去中断线程中中正在执行的任务;也就是说,如果使用该方法,有可能我们的 future 所对应的任务将被中断,无法得到执行结果。
    然后我们关注主线程中的内容,主线程的阻塞由我们自己来实现,通过 future isDone( ) isCancelled( ) 来判断执行状态,一直到执行完成或被取消。随后,我们打印 get 到的结果。

    实验结果

    使用 CountDownLatch

    使用 CountDownLatch 或许是日常编程中最常见的一种了,也感觉是 相对优雅 的一种:

    package AsyncCalltoSynchro;
    
    import java.util.concurrent.CountDownLatch;
    
    public class Demo4 extends BaseDemo {
    
        private final CountDownLatch countDownLatch = new CountDownLatch(1);
    
        @Override
        public void callback(long response) {
    
            System.out.println("得到结果");
            System.out.println(response);
            System.out.println("调用结束");
    
            countDownLatch.countDown();
    
        }
    
        public static void main(String[] args) {
    
            Demo4 demo4 = new Demo4();
    
            demo4.call();
    
            try {
                demo4.countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            System.out.println("主线程内容");
    
        }
    }

    正如大家平时使用的那样,此处在主线程中利用 CountDownLatch await( ) 方法进行阻塞,在回调中利用 countDown( ) 方法来使得其他线程 await 的部分得以继续运行。
    当然,这里和 demo1 demo2 中都一样,主线程中阻塞的部分,都可以设置一个超时时间,超时后可以不再阻塞。

    实验结果

    使用 CyclicBarrier

    CyclicBarrier 的情况和 CountDownLatch 有些类似:

    package AsyncCalltoSynchro;
    
    import java.util.concurrent.BrokenBarrierException;
    import java.util.concurrent.CyclicBarrier;
    
    public class Demo5 extends BaseDemo {
    
        private CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
    
    
        @Override
        public void callback(long response) {
    
            System.out.println("得到结果");
            System.out.println(response);
            System.out.println("调用结束");
    
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
    
        }
    
        public static void main(String[] args) {
    
            Demo5 demo5 = new Demo5();
    
            demo5.call();
    
            try {
                demo5.cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
    
            System.out.println("主线程内容");
    
        }
    }

    实验结果

    大家注意一下,CyclicBarrier CountDownLatch 仅仅只是类似,两者还是有一定区别的。比如,一个可以理解为做加法,等到加到这个数字后一起运行;一个则是减法,减到 0 继续运行。一个是可以重复计数的;另一个不可以等等等等。

    另外,使用 CyclicBarrier 的时候要注意两点:

    • 初始化的时候,参数数字要设为 2,因为异步调用这里是一个线程,而主线程是一个线程,两个线程都 await 的时候才能继续执行,这也是和 CountDownLatch 区别的部分。
    • 第二点也是关于初始化参数的数值的,和这里的 demo 无关,在平时编程的时候,需要比较小心,如果这个数值设置得很大,比线程池中的线程数都大,那么就很容易引起死锁了。

    总结

    综上,就是本次需要说的几种方法了。事实上,所有的方法都是同一个原理,也就是在调用的线程中进行阻塞等待结果,而在回调中函数中进行阻塞状态的解除。

     

    展开全文
  • java异步调用方法

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

    http://code.google.com/p/asyn4j/wiki/user_guide

     

    1.3更新

    1. 优化代码
    2. 新增任务持久与恢复功能
    3. 任务调用和回调做为一个整体

    例子:

    1.调用普通方法

    主方法

            public static void main(String[] args) {
                    // 初始化异步工作服务
                    AsynService anycService = AsynServiceImpl.getService(300, 3000L, 100, 100,1000);
                    //异步工作缓冲处理器
                    anycService.setWorkQueueFullHandler(new CacheAsynWorkHandler(100));
                    //服务启动和关闭处理器
                    anycService.setServiceHandler(new FileAsynServiceHandler());
                    //异步工作执行异常处理器
                    anycService.setErrorAsynWorkHandler(new DefaultErrorAsynWorkHandler());
                    // 启动服务
                    asynService.init();
                    // 异步回调对象
                    AsynCallBack back = new TargetBack();
                    for (int i = 0; i < 1000; i++) {
                            // 添加加异步工作- TargetService 的 test 方法 ,方法参数 asynej+ i
                            asynService.addWork(TargetService.class, "test", new Object[] { "asyn4j" + i },new TargetBack());
                            //实例化目标对象再调用
                           // TargetService targetService = new TargetService ();
                           //asynService.addWork(
                    //              targetService , "test",new Object[] { "asyn4j" + i }, new TargetBack());
                           
                    }
            }

    回调方法

    //回调需继承AsynCallBack抽象类
    public class TargetBack extends AsynCallBack {
    
            @Override
            public void doNotify() {
                    //输出异步方法调用结果
                    System.out.println(this.methodResult);
    
            }
    
    }

    目标对象

    //异步调用对象
    public class TargetService {
            public String test(String name){
                    System.out.println(name +" test is execute!");
                    return name;
            }
    
    }

    2.调用Spring Bean的异步方法

    调用 Spring testBean 的 myName 方法

       applicationContext.xml 加入
        <bean id="springBeanUtil" class="com.googlecode.asyn4j.spring.AsynSpringUtil">
            </bean>
    
      <bean id="asynService" class="com.googlecode.asyn4j.spring.AsynServiceFactoryBean">
                <!--设置自定义相关参数-->
                <property name="maxCacheWork" value="100"></property>
                    <property name="addWorkWaitTime" value="2000"></property>
                    <property name="workThreadNum" value="3"></property>
                    <property name="callbackThreadNum" value="2"></property>
                     <property name="closeServiceWaitTime" value="2000"></property>
                    <!--添加相关处理器-->
                    <property name="errorAsynWorkHandler">
                            <bean class="com.googlecode.asyn4j.core.handler.DefaultErrorAsynWorkHandler"/>
                </property>
                    <property name="workQueueFullHandler">
                            <bean class="com.googlecode.asyn4j.core.handler.CacheAsynWorkHandler"/>
               </property>
    <property name="asynServiceHandler">
                            <bean class="com.googlecode.asyn4j.core.handler.FileAsynServiceHandler"/>
               </property>
       </bean>
    
    
      public class TestMain {
            
            public AsynService asynService;
    
            public void setAsynService(AsynService asynService) {
                    this.asynService = asynService;
            }
            
            public void maintest(){
                    for(int i=0;i<10000;i++){
                            asynService.addWork("testBean", "myName",new Object[] { "panxiuyan" + i });
                    }
            }
    
    }

    3.相关处理器

    3.1异步工作缓冲器--(当工作队列工作数超过maxCacheWork时由处里器处理)

    AsynService anycService = AsynServiceImpl.getService(300, 3000L, 100,
                                    100);
                    anycService.setWorkQueueFullHandler(new CacheAsynWorkHandler(100));
                    anycService.init();
    当工作队列中的工作超过300个时,异步工作将由CacheAsynWorkHandler处理;
    自定义处理器 继承 WorkQueueFullHandler 抽象类

    3.2服务启动和关闭处理器 --(当服务启动和关闭调用)

          anycService.setCloseHander(new FileAsynServiceHandler("c:/asyn4j.data"));
    设置c:/asyn4j.data为持久化文件 FileAsynServiceHandler 是 AsynServiceHandler  的一个例子将任务持久化到文件,当系统启动时加载文件内容到内存,关闭时将未执行的任务持久化到文件。大家可以参考源码将任务持久化到别外的地方(memcached)
    自定义处理器 继承  AsynServiceHandler  抽象类

    3.3异步工作执行异常处理器 --(当工作执行出现异常时处理器)

        anycService.setErrorAsynWorkHandler(new DefaultErrorAsynWorkHandler());
    自定义处理器 继承 ErrorAsynWorkHandler 抽象类

    3.4所有处理器为可选配置,建议根据自己的业务继承相关的类实现自己的处理器

    4.异步工作优级

    分成三个等级WorkWeight.LOW,WorkWeight.MIDDLE, WorkWeight.HIGH 默认优先级为WorkWeight.MIDDLE 。

    API说明

    一.默认构造函数

       AsynServiceImpl.getService();

    采用的默认参数为,

     

    1. (maxCacheWork)最大工作队列缓存工作数 – 300(默认值)
    2. (addWorkWaitTime)当工作队列满时添加工作等待时间-- Long.MAX_VALUE(默认值)
    3. (workThreadNum)异步工作执行线程池大小  ---- CPU核数/2 +1(默认值)
    4. (callBackThreadNum)回调执行线程池大小  --- CPU核数/2(默认值)
    5. (closeServiceWaitTime) 服务关闭等待时间  ---- 60000s(默认值)

    二.自定义参数构造函数,参数顺序对应前面的说明

     AsynServiceImpl.getService (1000, 1000L, 3, 2,60 * 1000);

    AsynServiceImpl 是线程安全的,可以初始化一个实例,所有程序再引用.

    三.设置缓存工作队列处理器(在init方法调用前设置)

     public void setWorkQueueFullHandler(WorkQueueFullHandler workQueueFullHandler);

    系统有一个默认的处理器  CacheAsynWorkHandler 建议实现自己的处理器,需实现 addAsynWork,process 方法 。process建议启动一个守护线程监听.

    四.启动服务

     public void init(); 

    五.添加异步工作API

     /**
         * 添加异步工作
         * @param tagerObject -- 目标对象(可以是 Class,Object,String(spring))
         * @param method  -- 目标方法
         */
        public void addWork(Object tagerObject, String method);
    
        /**
         * 添加异步工作
         * @param tagerObject -- 目标对象(可以是 Class,Object,String(spring))
         * @param method -- 目标方法
         * @param params -- 目标方法参数
         */
        public void addWork(Object tagerObject, String method,Object[] params);
    
        /**
         * 添加异步工作
         * 
         * 
         * @param tagerObject -- 目标对象(可以是 Class,Object,String(spring))
         * @param method -- 目标方法
         * @param asynCallBack --回调对象
         * @param params -- 目标方法参数
         */
        public void addWork(Object tagerObject, String method,Object[] params, AsynCallBack asynCallBack);
    
        
        /**
         * 添加异步工作
         * 
         * 
         * @param tagerObject -- 目标对象(可以是 Class,Object,String(spring))
         * @param method -- 目标方法
         * @param asynCallBack --回调对象
         * @param params -- 目标方法参数
         * @param weight -- 工作权重
         
         */
        public void addWork(Object tagerObject, String method, Object[] params,AsynCallBack asynCallBack, WorkWeight weight);
        
        
        /**
         * 添加异步工作
         * @param tagerObject -- 目标对象(可以是 Class,Object,String(spring))
         * @param method -- 目标方法
         * @param asynCallBack --回调对象
         * @param params -- 目标方法参数
         * @param weight -- 工作权重
         * @param cache --  如果目标对象为class,实例化后是否缓存
         */
        public void addWork(Object tagerObject, String method, Object[] params, AsynCallBack asynCallBack, WorkWeight weight,
                boolean cache);
    
    
        /**
         *  Spring 添加异步工作
         * 
         * @param target -- 目标对象BeanName
         * @param method -- 目标方法
         * @param asynCallBack --回调对象
         * @param params -- 目标方法参数
         * @param weight -- 工作权重
         */
        public void addWorkWithSpring( String target, String method,Object[] params, AsynCallBack asynCallBack, WorkWeight weight);
    
        /**
         * 添加异步工作 
         * 
         * @param asynWork -- 异步工作实例
         */
        public void addAsynWork(AsynWork asynWork);
            

    六.获取运行状态信息

    /**
             * 
             * 获取运行状态MAP
             * @return
             */
            public Map<String,Integer> getRunStatMap();
    
       Map key说明
       total:累计接收异步工作数
       execute:执行异步工作数
       callback:执行回调数
            /**
             *  获取运行状态字符信息
             * @return
             */
            public String getRunStatInfo();

    七. 调用基于Spring Bean的异步方法

    1.applicationContext.xml 加入

    <bean id="springBeanUtil" class="com.googlecode.asyn4j.spring.AsynSpringUtil">
            </bean>

    使用下列方法添加异步工作

       asynService.addWork("testBean", "myName",new Object[] { "asyn4j" + i });

    八.创建基于Spring 的依赖Bean

    asynService spring bean 工厂

       <bean id="asynService" class="com.googlecode.asyn4j.spring.AsynServiceFactoryBean">
                <!--设置自定义相关参数-->
                <property name="maxCacheWork" value="100"></property>
                    <property name="addWorkWaitTime" value="2000"></property>
                    <property name="workThreadNum" value="3"></property>
                    <property name="callbackThreadNum" value="2"></property>
                    <!--添加相关处理器-->
                    <property name="errorAsynWorkHandler">
                            <bean class="com.googlecode.asyn4j.core.handler.DefaultErrorAsynWorkHandler"/>
                </property>
                    <property name="workQueueFullHandler">
                            <bean class="com.googlecode.asyn4j.core.handler.CacheAsynWorkHandler"/>
               </property>
       </bean>

    九.关闭服务

       /**
         * 关闭服务等待 waitTime 秒
         * @ wait time
         */
        public void close(long waitTime);
        
        /**
         * 关闭服务等待1分钟
         */
        public void close();

    十.注意

    查找异步工作目标方法时,无法区分方法同名的并且参数是继承关系的方法.

     

    展开全文
  • Java异步调用模式

    千次阅读 2017-01-11 16:36:58
    Java异步调用模式 在长期的Java客户端开发中,最常见的一个客户端调用模式就是Java的异步调用。所谓异步调用其实就是实现一个可无需等待被调用函数的返回值而让操作继续运行的方法。在Java语言中,简单的讲就是另启...

    Java异步调用模式

    在长期的Java客户端开发中,最常见的一个客户端调用模式就是Java的异步调用。所谓异步调用其实就是实现一个可无需等待被调用函数的返回值而让操作继续运行的方法。在Java语言中,简单的讲就是另启一个线程来完成调用中的部分计算,使调用继续运行或返回,而不需要等待计算结果。但调用者仍需要取线程的计算结果。虽然在1.5以前从异步线程中取得返回结果需要自己精心设计,但从JDK1.5开始引入了Future接口(FutureTask类)从异步执行的线程中取得返回值。
    Future 表示异步计算的结果,它提供了检查计算是否完成的方法,以等待计算的完成,并获取计算的结果。FutureTask类是Future接口方法的一个基本实现,是一种可以取消的异步计算任务,计算是通过Callable接口来实现的。

    FutureTask有下面几个重要的方法:

           1. get()   阻塞一直等待执行完成拿到结果

           2. get(int timeout, TimeUnit timeUnit)  阻塞一直等待执行完成拿到结果,如果在超时时间内,没有拿到抛出异常

           3. isCancelled()  是否被取消

           4. isDone()   是否已经完成

           5. cancel(boolean mayInterruptIfRunning)  试图取消正在执行的任务

    Callable和Runnable有几点不同:

    • Callable规定的方法是call(),而Runnable规定的方法是run().
    • Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。
    • call()方法可抛出异常,而run()方法是不能抛出异常的。
    运行Callable任务可拿到一个Future对象,通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果。
    举一个例子说明如何使用Future对象,如下:

    public class MyFutureTaskTest {
        public static void main(String[] args) {
            ExecutorService executor = Executors.newCachedThreadPool();
            FutureTask<String> future = new FutureTask<String>(new Callable<String>() {
                public String call() throws Exception{ //建议抛出异常
                    try {
                        Thread.sleep(5* 1000);
                        return "Hello Welcome!";
                    }
                    catch(Exception e) {
                        throw new Exception("Callable terminated with Exception!"); // call方法可以抛出异常
                    }
                }
            });
            executor.execute(future);
            long t = System.currentTimeMillis();
            try {

    //            String result = future.get(3000, TimeUnit.MILLISECONDS); //取得结果,同时设置超时执行时间为5秒。
                String result = future.get(); //取得结果,同时设置超时执行时间为5秒。
                System.err.println("result is " + result + ", time is " + (System.currentTimeMillis() - t));
            } catch (InterruptedException e) {
                future.cancel(true);
                System.err.println("Interrupte time is " + (System.currentTimeMillis() - t));
            } catch (ExecutionException e) {
                future.cancel(true);
                System.err.println("Throw Exception time is " + (System.currentTimeMillis() - t));
    //        } catch (TimeoutException e) {
    //            future.cancel(true);
    //            System.err.println("Timeout time is " + (System.currentTimeMillis() - t));
            } finally {
                executor.shutdown();
            }

        }
    }

    运行结果如下:

     result is Hello Welcome!, time is 5000

    如果设置了超时时间,则运行结果如下:

    Timeout time is 3000

     可以看出设置超时时间的影响。

    再如一个多个运行任务的例子:

    public class MyAsyncExample implements Callable {
        private int num;

        public MyAsyncExample(int aInt) {
            this.num = aInt;
        }

        public String call() throws Exception {
            boolean resultOk = false;
            if (num == 0) {
                resultOk = true;
            } else if (num == 1) {
                while (true) { //infinite loop
                    System.out.println("looping....");
                    Thread.sleep(3000);
                }
            } else {
                throw new Exception("Callable terminated with Exception!"); 
            }
            if (resultOk) {
                return "Task done.";
            } else {
                return "Task failed";
            }
        }

        public static void main(String[] args) {
            //定义几个任务
            MyAsyncExample call1 = new MyAsyncExample(0);
            MyAsyncExample call2 = new MyAsyncExample(1);
            MyAsyncExample call3 = new MyAsyncExample(2);
            //初始任务执行工具。
            ExecutorService es = Executors.newFixedThreadPool(3);
            //执行任务,任务启动时返回了一个Future对象,
            Future future1 = es.submit(call1);
            Future future2 = es.submit(call2);
            Future future3 = es.submit(call3);
            try {
                //任务1正常执行完毕,future1.get()会返回线程的值
                System.out.println(future1.get());
                //任务2进行一个死循环,调用future2.cancel(true)来中止此线程。
                Thread.sleep(3000);
                System.out.println("Thread 2 terminated? :" + future2.cancel(true));
                //任务3抛出异常,调用future3.get()时会引起异常的抛出
                System.out.println(future3.get());
            } catch (ExecutionException ex) {
                ex.printStackTrace();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

     运行结果如下:

    looping....
    Task done.
    java.util.concurrent.ExecutionException: java.lang.Exception: Callable terminated with Exception!
     at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:222)
    looping....
     at java.util.concurrent.FutureTask.get(FutureTask.java:83)
    Thread 2 terminated? :true
     at org.jevo.future.sample.MyAsyncExample.main(MyAsyncExample.java:57)
     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
     at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
     at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
     at java.lang.reflect.Method.invoke(Method.java:597)
     at com.intellij.rt.execution.application.AppMain.main(AppMain.java:90)
    Caused by: java.lang.Exception: Callable terminated with Exception!
     at org.jevo.future.sample.MyAsyncExample.call(MyAsyncExample.java:30)
     at org.jevo.future.sample.MyAsyncExample.call(MyAsyncExample.java:13)
     at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)
     at java.util.concurrent.FutureTask.run(FutureTask.java:138)
     at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
     at java.lang.Thread.run(Thread.java:662)

    以上是对Future模型的例子。异步调用在Swing中应该十分广泛,当客户端调用一个'重'的服务端操作时,我们常采用这种方式。Swing中存在一个Future的实现——SwingWorker,这使我们十分方便地在客户端开发中使用异步调用,详细使用参见API文档。下面附一个不使用Future来实现取得异步调用的代码,如下:

    public abstract class AsyncWorker {
        private Object value;  //the running result
        private boolean finished = false;

        private static class ThreadVar {
            private Thread thread;

            ThreadVar(Thread t) {
                thread = t;
            }

            synchronized Thread get() {
                return thread;
            }

            synchronized void clear() {
                thread = null;
            }
        }

        private ThreadVar threadVar;

        /**
         * 返回当前线程运行结果。
         */
        protected synchronized Object getValue() {
            return value;
        }

        /**
         * 设置当前线程运行结果
         */
        private synchronized void setValue(Object x) {
            value = x;
        }

        /**
         * 调用都创建计算逻辑,将运算结果返回
         */
        public abstract Object construct();

        public void finished() {
            finished = true;
        }

        public boolean isFinished() {
            return finished;
        }

        public void interrupt() {
            Thread t = threadVar.get();
            if (t != null) {
                t.interrupt();
            }
            threadVar.clear();
        }

        public void stop() {
            Thread t = threadVar.get();
            if(t!=null) {
                t.stop();
            }
            threadVar.clear();
        }

        /**
         * 返回 construct方法运行结果。
         */
        public Object get() {
            while (true) {
                Thread t = threadVar.get();
                if (t == null) {
                    return getValue();
                }
                try {
                    t.join();
                }
                catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return null;
                }
            }
        }


        public AsyncWorker() {
            final Runnable doFinished = new Runnable() {
                public void run() {
                    finished();
                }
            };

            Runnable doConstruct = new Runnable() {
                public void run() {
                    try {
                        setValue(construct());
                    }
                    finally {
                        threadVar.clear();
                    }

                    SwingUtilities.invokeLater(doFinished);
                }
            };

            Thread t = new Thread(doConstruct);
            threadVar = new ThreadVar(t);
        }

        /**
         * Start the worker thread.
         */
        public void start() {
            finished = false;
            Thread t = threadVar.get();
            if (t != null) {
                t.start();
            }
        }

        public static void main(String[] args) {
            AsyncWorker worker = new AsyncWorker() {
                public Object construct() {
                    try {
                        Thread.sleep(3*1000);
                    }
                    catch(Exception e){}
                    return "hello world";

                }

                public void finished() {
                    super.finished();
                    //取线程运行返回的结果
    //                Object obj = this.get();
    //                System.err.println("return is " + obj);
                }
            };

            long t = System.currentTimeMillis();
            worker.start();
            Object obj = worker.get(); //取得运行结果
            System.err.println("return is " + obj + ", time = " + (System.currentTimeMillis() - t));

        }
    }

    在上述代码中,调用者只需要扩展AsyncWorker类定义可计算的逻辑,并将逻辑结果返回。返回结果会保存在一变量中。当调用者调用返回结果时,如果计算还未完成,将调用Thread.join()阻塞线程,直到计算结果返回。用法上是不是与FutureTask相似?在Swing异步调用中,还需要结合等待对话框来表示计算运行进程,从而使运行界面显示更加友好。 

    再看一下线程的join方法,我们知道线程可被Object.wait、Thread.join和Thread.sleep三种方法之一阻塞,当接收到一个中断异常(InterruptedException)时,可提早地终结被阻塞状态。Thread.join的使用情况却有所不同:我们对一些耗时运算,常启用一个主线程来生成并启动一些子线程,在子线程中进行耗时的运算,当主线程继续处理完其他的事务后,需要调用子线程的处理结果,这个时候就要使用join();。Joint方法将使主线程等待子线程运行结束,即join()方法后的代码,只有等到子线程运行结束后才能被执行。参考下例:

    public class ChildThread extends Thread {
        public ChildThread() {
            super("ChildThread");
        }

        public void run() {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " start.");
            try {
                for (int i = 0; i < 5; i++) {
                    System.out.println(threadName + " loop at " + i);
                    Thread.sleep(1000);
                }
                System.out.println(threadName + " end.");
            } catch (Exception e) {
                System.out.println("Exception from " + threadName + ".run");
            }
        }
    }

     

    public class ParentThread extends Thread {
        ChildThread t1;

        public ParentThread(ChildThread t1) {
            super("ParentThread");
            this.t1 = t1;
        }

        public void run() {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " start.");
            try {
                t1.join();   //ChildThread 线程t1结束后,才能运行此行代码后的代码。
                System.out.println(threadName + " end.");
            } catch (Exception e) {
                System.out.println("Exception from " + threadName + ".run");
            }
        }

        public static void main(String[] args) {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " start.");
            ChildThread t1 = new ChildThread();
            ParentThread t = new ParentThread(t1);
            try {
                t1.start();
                Thread.sleep(2000);
                t.start();
                t.join();//此处注释后,将直接运行到结束代码. 注释此处代码,比较运行结果
            } catch (Exception e) {
                System.out.println("Exception from main");
            }
            System.out.println(threadName + " end!");
        }

    }

    在t.join()被注释前运行结果如下:

    main start.
    ChildThread start.
    ChildThread loop at 0
    ChildThread loop at 1
    ParentThread start.
    ChildThread loop at 2
    ChildThread loop at 3
    ChildThread loop at 4
    ChildThread end.
    ParentThread end.
    main end!

    当t.join()被注释后运行结果如下: 

    main start.
    ChildThread start.
    ChildThread loop at 0
    ChildThread loop at 1
    main end!
    ParentThread start.
    ChildThread loop at 2
    ChildThread loop at 3
    ChildThread loop at 4
    ChildThread end.
    ParentThread end.

    可见ParentThread线程仍等待ChildThread线程运行结束后才运行完毕,而Main线程与ParentThread线程的运行并没有保持等待。

    展开全文
  • java 异步调用

    千次阅读 2012-09-27 16:32:22
    在异步执行的方法前面加上注解@async 异步执行的方法必须单独抽到一个类中 并且需要在Spring中配置这个类,因为这种异步调用是通过Spring实现的

    在异步执行的方法前面加上注解@async

    异步执行的方法必须单独抽到一个类

    并且需要在Spring中配置这个类,因为这种异步调用是通过Spring实现的


    展开全文
  • Java实现异步调用方法(jdk1.8)

    千次阅读 2020-10-26 16:38:23
    点击上方“秋秋秋影影影”,并“星标置顶” 喜欢我的都关注我了 阅读本文大约需要 30秒 jdk1.8开始的Future 很多时候,我们需要调用一个耗时方法,但是我们并不需要等待它执行完,才继续后面的...
  • 转载请注明本文地址: ... 异步调用:调用方在调用过程中,不直接等待返回结果,而是执行其他任务,结果返回形式通常为回调函数。 其实,两者的区别还是很明显的,这里也不再细说,我们主要来说一下Java如...
  • A和B之间是同步调用 B和C是异步调用 现在需要A同步请求B时 B根据A的请求去异步请求C A等待 B要等到C异步返回数据之后 在将C返回的数据同步返回给A 。 有没有好的解决方案 。 感谢各位大神给我解答一下。
  • java线程异步调用

    千次阅读 2018-11-07 09:54:13
    本文主要讲解生产环境中遇到的异步加载数据问题以及相应的解决思路。 系统登录的时候,需要根据用户ID生成一些和当前...在Java程序中,如果想实现异步调用方法的功能,需要通过线程方式实现,即实现java.lang.Ru...
  • 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 ...
  • AsyncTask -- Java异步调用框架

    千次阅读 2017-02-28 17:40:09
    原创文章,转载请注明...  AsyncTask是个人编写的一个Java异步调用框架,支持用户: 1)自定义Task,并可设置Task的类型(Type), 子类型(subType),超时时间(TImeout),标识(Flag-可用来区分不同的Task),
  • Java如何实现方法级的异步调用 业务需求: 方法A里面调用方法B,但是方法B执行的时间太久,如果方法A要等方法B 执行完再返回页面,页面需要等很久,而且方法B的执行结果不影响方法A的后续执行。 因此,这里方法B异步...
  • Java 实现异步调用

    万次阅读 热门讨论 2018-04-03 15:27:12
    首先 我遇到的问题是 接口调用时需要更新缓存 而更新缓存又是个说快不快的过程 所以打算做异步调用 返回我所需要的结果即可 ,至于缓存什么时候更新完 就不是我所需要关注的了废话不多说 上代码public class ...
  • Java接口异步调用

    千次阅读 2017-10-12 07:49:47
    java接口调用从调用方式上可以分为3类:同步调用,异步调用,回调;同步调用基本不用说了,它是一种阻塞式的调用,就是A方法中直接调用方法B,从上往下依次执行。今天来说说异步调用。 什么是异步调用? 我的理解...
  • 要在springboot中使用异步调用方法,只要在被调用的方法上面加上@Async就可以了 1.准备工作 准备一个springboot工程,在Application类上加上EnableAsync注解开启异步 /** * @Author: zgd * @Date...
  • SpringBoot异步调用方法

    千次阅读 2019-04-23 18:28:29
    SpringBoot异步调用方法 一、spring boot--使用异步请求,提高系统的吞吐量 https://blog.csdn.net/liuchuanhong1/article/details/78744138 1.使用Callable来实现 2. 通过WebAsyncTask,也能实现异步调用 ...
  • SpringBoot 异步执行方法,在接口调用时开启一个新线程做一些操作,这个操作结果,不影响返回值 项目启动类或者任意被Spring容器管理的类,必须要有一个`@EnableAsync`注解,标识项目开启异步功能 然后在需要异步...
  • java实现异步调用方法

    万次阅读 2018-03-08 00:19:29
    概念的理解同步/异步:关于同步,我们知道jvm解释执行class文件时候,就是按照代码从上到下的顺序执行的,这里我们正常的程序开发流程,如果一个方法中执行了doSomething1,doSomething2两个方法,正常情况下...
  • JAVA异步调用

    万次阅读 2017-12-11 10:14:53
    那么后台的异步调用改怎么实现呢?1、 使用callable接口,加线程池 2、 使用JAVA的回调机制 3、 使用spring框架默认的异步调用方式一、第一种方式是比较简单,也比较常用的方式,下面看一段示例代码:public void ...
  • Java方法异步调用,并行

    千次阅读 2019-12-27 15:58:36
    Java同一个方法调用多个方法时默认是串行的方式,我的这个业务调用6个方法串行需要4秒左右,由于需要处理数据量比较多,需要优化 原来的逻辑: //裁判文书对象转换 List<JudicialUpdateItem> ...
  • java 调用异步方法

    千次阅读 2014-12-24 15:51:44
    某些时候我们需要执行一个方法立即返回一个处理结果,但仍需要另一个方法去实现某些功能(如调用存储过程)实现异步处理。下面我们采用新开一个线程的方式处理: /** * 手动执行 */ public void doJob() { ...
  • 创建线程执行FutureTask并通过FutureTask得到异步结果; public static void main(String[] args) throws ExecutionException, InterruptedException { long start = System.currentTimeMillis(); ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 275,678
精华内容 110,271
关键字:

java异步调用方法

java 订阅