【面试】Java最新面试题资深开发-Java中的并发集合类-编程知识

问题五：Java中的并发集合类

Java提供了许多并发集合类来处理多线程环境下的数据共享和同步。你能列举一些Java中常用的并发集合类，并简要说明它们的特点和使用场景吗？

以下六个是经常被使用的，它们在实际开发中发挥着重要作用：

ConcurrentHashMap:
- 特点： 高并发安全，采用分段锁机制，适用于高并发的读写操作。
- 使用场景： 频繁读写的数据缓存，需要高并发性能的场景。
CopyOnWriteArrayList:
- 特点： 写时复制，适用于读操作频繁、写操作较少的场景。
- 使用场景： 事件监听器列表等读多写少的场合。
BlockingQueue:
- 特点： 阻塞队列，用于实现线程之间的数据传递和同步。
- 使用场景： 生产者-消费者模型，任务调度等。
Semaphore:
- 特点： 信号量，用于控制同时访问特定资源的线程数量。
- 使用场景： 资源池的控制，控制并发访问的线程数量。
CountDownLatch:
- 特点： 倒计数器，用于等待多个线程完成任务后再执行后续操作。
- 使用场景： 主线程等待多个子线程完成后再执行的场景。
CyclicBarrier:
- 特点： 循环屏障，多个线程互相等待，当所有线程都达到某个状态后，同时执行后续操作。
- 使用场景： 多个线程协同工作，等待其他线程到达某个状态后再继续执行的场景。

下面，我将对每个类进行更详细的讲解，并提供一些示例代码来说明它们的用法。由于篇幅限制，每个类的讲解将简洁明了，着重强调关键概念和用法。

1. ConcurrentHashMap

特点：

高并发安全： 使用分段锁机制，每个段相当于一个小的HashTable，不同段之间互相独立，提高了并发读的性能。
读操作不加锁： 在读操作上不加锁，多个线程可以同时读取，提高了并发读的效率。
动态扩容： 允许在并发的情况下进行扩容操作。

使用场景：

适用于高并发的读写操作，例如在多线程环境下频繁读写的数据缓存。

示例代码：

