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

总结

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