CyclicBarrier实例二

public class CyclicBarrierTest4 {
    public static void main(String[] args) throws InterruptedException {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                //线程都到了之后，先执行这个
                System.out.println("各线程到齐后，由最后到达的线程执行该Action" + "," + 
               Thread.currentThread().getName());
            }
        });
        for (int i = 0; i < 5; i++) {
            new Thread(new readNum(i, cyclicBarrier)).start();
        }

        //CyclicBarrier 可以重复利用，这个是CountDownLatch做不到的
//        for (int i = 11; i < 16; i++) {
//            new Thread(new readNum(i,cyclicBarrier)).start();
//        }

    }

    static class readNum implements Runnable {
        private int id;
        private CyclicBarrier cyc;

        public readNum(int id, CyclicBarrier cyc) {
            this.id = id;
            this.cyc = cyc;
        }

        @Override
        public void run() {
            synchronized (this) {
                System.out.println("id:" + id + "," + Thread.currentThread().getName());
                try {
                    cyc.await();
                    System.out.println("线程组任务" + id + "," + 
                     Thread.currentThread().getName() + "结束，其他任务继续");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出：

//CyclicBarrier中设置Action
id:0,Thread-0
id:2,Thread-2
id:1,Thread-1
id:4,Thread-4
id:3,Thread-3
各线程到齐后，由最后到达的线程执行该Action,Thread-3
线程组任务3,Thread-3结束，其他任务继续
线程组任务0,Thread-0结束，其他任务继续
线程组任务2,Thread-2结束，其他任务继续
线程组任务1,Thread-1结束，其他任务继续
线程组任务4,Thread-4结束，其他任务继续

二：

//把构造函数中的Action去掉   
 CyclicBarrier cyclicBarrier = new CyclicBarrier(5);

输出：

//CyclicBarrier中不设置Action
id:2,Thread-2
id:0,Thread-0
id:4,Thread-4
id:1,Thread-1
id:3,Thread-3
线程组任务3,Thread-3结束，其他任务继续
线程组任务2,Thread-2结束，其他任务继续
线程组任务4,Thread-4结束，其他任务继续
线程组任务0,Thread-0结束，其他任务继续
线程组任务1,Thread-1结束，其他任务继续

三：

import java.io.IOException;
import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class Runner implements Runnable {

    private CyclicBarrier barrier;

    private String name;

    public Runner(CyclicBarrier barrier, String name) {
        super();
        this.barrier = barrier;
        this.name = name;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000 * (new Random()).nextInt(8));
            System.out.println(name + " 准备OK.");
            barrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
        System.out.println(name + " Go!!");
    }
}

public class CyclicBarrierTest5 {

    public static void main(String[] args) throws IOException, InterruptedException {
        CyclicBarrier barrier = new CyclicBarrier(3);

        ExecutorService executor = Executors.newFixedThreadPool(3);
        executor.submit(new Thread(new Runner(barrier, "zhangsan")));
        executor.submit(new Thread(new Runner(barrier, "lisi")));
        executor.submit(new Thread(new Runner(barrier, "wangwu")));

        executor.shutdown();
    }

}

输出：

lisi 准备OK. zhangsan 准备OK. wangwu 准备OK. wangwu Go!! lisi Go!! zhangsan Go!!

CyclicBarrier和CountDownLatch区别

猜你喜欢