devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java多线程：多线程下的其他组件之CyclicBarrier、Callable、Future和FutureTask_线程池cyclicbarrier

作者：Cpp五条 | 2024-02-27 01:41:20

赞

踩

线程池cyclicbarrier

CyclicBarrier

接着讲多线程下的其他组件，第一个要讲的就是CyclicBarrier。CyclicBarrier从字面理解是指循环屏障，它可以协同多个线程，让多个线程在这个屏障前等待，直到所有线程都达到了这个屏障时，再一起继续执行后面的动作。看一下CyclicBarrier的使用实例：

  1. public static class CyclicBarrierThread extends Thread {
  2.  
  3.         private CyclicBarrier cb;
  4.  
  5.         private int sleepSecond;
  6.  
  7.         public CyclicBarrierThread(CyclicBarrier cb, int sleepSecond) {
  8.  
  9.             this.cb = cb;
  10.  
  11.             this.sleepSecond = sleepSecond;
  12.  
  13.         }
  14.  
  15.         public void run() {
  16.  
  17.             try {
  18.  
  19.                 System.out.println(this.getName() + "运行了");
  20.  
  21.                 Thread.sleep(sleepSecond * 1000);
  22.  
  23.                 System.out.println(this.getName() + "准备等待了, 时间为" + System.currentTimeMillis());
  24.  
  25.                 cb.await();
  26.  
  27.                 System.out.println(this.getName() + "结束等待了, 时间为" + System.currentTimeMillis());
  28.  
  29.             } catch (Exception e) {
  30.  
  31.                 e.printStackTrace();
  32.  
  33.             }
  34.  
  35.         }
  36.  
  37.     }
  38.  
  39.     public static void main(String[] args) {
  40.  
  41.         Runnable runnable = new Runnable() {
  42.  
  43.             public void run() {
  44.  
  45.                 System.out.println("CyclicBarrier的所有线程await()结束了，我运行了, 时间为" + System.currentTimeMillis());
  46.  
  47.             }
  48.  
  49.         };
  50.  
  51.         CyclicBarrier cb = new CyclicBarrier(3, runnable);
  52.  
  53.         CyclicBarrierThread cbt0 = new CyclicBarrierThread(cb, 3);
  54.  
  55.         CyclicBarrierThread cbt1 = new CyclicBarrierThread(cb, 6);
  56.  
  57.         CyclicBarrierThread cbt2 = new CyclicBarrierThread(cb, 9);
  58.  
  59.         cbt0.start();
  60.  
  61.         cbt1.start();
  62.  
  63.         cbt2.start();
  64.  
  65.     }

看一下运行结果：

Thread-0运行了

Thread-2运行了

Thread-1运行了

Thread-0准备等待了, 时间为1444650316313

Thread-1准备等待了, 时间为1444650319313

Thread-2准备等待了, 时间为1444650322313

CyclicBarrier的所有线程await()结束了，我运行了, 时间为1444650322313

Thread-2结束等待了, 时间为1444650322313

Thread-0结束等待了, 时间为1444650322313

Thread-1结束等待了, 时间为1444650322313

从运行结果看，由于是同一个CyclicBarrier，Thread-0先运行到了await()的地方，等着；Thread-2接着运行到了await()的地方，还等着；Thread-1最后运行到了await()的地方，所有的线程都运行到了await()的地方，所以三个线程以及指定的Runnable"同时"运行后面的代码，可以看到，await()之后，四个线程运行的时间一模一样，都是1444650322313。

从使用来看，可能有人觉得CyclicBarrier和CountDownLatch有点像，都是多个线程等待相互完成之后，再执行后面的代码。实际上，CountDownLatch和CyclicBarrier都是用于多个线程间的协调的，它们二者的几个差别是：

1、CountDownLatch是在多个线程都进行了latch.countDown()后才会触发事件，唤醒await()在latch上的线程，而执行countDown()的线程，执行完countDown()后会继续自己线程的工作；CyclicBarrier是一个栅栏，用于同步所有调用await()方法的线程，并且等所有线程都到了await()方法时，这些线程才一起返回继续各自的工作

2、另外CountDownLatch和CyclicBarrier的一个差别是，CountDownLatch不能循环使用，计数器减为0就减为0了，不能被重置，CyclicBarrier可以循环使用

3、CountDownLatch可以唤起多条线程的任务，CyclicBarrier只能唤起一条线程的任务

注意，因为使用CyclicBarrier的线程都会阻塞在await方法上，所以在线程池中使用CyclicBarrier时要特别小心，如果线程池的线程过少，那么就会发生死锁了

Callable、Future和FutureTask

Callable

Callable和rRunnable差不多，两者都是为那些其实例可能被另一个线程执行的类而设计的，最主要的差别在于Runnable不会返回线程运算结果，Callable可以（假如线程需要返回运行结果）

Future

Future是一个接口表示异步计算的结果，它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。Future提供了get()、cancel()、isCancel()、isDone()四种方法，表示Future有三种功能：

1、判断任务是否完成

2、中断任务

3、获取任务执行结果

FutureTask

FutureTask是Future的实现类，它提供了对Future的基本实现。可使用FutureTask包装Callable或Runnable对象，因为FutureTask实现了Runnable，所以也可以将FutureTask提交给Executor。

使用方法

