JDK CyclicBarrier简单解释



JDK CyclicBarrier简单解释以及相关实例介绍,CyclicBarrier是一个同步辅助类,允许一组线程相互等待,直到到达一个共同的barrier point。如果一组线程需要不定时地相互等待,这个时候就可以用到CyclicBarrier。CyclicBarrier之所以带“Cyclic”前缀,是因为当所有相互等待的线程释放后,Barrier可以被重复利用。

还是看一段java代码,下边输出什么?

  1. package com.test.java;
  2. class MyThread3 implements Runnable{
  3.     String name;
  4.     public MyThread3(){}
  5.     public MyThread3(String name) {
  6.         this.name = name;
  7.     }
  8.     @Override
  9.     public void run() {
  10.          for (int i = 0; i < 7; i++) {
  11.             System.out.println(name+”正在做第”+(i+1)+”个俯卧撑。”);
  12.          }
  13.     }
  14. }
  15. public class TestConcurrent3 {
  16.     public static void main(String[] args) {
  17.         Thread kaka = new Thread(new MyThread3(“卡卡”));
  18.         kaka.start();
  19.         Thread beckham = new Thread(new MyThread3(“小贝”));
  20.         beckham.start();
  21.         Thread owen = new Thread(new MyThread3(“欧文”));
  22.         owen.start();
  23.         System.out.println(“guys, good job!”);
  24.     }
  25. }

但是输出的是各种无序,本来想要输出”guys, good job!”但于在最后一行,却发现输出是整个乱的,像这样…

 

现在是CyclicBarrier的大展身手的时候了。

改造一下代码…

  1. package com.test.java;
  2. import java.util.concurrent.BrokenBarrierException;
  3. import java.util.concurrent.CyclicBarrier;
  4. class MyThread3 implements Runnable{
  5.     String name;
  6.     CyclicBarrier cyclic;
  7.     public MyThread3(){}
  8.     public MyThread3(String name) {
  9.         this.name = name;
  10.     }
  11.     public MyThread3(String name, CyclicBarrier cyclic) {
  12.         this.name = name;
  13.         this.cyclic = cyclic;
  14.     }
  15.     @Override
  16.     public void run() {
  17.          for (int i = 0; i < 7; i++) {
  18.             System.out.println(name+”正在做第”+(i+1)+”个俯卧撑。”);
  19.          }
  20.          try {
  21.             cyclic.await();
  22.          } catch (InterruptedException e) {
  23.             e.printStackTrace();
  24.          } catch (BrokenBarrierException e) {
  25.             e.printStackTrace();
  26.          }
  27.     }
  28. }
  29. class MyThread3_barrierAction implements Runnable{
  30.     @Override
  31.     public void run() {
  32.         System.out.println(“guys, good job!”);
  33.     }
  34. }
  35. public class TestConcurrent3 {
  36.     public static void main(String[] args) {
  37.         CyclicBarrier cyclic = new CyclicBarrier(4, new MyThread3_barrierAction());
  38.         Thread kaka = new Thread(new MyThread3(“卡卡”, cyclic));
  39.         kaka.start();
  40.         Thread beckham = new Thread(new MyThread3(“小贝”, cyclic));
  41.         beckham.start();
  42.         Thread owen = new Thread(new MyThread3(“欧文”, cyclic));
  43.         owen.start();
  44.         try {
  45.             cyclic.await();
  46.         } catch (InterruptedException e) {
  47.             e.printStackTrace();
  48.         } catch (BrokenBarrierException e) {
  49.             e.printStackTrace();
  50.         }
  51.     }
  52. }

但又似乎以上java代码好像少了什么东西  .. …