并发工具类

比如：ConcurrentHashMap、AtomicInteger、Semaphore、CyclicBarrier、CountDownLatch、BlockingQueue 等等。

1. ConcurrentHashMap

• 作用： 是一个线程安全且高效的哈希表，支持并发访问。
• 用法： 多个线程可以同时进行读写操作，而不会导致线程安全问题。

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("key1", 1);
Integer value = map.get("key1");
map.computeIfAbsent("key2", k -> 2); //方法用于在键不存在时，通过提供的函数计算一个值并插入到 ConcurrentHashMap 中，如果键已经存在，则直接返回对应的值。

2. AtomicInteger

• 作用： 提供一种线程安全的方式对 int 类型进行原子操作，如增减、比较。
• 用法： 适用于需要频繁对数值进行无锁操作的场景。

AtomicInteger atomicInt = new AtomicInteger(0);
atomicInt.incrementAndGet(); // 递增
atomicInt.decrementAndGet(); // 递减
atomicInt.compareAndSet(1, 2); // 比较并设置(如果为1，设置为2)

3. Semaphore（信号量）抢车位

• 作用： 控制访问资源的线程数（3个或4个），可以用来实现限流或访问控制。
• 用法： 在资源有限的情况下，控制同时访问的线程数量。

Semaphore semaphore = new Semaphore(3);
try {
    semaphore.acquire(); // 获取许可
    // 执行任务
} finally {
    semaphore.release(); // 释放许可
}

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

        // 线程数量，停车位，限流
        // 有限的条件下，有序！
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i <= 6; i++) {
            new Thread(() -> {
                // acquire() 得到
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName() + "离开车位");
                }catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release(); // release() 释放
                }
            }).start();
        }
    }
}

4. CyclicBarrier 集齐七科龙珠就召唤神龙

• 作用： 让一组线程到达一个共同的同步点，然后一起继续执行。常用于分阶段任务执行。
• 用法： 适用于需要所有线程在某个点都完成后再继续的场景。

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        // 主线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,() -> {
            System.out.println("召唤神龙");
        });

        for (int i = 1; i <= 7; i++) {
            // 子线程
            int finalI = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "收集了第" + finalI + "颗龙珠");
                try {
                    /**
                    每个线程在执行到 await() 方法时，会阻塞并等待其他线程也调用 await() 方法。每当一个线程调				    用 await() 方法时，CyclicBarrier 的内部计数器会减一（而不是加一），直到计数器减到 0，屏   					障才会打开。
                    */
                    cyclicBarrier.await(); // 加法计数 等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

5. CountDownLatch

• 作用： 一个线程（或多个）等待其他线程完成操作。
• 用法： 适用于主线程需要等待多个子线程完成任务的场景。

CountDownLatch latch = new CountDownLatch(3);
Runnable task = () -> {
    try {
        // 执行任务
    } finally {
        latch.countDown(); // 任务完成，计数器减一
    }
};
new Thread(task).start();
new Thread(task).start();
new Thread(task).start();
latch.await(); // 等待所有任务完成
System.out.println("所有任务都完成了");

6. BlockingQueue

• 作用： 是一个线程安全的队列，支持阻塞操作，适用于生产者-消费者模式。
• 用法： 生产者线程将元素放入队列，消费者线程从队列中取元素，队列为空时消费者线程阻塞。

BlockingQueue<String> queue = new LinkedBlockingQueue<>();
Runnable producer = () -> {
    try {
        queue.put("item"); // 放入元素
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
};
Runnable consumer = () -> {
    try {
        String item = queue.take(); // 取出元素
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
};
new Thread(producer).start();
new Thread(consumer).start();