Callable、Future、FutureTask一般都是和线程池配合使用的，因为线程池ThreadPoolExecutor的父类AbstractExecutorService提供了三种submit方法：

  1. 1、public Future<?> subit(Runnable task){...}
  2.  
  3. 2、public <T> Future<T> submit<Runnable task, T result>{...}
  4.  
  5. 3、public <T> Future<T> submit<Callable<T> task>{...}

第2个用得不多，第1个和第3个比较有用

Callable+Future使用示例

  1. public static class CallableThread implements Callable<String> {
  2.  
  3.         public String call() throws Exception {
  4.  
  5.             System.out.println("进入CallableThread的call()方法, 开始睡觉, 睡觉时间为" + System.currentTimeMillis());
  6.  
  7.             Thread.sleep(10000);
  8.  
  9.             return "123";
  10.  
  11.         }
  12.  
  13.     }
  14.  
  15.     public static void main(String[] args) throws Exception {
  16.  
  17.         ExecutorService es = Executors.newCachedThreadPool();
  18.  
  19.         CallableThread ct = new CallableThread();
  20.  
  21.         Future<String> f = es.submit(ct);
  22.  
  23.         es.shutdown();
  24.  
  25.         Thread.sleep(5000);
  26.  
  27.         System.out.println("主线程等待5秒, 当前时间为" + System.currentTimeMillis());
  28.  
  29.         String str = f.get();
  30.  
  31.         System.out.println("Future已拿到数据, str = " + str + ", 当前时间为" + System.currentTimeMillis());
  32.  
  33.     }

运行结果为：

进入CallableThread的call()方法, 开始睡觉, 睡觉时间为1444654421368

主线程等待5秒, 当前时间为1444654426369

Future已拿到数据, str = 123, 当前时间为1444654431369

看到任意一个利用Callable接口submit上去的任务，只要有一个Future接受它，Future便可以在程序任何地点尝试去获取这条线程返回出去的数据，时间可以比对一下，正好10000ms，即10s

Callable+FutureTask使用示例

有兴趣的可以看下源码，其实使用Callable+Future的方式，es.submit(ct)方法返回的Future，底层实现new出来的是一个FutureTask。那么，我们看一下Callable+FutureTask的方式：

  1. public static class CallableThread implements Callable<String> {
  2.  
  3.         public String call() throws Exception {
  4.  
  5.             System.out.println("进入CallableThread的call()方法, 开始睡觉, 睡觉时间为" + System.currentTimeMillis());
  6.  
  7.             Thread.sleep(10000);
  8.  
  9.             return "123";
  10.  
  11.         }
  12.  
  13.     }
  14.  
  15.     public static void main(String[] args) throws Exception {
  16.  
  17.         ExecutorService es = Executors.newCachedThreadPool();
  18.  
  19.         CallableThread ct = new CallableThread();
  20.  
  21.         FutureTask<String> f = new FutureTask<String>(ct);
  22.  
  23.         es.submit(f);
  24.  
  25.         es.shutdown();
  26.  
  27.         Thread.sleep(5000);
  28.  
  29.         System.out.println("主线程等待5秒, 当前时间为" + System.currentTimeMillis());
  30.  
  31.         String str = f.get();
  32.  
  33.         System.out.println("Future已拿到数据, str = " + str + ", 当前时间为" + System.currentTimeMillis());
  34.  
  35.     }

看下运行结果：

进入CallableThread的call()方法, 开始睡觉, 睡觉时间为1444655049199

主线程等待5秒, 当前时间为1444655054200

Future已拿到数据, str = 123, 当前时间为1444655059200

和上面的写法运行结果一样，就不解释了

使用Callable、Future和FutureTask的好处

上面演示了两个例子，其实反映的是现实中一种情况，把上面的例子稍微扩展一下就是：

有一个method()方法，方法中执行方法A返回一个数据要10秒钟，A方法后面的代码一共要执行20秒钟，但是这20秒的代码中有10秒的方法并不依赖方法A的执行结果，有10秒钟的代码依赖方法A的执行结果。此时若采用同步的方式，那么势必要先等待10秒钟，等待方法A执行完毕，返回数据，再执行后面20秒的代码。

不得不说这是一种低效率的做法。有了Callable、Future和FutureTask，那么：

1、先把A方法的内容放到Callable实现类的call()方法中

2、method()方法中，Callable实现类传入Executor的submit方法中

3、执行后面方法中10秒不依赖方法A运行结果的代码

4、获取方法A的运行结果，执行后面方法中10秒依赖方法A运行结果的代码

这样代码执行效率一下子就提高了，程序不必卡在A方法处。

当然，也可以不用Callable，采用实现Runnable的方式，run()方法执行完了想个办法给method()方法中的某个变量V赋个值就好了。但是我上一篇文章开头就说了，之所以要用多线程组件，就是因为JDK帮我们很好地实现好了代码细节，让开发者更多可以关注业务层的逻辑。如果使用Runnable的方式，那么我们自己就要考虑很多细节，比如Runnable实现类的run()方法执行完毕给V赋值是否线程安全、10秒后如果A方法没有执行完导致V还没有值怎么办，何况JDK还给用户提供了取消任务、判断任务是否存在等方法。既然JDK已经帮我们考虑并实现这些细节了，在没有有说服力的理由的情况下，我们为什么还要自己写run()方法的实现呢？ 

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号