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是可以重用的。