java 异步调用方法

Posted 2023-04-16

参考技术A asynchronous call（异步调用）
一个可以无需等待被调用函数的返回值就让操作继续进行的方法
中文名
异步调用
外文名
asynchronous call
领域
函数
杰作
线程
。
。
快速
导航
实战用法异步调用使用方法
举例
异步调用就是你 喊 你朋友吃饭 ，你朋友说知道了 ，待会忙完去找你 ，你就去做别的了。
同步调用就是你 喊 你朋友吃饭 ，你朋友在忙 ，你就一直在那等，等你朋友忙完了 ，你们一起去。
实战用法
操作系统发展到今天已经十分精巧，线程就是其中一个杰作。操作系统把 CPU 处理时间划分成许多短暂时间片，在时间 T1 执行一个线程的指令，到时间 T2又执行下一线程的指令，各线程轮流执行，结果好象是所有线程在并肩前进。这样，编程时可以创建多个线程，在同一期间执行，各线程可以“并行”完成不同的任务。
在单线程方式下，计算机是一台严格意义上的冯·诺依曼式机器，一段代码调用另一段代码时，只能采用同步调用，必须等待这段代码执行完返回结果后，调用方才能继续往下执行。有了多线程的支持，可以采用异步调用，调用方和被调方可以属于两个不同的线程，调用方启动被调方线程后，不等对方返回结果就继续执行后续代码。被调方执行完毕后，通过某种手段通知调用方：结果已经出来，请酌情处理。 参考技术B 1. 使用wait和notify方法
这个方法其实是利用了锁机制，直接贴代码:

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，主线程内容会紧随调用内容立刻打印;而像我们上面的代码，主线程内容会一直等待回调函数调用结束才会进行打印。

没有使用同步操作的情况下，打印结果:发起调用 调用返回 主线程内容 得到结果 1 调用结束
而使用了同步操作后:

发起调用 调用返回 得到结果 9 调用结束 主线程内容2. 使用条件锁
和方法一的原理类似:

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 demo2.con.await(); catch (InterruptedException e) e.printStackTrace(); finally demo2.lock.unlock(); System.out.println("主线程内容");
基本上和方法一没什么区别，只是这里使用了条件锁，两者的锁机制有所不同。

Java异步调用转同步的5种方式

1、异步和同步的概念

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

2 、异步转为同步的概率

  需要在异步调用过程中，持续阻塞至获得调用结果。

3、异步调用转同步的5种方式

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

4、构造一个异步调用模型。

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

    

demo的基类:

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("调用返回");
    

5、各种方法的具体实现

5.1、使用wait和notify方法

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

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("主线程内容");

    

没有使用同步操作的情况下，打印结果：

发起调用
调用返回
主线程内容
得到结果
1
调用结束

而使用了同步操作后：

发起调用
调用返回
得到结果
9
调用结束
主线程内容

5.2、使用条件锁

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

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 
            demo2.con.await();
         catch (InterruptedException e) 
            e.printStackTrace();
        finally 
            demo2.lock.unlock();
        
        System.out.println("主线程内容");
    

5.3、Future

使用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("主线程内容");

    

5.4、CountDownLatch

使用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中都一样，主线程中阻塞的部分，都可以设置一个超时时间，超时后可以不再阻塞

5.5、CyclicBarrier

CyclicBarrier的情况和CountDownLatch有些类似：

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无关，在平时编程的时候，需要比较小心，如果这个数值设置得很大，比线程池中的线程数都大，那么就很容易引起死锁了。