CyclicBarrier使用

CyclicBarrier 允许一组线程到达某个 屏障的时候阻塞，比如3个线程，前面2个线程无论谁到达的时候都会阻塞，当最后一个线程到达的时候，所有的线程就都会唤醒执行

public class Work implements Runnable{

    private CyclicBarrier barrier;

    public Work(CyclicBarrier barrier){
        this.barrier=barrier;
    }

    @Override
    public void run() {
        try {
            System.out.println("我准备好了，thread id:"+Thread.currentThread().getId());
            Thread.sleep(2000);
            barrier.await();
            System.out.println("大家都准备好了，开始工作吧，thread id:"+Thread.currentThread().getId());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

public class TestOne {

    public static void main(String[] args) {
        CyclicBarrier barrier=new CyclicBarrier(3,null);
        new Thread(new Work(barrier)).start();
        new Thread(new Work(barrier)).start();
        new Thread(new Work(barrier)).start();
    }
}

运行结果：

我准备好了，thread id:11
我准备好了，thread id:13
我准备好了，thread id:12
大家都准备好了，开始工作吧，thread id:12
大家都准备好了，开始工作吧，thread id:13
大家都准备好了，开始工作吧，thread id:11

每个线程调用 await 方法的时候阻塞， 当第三个 线程 调用 await的时候，会唤醒所有等待中的

CyclicBarrier的构造函数中还可以传入一个 Runnable类，该类会在所有即将被 唤醒的线程之前执行，

public class FirstWork implements Runnable {

    @Override
    public void run() {
        System.out.println("大家都准备好了，那我就先开始运行了，thread id:" + Thread.currentThread().getId());
    }
}

public class TestTwo {

    public static void main(String[] args) {
        CyclicBarrier barrier=new CyclicBarrier(3,new FirstWork());
        new Thread(new Work(barrier)).start();
        new Thread(new Work(barrier)).start();
        new Thread(new Work(barrier)).start();
    }
}

运行结果：

我准备好了，thread id:11
我准备好了，thread id:13
我准备好了，thread id:12
大家都准备好了，那我就先开始运行了，thread id:11
大家都准备好了，开始工作吧，thread id:11
大家都准备好了，开始工作吧，thread id:12
大家都准备好了，开始工作吧，thread id:13