Java CountDownLatch计数器与CyclicBarrier循环屏障怎么定义

定义

CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.

CyclicBarrier: A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.

上述是Oracle官方定义。简单来说

CountDownLatch：计数器，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。

CyclicBarrier：循环屏障，它允许一组线程相互等待以达到一个共同的屏障点。

区别

• CountDownLatch 是 AQS (AbstractQueuedSynchronizer) 的一员，但 CyclicBarrier 不是。

• CountDownLatch 的使用场景中，有两类线程，一类是调用await()方法的等待线程，另一类是调用countDownl() 方法的操作线程。在 CyclicBarrier 的情境中，所有线程都是等待彼此的线程，属于同一类型。

• CountDownLatch 是减计数，递减完后不能复位，CyclicBarrier 是加计数，递增完后自动复位

CountDownLatch 示例

创建两组线程，一组等待另一组执行完才继续进行

CountDownLatch countDownLatch = new CountDownLatch(5);
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 5; i++) {
    executorService.execute(() -> {
        countDownLatch.countDown();
        System.out.println("run..");
    });
}
for (int i = 0; i < 3; i++) {  //我们要等上面执行完成才继续
    executorService.execute(() -> {
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("await..");
    });
}
executorService.shutdown();

打印：

run..
run..
run..
run..
run..
await..
await..
await..

等待累加线程执行完，主线程再输出累加结果

public class ThreadUnsafeExample {
    private int cnt = 0;
    public void add() {
        cnt++;
    }
    public int get() {
        return cnt;
    }
    public static void main(String[] args) throws InterruptedException {
        final int threadSize = 1000;
        ThreadUnsafeExample example = new ThreadUnsafeExample();
        final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < threadSize; i++) {
            executorService.execute(() -> {
                example.add();
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println(example.get());
    }
}

打印：

997

3 模拟并发

ExecutorService executorService = Executors.newCachedThreadPool();
        CountDownLatch countDownLatch = new CountDownLatch(1);
        for (int i = 0; i < 5; i++) {
            executorService.submit( () -> {
                try {
                    countDownLatch.await();
                    System.out.println("【" + Thread.currentThread().getName() + "】开始执行……");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        Thread.sleep(2000);
        countDownLatch.countDown();//开始并发
        executorService.shutdown();

打印：

【pool-2-thread-2】开始执行……
【pool-2-thread-5】开始执行……
【pool-2-thread-3】开始执行……
【pool-2-thread-1】开始执行……
【pool-2-thread-4】开始执行……

CyclicBarrier 示例

所有线程相互等待，直到某一步完成后再继续执行

        final int totalThread = 3;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < totalThread; i++) {
            executorService.execute(() -> {
                System.out.println("before..");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("after..");
            });
        }
        executorService.shutdown();

打印：

before..
before..
before..
after..
after..
after..

以上是Java CountDownLatch计数器与CyclicBarrier循环屏障怎么定义的详细内容。更多信息请关注PHP中文网其他相关文章！