服务器之家：专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - 5种必会的Java异步调用转同步的方法你会几种

5种必会的Java异步调用转同步的方法你会几种

2021-11-19 14:52程序员Sunny Java教程

这篇文章主要介绍了5种必会的Java异步调用转同步的方法你会几种，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

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

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

其实，两者的区别还是很明显的，这里也不再细说，我们主要来说一下Java如何将异步调用转为同步。换句话说，就是需要在异步调用过程中，持续阻塞至获得调用结果。
不卖关子，先列出五种方法，然后一一举例说明：

  • 使用wait和notify方法
  • 使用条件锁
  • Future
  • 使用CountDownLatch
  • 使用CyclicBarrier

0.构造一个异步调用

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
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();
 
  }
}

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

至于futureCall和shutdown方法，以及线程池tp都是为了demo3利用Future来实现做准备的。

demo的基类:

?
1
2
3
4
5
6
7
8
9
10
11
12
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去实现的——主要在回调中进行相应的处理来达到异步调用转同步的目的。

1. 使用wait和notify方法

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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. 使用条件锁

和方法一的原理类似：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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("主线程内容");
  }
}

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

3. Future

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
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方法：

?
1
2
3
4
5
public void shutdown(){
 
    tp.shutdown();
 
  }

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

4. 使用CountDownLatch

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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. 使用CyclicBarrier

CyclicBarrier的情况和CountDownLatch有些类似：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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无关，在平时编程的时候，需要比较小心，如果这个数值设置得很大，比线程池中的线程数都大，那么就很容易引起死锁了。

总结

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

源码地址：https://gitee.com/sunnymore/asyncToSync

到此这篇关于5种必会的Java异步调用转同步的方法你会几种的文章就介绍到这了,更多相关Java异步调用转同步内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://www.jianshu.com/p/f00aa6f66281

  • Java
  • 异步调用
  • 同步调用

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    501 　 406 　 415 　 1433 　 2000 　 401 　 330 　 GOF23 　 new 　 newInstance 　 Hibernate 　 volatile 　 集合 　 spring 　 consul 　 critical 　 嵌套循环 　 注册服务 　 堆栈类 　 supplyAsync 　 遍历 　 设计模式 　 观察者模式 　 小数 　 JAVA8 　 写入文件 　 回车 　 制表符 　 排列组合 　 Java 　
    © 2019-2023 服务器之家(www.zzvips.com) 版权所有关于我们联系我们版权申明网站地图