java并发编程基础--并发工具类介绍与示例

在JDK的并发包里提供了几个非常有用的并发工具类，主要有以下四个：

CountDownLatch、CyclicBarrier、Semaphore、Exchanger

一、CountDownLatch

CountDownLatch允许一个线程或多个线程等待其他线程完成操作。

其中，await（）方法表示进入等待状态，countDown（）方法表示计数器减一

举例：就是田径场可作为长跑也可作为短跑赛道，要切换为其他赛道用途时，需等待当前比赛选手全部到达并清空赛道才可使用

public class CountDownLatchDemo {

    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(8);
        new Thread(()->{
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("800米比赛结束，准备清空跑道并继续短跑比赛");
        }).start();

        for (int i = 0; i < 8; i++) {
            int finalI = i;
            new Thread(()->{
                try {
                    Thread.sleep(finalI * 1000L);
                    System.out.println(Thread.currentThread().getName()+"到达终点");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    countDownLatch.countDown();
                }
            }).start();
        }
    }

二、CyclicBarrier

CyclicBarrier(栅栏)允许一组线程相互等待至一个公共的障碍点，之后再继续执行

跟countDownLatch的区别
CountDownLatch一般用于某个线程等待若干个其他线程执行完任务之后，它才执行；不可重复使用
CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；可重用的

举例：进行长跑比赛时，需等待8位选手全部准备就绪才可以一起开跑（同时执行）

public class CyclicBarrierDemo {

    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(8);

        for (int i = 0; i < 8; i++) {
            int finalI = i;
            new Thread(() -> {
                try {
                    Thread.sleep(finalI * 1000L);
                    System.out.println(Thread.currentThread().getName() + "准备就绪");
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }

                System.out.println("开始比赛");
            }).start();
        }
    }
}

三、Semaphore

Semaphore（信号量）是用来控制同时访问特定资源的线程数量，即并发数量，常见的使用场景有接口限流

举例：有10个线程，但每次只能允许运行2个线程

public class SemaphoreDemo {

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(2);

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "开始执行");
                    Thread.sleep(5000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }).start();
        }
    }
    
}

四、Exchanger

Exchanger用于交换数据，它提供了一个同步点，在这个同步点两个线程可以交换彼此的数据，线程1到达同步点时会等待线程2到达，然后交换彼此数据，需要注意的是，Exchagner的重点是成对的线程使用exchange（）方法

举例：线程1.2交换彼此的值

public class ExchangerDemo {

    public static void main(String[] args) {
        Exchanger<String> stringExchanger = new Exchanger<>();

        String str1 = "xuhan1";
        String str2 = "xuhan2";

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "初始值==========>" + str1);
            try {
                String exchange = stringExchanger.exchange(str1);
                System.out.println(Thread.currentThread().getName() + "交換后的数据==========>" + exchange);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "线程1").start();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "初始值==========>" + str2);
            try {
                String exchange = stringExchanger.exchange(str2);
                System.out.println(Thread.currentThread().getName() + "交換后的数据==========>" + exchange);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "线程2").start();

    }

}