Thread--CountDownLatch & CyclicBarrier

参考:http://www.importnew.com/21889.html

CountDownLatch

　　countDown() 方法执行完只是计数器减一, 并不会阻塞当前运行线程的的后续代码执行.

 package org.wzh.cc;

 import java.util.Arrays;
 import java.util.Random;
 import java.util.concurrent.CountDownLatch;
 import java.util.stream.IntStream;

 import static java.lang.System.out;

 public class D4CountDownLatch {

     class Task extends Thread {

         private CountDownLatch latch;
         private int time;

         public Task(CountDownLatch latch) {
             super();
             this.latch = latch;
             time = score();
         }

         private int score() {
             return (new Random().nextInt(8000) + 10000) / 1000;
         }

         @Override
         public void run() {
             // TODO Auto-generated method stub
             try {
                 String name = currentThread().getName();
                 out.println(name + " 预计成绩 " + time + " seconds");
                 out.println(name + " 正在冲刺");
                 sleep(time * 1000);
                 out.println(name + " 到达终点!");
                 latch.countDown();//跑完减一
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }

     public static void main(String[] args) throws InterruptedException {
         out.println("-- 百米赛跑比赛 --");
         out.println("参赛选手:");
         String[] names = {"小明", "小强", "小智"};
         Arrays.stream(names).forEach(out::println);
         out.println("########## 比赛开始 #########");

         CountDownLatch latch = new CountDownLatch(names.length);
         IntStream.range(0, names.length).forEach(i -> {
             Thread t = new D4CountDownLatch().new Task(latch);
             t.setName(names[i]);
             t.start();
         });
         latch.await();//当latch countDown指定的次数之后才会继续向下执行
         out.println("百米赛跑比赛结束");
     }
 }

CyclicBarrier

　　await() 方法阻塞后面的代码,直到达到条件才继续向下执行.　　

 package org.wzh.cc;

 import java.util.Arrays;
 import java.util.Random;
 import java.util.concurrent.BrokenBarrierException;
 import java.util.concurrent.CyclicBarrier;
 import java.util.stream.IntStream;

 import static java.lang.System.out;

 public class D4CyclicBarrier {

     class Task extends Thread {

         private CyclicBarrier barrier;
         private int time;

         public Task(CyclicBarrier barrier) {
             super();
             this.barrier = barrier;
             time = score();
         }

         private int score() {
             return (new Random().nextInt(8000) + 10000) / 1000;
         }

         @Override
         public void run() {
             try {
                 String name = currentThread().getName();
                 System.out.println(name + " 预计成绩 " + time + " seconds");
                 barrier.await();//线程阻塞在这边,直到所有参与的线程都到达这里
                 out.println(name + " 正在冲刺");
                 sleep(time * 1000);
                 out.println(name + " 到达终点!");
             } catch (InterruptedException e) {
                 e.printStackTrace();
             } catch (BrokenBarrierException e) {
                 e.printStackTrace();
             }
         }
     }

     public static void main(String[] args) {
         try {
             out.println("-- 百米赛跑比赛 --");
             out.println("参赛选手:");
             String[] names = {"小明", "小强", "小智"};
             Arrays.stream(names).forEach(out::println);
             out.println("########## 比赛开始 #########");

             CyclicBarrier barrier = new CyclicBarrier(names.length + 1);//***
             IntStream.range(0, names.length).forEach(i -> {
                 Thread t = new D4CyclicBarrier().new Task(barrier);
                 t.setName(names[i]);
                 t.start();
             });
             barrier.await();
             System.out.println("百米赛跑比赛结束");
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

 }

对比

区别

　　CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：

　　　　CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；

　　　　而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；

　　另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。