Java同步/异步调用

同步调用

A程序对B程序的调用，当B程序的处理比较耗时，A程序就处于阻塞状态中，只有等待B程序执行完成，A程序才会往下执行

同步调用比较简单，当在调用一些不怎么耗时的操作时，比较方便，可以很快的拿到调用结果

public class Demo
{
     //B
     public String work()
     {
           System.out.println("我开始工作了");
           return "完成工作";
     }  
     //A
     public void call()
     {
           System.out.println("我要调用B函数");
           String result = work();
           System.out.println("调用完毕，返回值为："+result);
     }
    
     public static void main(String[] args)
     {
           Demo demo = new Demo();
           demo.call();
     }
}

异步调用

A程序对一个比较耗时的B程序进行调用时，如果采用同步调用就会导致A程序阻塞，而使用异步调用就很好的解决了这个问题。将A程序对B程序的调用代码放入一个线程当中执行，这样就不会阻塞A程序的执行

异步调用的优点是，不会阻塞程序的执行，但是代码相对复杂化

如果想要在异步调用中取到所调用的程序的返回值，就得加入匿名内部类的使用。使用匿名内部类在被调用代码执行完成后，取得返回值

为了取到被调用函数的返回值，需要先创建一个接口

public interface EndCallback 
{
     void onEnd(String message);
}

异步调用的执行

public class SyncCall 
{
     //B
     public String work()
     {
           try {
           //模拟耗时操作
                Thread.sleep(3000);
           } catch (InterruptedException e) {              
                e.printStackTrace();
           }
           System.out.println("我完成工作了");
           return "我今天完成了JMS的开发";
     }
     //A调用B；
     public void watchDog(EndCallback callback)
     {
           System.out.println("我是一个监工");
           new Thread(new Runnable() {              
                @Override
                public void run() {
                     String result = work();
                     callback.onEnd(result);
                }
           }).start();
           System.out.println("我调用work()了");
     }
     public static void main(String[] args)
     {
           SyncCall call = new SyncCall();
           //用匿名内部类来完成异步的调用
           call.watchDog(new EndCallback() {
               
                @Override
                public void onEnd(String message)
                {    
                     System.out.println(message);
                }
           });
           while(true)
           {
           System.out.println("我在执行");
           try {
                Thread.sleep(2000);
           } catch (InterruptedException e) {            
                e.printStackTrace();
           }
           }
     }
}

执行结果

我是一个监工

我调用work()了

我在执行

我在执行

我完成工作了

我今天完成了JMS的开发

我在执行

我在执行

我在执行

我在执行

异步调用并不会对当前的程序的执行造成阻塞，在使用了匿名内部类后，函数的返回值能在调用完成后自动的进行打印