CountDownLatch和CyclicBarrier

JUC（Java.util.concurrent）是Java 5中引入的一个并发编程库，它包含了许多用于多线程处理的工具类和接口。JUC主要提供了以下特性：

1. 线程池：线程池可以提高线程的使用效率，避免频繁地创建和销毁线程，从而使得应用程序的性能得到提升。

2. 并发集合类：JUC提供了一些线程安全的集合类，如ConcurrentHashMap、CopyOnWriteArrayList等，可以在多线程环境下安全地操作集合。

3. 原子操作类：JUC提供了一些原子操作类，如AtomicInteger、AtomicLong等，可以在多线程环境下安全地操作共享变量。

4. 同步器：JUC提供了一些同步器，如Semaphore、CountDownLatch、CyclicBarrier等，可以协调多个线程之间的执行。

5. 并发工具类：JUC还提供了一些并发工具类，如Lock、Condition等，可以代替传统的synchronized关键字，提供更灵活、更高效的线程同步机制。

CountDownLatch和CyclicBarrier都是Java中用于多线程编程的工具类，属于同步器的一种。它们都可以用于控制多个线程的执行顺序。

 代码示例

CountDownLatch 

介绍

CountDownLatch是一个计数器，通过它可以控制线程执行的先后顺序。它的作用是让某个线程等待若干个其他线程执行完后再执行。使用CountDownLatch时需要指定一个计数器的值，当所有计数器都为0时，等待线程才会继续执行。

代码 

public class TestCountDown {
 
    private static CountDownLatch cl=new CountDownLatch(4);
 
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                System.out.println("start1");
                Thread.sleep(4000);
                cl.countDown();
                System.out.println("end1");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
 
        Thread thread2 = new Thread(() -> {
            try {
                System.out.println("start2");
                Thread.sleep(4000);
                cl.countDown();
                System.out.println("end2");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
 
        Thread thread3 = new Thread(() -> {
            try {
                System.out.println("start3");
                Thread.sleep(4000);
                cl.countDown();
                System.out.println("end3");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
 
        Thread thread4 = new Thread(() -> {
            try {
                System.out.println("start4");
                Thread.sleep(4000);
                cl.countDown();
                System.out.println("end4");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
 
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
 
        try {
            cl.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
 
        System.out.println("ok");
    }
}

运行结果

 CyclicBarrier

 介绍

CyclicBarrier也可以用于控制线程的顺序执行。它可以协调一组线程在某个屏障处等待并互相等待，直到所有线程都到达该屏障后再一起继续执行。CyclicBarrier可以重复使用，每次调用await()方法时，计数器的值都会减1，当计数器为0时，所有线程都会被释放。

代码 

public class TestCyclicBarrier {
    // 自定义工作线程
    private static class Worker extends Thread {
        private CyclicBarrier cyclicBarrier;
 
        public Worker(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }
 
        @Override
        public void run() {
            super.run();
 
            try {
                System.out.println(Thread.currentThread().getName() + "开始等待其他线程");
                cyclicBarrier.await();
                System.out.println(Thread.currentThread().getName() + "开始执行");
                // 工作线程开始处理，这里用Thread.sleep()来模拟业务处理
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + "执行完毕");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
 
    public static void main(String[] args) {
        int threadCount = 3;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(threadCount);
 
        for (int i = 0; i < threadCount; i++) {
            System.out.println("创建工作线程" + i);
            Worker worker = new Worker(cyclicBarrier);
            worker.start();
        }
    }
}

运行结果

总结 

总结来说，CountDownLatch是控制一个线程等待多个其他线程执行完毕后再执行，而CyclicBarrier是控制多个线程相互等待，直到所有线程都到达某个屏障后再一起继续执行。