import java.util.concurrent.ConcurrentHashMap;public class ConcurrentHashMapExample {public static void main(String[] args) {ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();// 线程安全的put操作concurrentMap.put("A", 1);concurrentMap.put("B", 2);// 线程安全的get操作int valueA = concurrentMap.get("A");int valueB = concurrentMap.get("B");System.out.println("Value for A: " + valueA);System.out.println("Value for B: " + valueB);}
}

在这个示例中，ConcurrentHashMap 提供了线程安全的 put 和 get 操作，无需额外的同步手段，适用于高并发的场景。
在这里插入图片描述

2. CopyOnWriteArrayList

特点：

写时复制： 写操作时，先复制整个列表，进行修改，然后将新的列表替换原来的列表。
读操作无锁： 读操作不需要加锁，可以被多个线程同时执行。
适用于读多写少： 适用于对列表的读操作比写操作频繁的场景。

使用场景：

适用于读操作频繁，写操作较少的场景，例如事件监听器列表。

示例代码：

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;public class CopyOnWriteArrayListExample {public static void main(String[] args) {List<String> copyOnWriteList = new CopyOnWriteArrayList<>();// 线程安全的添加操作copyOnWriteList.add("A");copyOnWriteList.add("B");// 线程安全的遍历操作for (String item : copyOnWriteList) {System.out.println("Item: " + item);}}
}

在这个示例中，CopyOnWriteArrayList 提供了线程安全的列表，通过写时复制机制保证了在读多写少的场景中的高效性。

接下来，我们将继续探讨 BlockingQueue。

3. BlockingQueue

特点：

阻塞队列： 提供了在队列为空或队列已满时阻塞线程的功能。
线程安全： 内部实现了线程安全的操作，适用于多线程间的数据传递和同步。
多种实现： Java提供了多种阻塞队列的实现，如ArrayBlockingQueue、LinkedBlockingQueue等。

使用场景：

适用于多线程数据传递和同步的场景，例如生产者-消费者模型，任务调度等。

示例代码：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;public class BlockingQueueExample {public static void main(String[] args) {BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3); // 定义容量为3的阻塞队列// 生产者线程new Thread(() -> {try {blockingQueue.put("A"); // 阻塞式地添加元素System.out.println("Produced item A");blockingQueue.put("B");System.out.println("Produced item B");} catch (InterruptedException e) {e.printStackTrace();}}).start();// 消费者线程new Thread(() -> {try {String item = blockingQueue.take(); // 阻塞式地获取元素System.out.println("Consumed item: " + item);item = blockingQueue.take();System.out.println("Consumed item: " + item);} catch (InterruptedException e) {e.printStackTrace();}}).start();}
}

在这个示例中，BlockingQueue 通过 put 和 take 操作提供了阻塞式的添加和获取元素的功能，适用于生产者-消费者模型。

4. Semaphore

特点：

信号量： 用于控制同时访问特定资源的线程数量。
计数信号量： 通过计数进行控制，每次访问资源时减少计数，释放资源时增加计数。

使用场景：

适用于控制资源访问的并发场景，如连接池的控制，限制最大并发访问数。

示例代码：

import java.util.concurrent.Semaphore;public class SemaphoreExample {public static void main(String[] args) {Semaphore semaphore = new Semaphore(2); // 允许两个线程同时访问资源// 线程1new Thread(() -> {try {semaphore.acquire(); // 尝试获取资源System.out.println("Thread 1 acquired the resource.");Thread.sleep(2000); // 模拟工作时间semaphore.release(); // 释放资源System.out.println("Thread 1 released the resource.");} catch (InterruptedException e) {e.printStackTrace();}}).start();// 线程2new Thread(() -> {try {semaphore.acquire(); // 尝试获取资源System.out.println("Thread 2 acquired the resource.");Thread.sleep(2000); // 模拟工作时间semaphore.release(); // 释放资源System.out.println("Thread 2 released the resource.");} catch (InterruptedException e) {e.printStackTrace();}}).start();}
}

在这个示例中，Semaphore 通过 acquire 和 release 操作提供了对资源的控制，限制了同时访问资源的线程数量。

接下来，我们将继续学习 CountDownLatch。

5. CountDownLatch

特点：

倒计数器： 用于等待多个线程完成任务后，再执行后续操作。
计数减少： 初始设定一个计数值，每个线程完成任务时，将计数减一，直到计数为零。

使用场景：

适用于主线程等待多个子线程完成后再执行的场景。

示例代码：

import java.util.concurrent.CountDownLatch;public class CountDownLatchExample {public static void main(String[] args) {CountDownLatch countDownLatch = new CountDownLatch(2); // 两个子线程完成任务后，主线程才能执行// 子线程1new Thread(() -> {System.out.println("Thread 1 is doing some work.");countDownLatch.countDown(); // 任务完成，计数减一}).start();// 子线程2new Thread(() -> {System.out.println("Thread 2 is doing some work.");countDownLatch.countDown(); // 任务完成，计数减一}).start();try {// 主线程等待计数归零countDownLatch.await();System.out.println("All threads have completed their tasks. Main thread is now executing.");} catch (InterruptedException e) {e.printStackTrace();}}
}

在这个示例中，CountDownLatch 通过 countDown 和 await 操作提供了等待多个线程完成任务的功能。主线程等待计数归零后再执行。

6. CyclicBarrier

特点：

循环屏障： 多个线程互相等待，当所有线程都达到某个状态后，同时执行后续操作。
可循环使用： 在所有线程到达屏障后，可以重置屏障，继续使用。

使用场景：

适用于多个线程协同工作，等待其他线程到达某个状态后再继续执行的场景。

示例代码：

import java.util.concurrent.CyclicBarrier;public class CyclicBarrierExample {public static void main(String[] args) {CyclicBarrier cyclicBarrier = new CyclicBarrier(3); // 三个线程到达屏障后，同时执行// 线程1new Thread(() -> {System.out.println("Thread 1 is ready.");try {cyclicBarrier.await(); // 等待其他线程到达System.out.println("Thread 1 is executing.");} catch (Exception e) {e.printStackTrace();}}).start();// 线程2new Thread(() -> {System.out.println("Thread 2 is ready.");try {cyclicBarrier.await(); // 等待其他线程到达System.out.println("Thread 2 is executing.");} catch (Exception e) {e.printStackTrace();}}).start();// 线程3new Thread(() -> {System.out.println("Thread 3 is ready.");try {cyclicBarrier.await(); // 等待其他线程到达System.out.println("Thread 3 is executing.");} catch (Exception e) {e.printStackTrace();}}).start();}
}