Java并发编程：第七章 并发工具类

一、并发工具类

1、CyclicBrrier

（1）概念

CyclicBarrier是一个用于多线程同步的工具类，也被称为同步屏障或循环栅栏。它在JDK 1.5中被引入，主要作用是让一组线程互相等待，直到所有线程都到达某个状态（或称为屏障点），然后这些线程才会继续执行。CyclicBarrier的名字中的“Cyclic”表示它是可循环利用的，即当所有等待线程执行完毕并重置CyclicBarrier状态后，它可以被重用。

CyclicBarrier的初始化时规定一个数目，表示需要等待的线程数量。每个线程调用CyclicBarrier的await()方法后，就会进入等待状态，并阻塞当前线程，直到达到设定的线程数量。当所有线程都到达屏障点时，屏障打开，所有被阻塞的线程被唤醒并继续执行。CyclicBarrier还可以接受一个Runnable对象作为参数，这个Runnable对象会在最后一个线程到达屏障点时被执行。

CyclicBarrier的主要用途是控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。它与CountDownLatch有些类似，但侧重点不同。CountDownLatch一般用于一个线程等待多个其他线程完成任务，而CyclicBarrier则是多个线程互相等待，当大家都完成后再一起继续执行。

总的来说，CyclicBarrier是一个强大的多线程同步工具，可以帮助开发者更好地控制线程的执行顺序和协调多个线程的工作。

（2）demo

package chatpter07;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class TestCyclicBarrier {
    public static void main(String[] args) {
        /**
         * 定义一个循环屏障，参数1：需要累加的值，参数2 需要执行的方法
         */
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("召唤神龙");
        });

        for (int i = 1; i <= 7; i++) {
            final Integer tempInt = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "\t 收集到 第" + tempInt + "颗龙珠");

                try {
                    // 先到的被阻塞，等全部线程完成后，才能执行方法
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }
    }
}

package chatpter07;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    private static final int THREAD_COUNT = 5;
    private static CyclicBarrier cyclicBarrier = new CyclicBarrier(THREAD_COUNT);

    public static void main(String[] args) {
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(new Worker(i)).start();
        }
    }

    static class Worker implements Runnable {
        private final int workerId;

        public Worker(int workerId) {
            this.workerId = workerId;
        }

        @Override
        public void run() {
            System.out.println("Worker " + workerId + " is ready");
            try {
                // 等待其他线程到达屏障点
                cyclicBarrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }

            // 所有线程到达屏障点后，继续执行
            System.out.println("Worker " + workerId + " is working now");
            // 模拟工作...
        }
    }
}

2、CountDownLatch

（1）概念

CountDownLatch是Java并发包java.util.concurrent下提供的一个同步工具类，它允许一个或多个线程等待其他线程完成操作。

CountDownLatch的工作原理是，它维护了一个计数器，这个计数器的初始值由构造函数的参数决定。每当一个线程完成了某个任务后，计数器的值就会减一。当计数器的值减至0时，所有因调用await()方法而阻塞的线程就会被唤醒，继续执行后续的操作。

CountDownLatch的主要方法包括：

• CountDownLatch(int count)：这是构造方法，用于创建一个新的CountDownLatch实例，并用给定的计数初始化。参数count表示线程需要等待的任务数量。
• await()：这个方法会使当前线程等待，直到计数器值变为0。如果计数器的值已经为0，则此方法立即返回。此方法返回一个布尔值，表示在等待时间内计数器是否变为0。
• countDown()：这个方法用于递减计数器的值。如果计数器的结果为0，则释放所有等待的线程。在实际应用中，通常在线程完成任务后调用此方法。

CountDownLatch的使用场景通常包括那些一个或者多个线程在执行之前必须依赖于某些必要的前提业务先执行的场景。例如，你可能有一个主线程需要等待多个子线程完成初始化或数据加载任务后才能继续执行。在这种情况下，你可以使用CountDownLatch来协调这些线程的执行顺序。

此外，CountDownLatch是基于AQS（AbstractQueuedSynchronizer）实现的。在构建CountDownLatch对象时，传入的值会赋值给AQS的关键变量state。执行countDown方法时，会利用CAS（Compare-and-Swap）将state减一。执行await方法时，会判断state是否为0，不为0则加入到队列中，将该线程阻塞。当state为0时，头节点会把剩余的在队列中阻塞的节点也一并唤醒。

总的来说，CountDownLatch是一个强大的同步工具，可以帮助开发者更好地控制线程的执行顺序和协调多个线程的工作。

（2）demo

package chatpter07;

import java.util.concurrent.CountDownLatch;

public class TestCountDownLatch {
    public static void main(String[] args) throws InterruptedException {

        // 计数器
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 0; i <= 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "\t 上完自习，离开教室");
                //计数器 -1
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }

        //设置屏障
        countDownLatch.await();

        System.out.println(Thread.currentThread().getName() + "\t 班长最后关门");
    }
}

3、SemaPhore

（1）概念

信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另外一个用于并发线程的控制

（2）方法

• 构造器
  • Semaphore(permis)
    构造一个Semaphore实例，初始化其管理的许可数量为permis参数值
  • Semaphore(permis, fair)
    构造一个Semaphore(permis, fair)实例，初始化其管理的许可数量为permits参数值，以及是否以公平模式（fair参数是否为true）进行许可的发放
• availablePermits()
  获取Semaphore对象可用的许可数量
• acquire()
  当前线程尝试获取Semaphore对象的一个许可。此过程是阻塞的，线程会一直等待Semaphore发放一个许可，知道发生一下任意一件事
  • 当前线程获取了一个可用的许可
  • 当前线程被中断，就会抛出InterrupttedException异常，并停止等待，继续往下执行
• acquire(permits)
  当前线程尝试阻塞地获取permits个许可。此过程是阻塞的，线程会一直等待Semaphore发放permits个许可。如果没有足够的许可而当前线程被中断，就会抛出InterruptedException异常并终止阻塞。
• acquireUninterruptibly()
  当前线程尝试阻塞地获取一个许可，阻塞的过程不可中断，直到成功获取一个许可

（3）demo

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
    public static void main(String[] args) {

        /**
         * 初始化一个信号量为3，默认是false 非公平锁， 模拟3个停车位
         */
        Semaphore semaphore = new Semaphore(3, false);

        // 模拟6部车
        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                try {
                    // 代表一辆车，已经占用了该车位
                    semaphore.acquire(); // 抢占

                    System.out.println(Thread.currentThread().getName() + "\t 抢到车位");

                    // 每个车停3秒
                    try {
                        TimeUnit.SECONDS.sleep(3);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "\t 离开车位");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 释放停车位
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }
    }
}

4、Exchanger

在Java并发框架中，Exchanger 是一个同步点，它允许一对线程在一个点上交换对象。当两个线程都到达交换点时，它们会交换各自持有的对象，然后可以继续执行。Exchanger 非常适合于两个线程需要相互传递数据或信息的场景，例如遗传算法中的配对交叉操作，或者流水线设计中两个工作阶段的交互。使用 Exchanger 的一般步骤如下：

• 创建一个 Exchanger 实例。
• 线程A和线程B分别持有需要交换的对象。
• 线程A和线程B都调用 exchange 方法，并传入它们各自持有的对象。
• 当两个线程都调用 exchange 方法时，它们会阻塞，直到两个线程都到达同步点。
• 在交换点，Exchanger 将线程A的对象给线程B，将线程B的对象给线程A。
• 交换完成后，两个线程可以继续执行。
  下面是一个简单的示例，展示了如何使用 Exchanger 来交换两个线程之间的整数：

package chatpter07;

import java.util.concurrent.Exchanger;
public class TestExchanger {
    public static void main(String[] args) throws InterruptedException {
        Exchanger<Integer> exchanger = new Exchanger<>();

        Thread threadA = new Thread(() -> {
            try {
                int a = 1;
                int b = exchanger.exchange(a); // 线程A阻塞，直到线程B也调用exchange方法
                System.out.println("Thread A received: " + b);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread threadB = new Thread(() -> {
            try {
                int a = 2;
                int b = exchanger.exchange(a); // 线程B阻塞，直到线程A也调用exchange方法
                System.out.println("Thread B received: " + b);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        threadA.start();
        threadB.start();

        threadA.join();
        threadB.join();
    }
}

三、并发工具框架

• disruptor
• guava