• 面试系列 - Java 并发容器详解

    Java 并发容器是一组用于在多线程环境下安全访问和操作数据的数据结构。它们提供了线程安全的集合和映射，使开发者能够更轻松地处理并发编程问题。

    一、Java并发容器

    1. ConcurrentHashMap： 它是一个高效的并发哈希表，支持多线程并发操作而不需要显式的同步。适用于高并发读和写操作的场景。

    2. CopyOnWriteArrayList ：这个容器支持在迭代期间进行并发写操作。当需要在读操作频繁而写操作较少的场景中使用。

    3. ConcurrentLinkedQueue 和 ConcurrentLinkedDeque： 这些是非阻塞队列实现，适用于高吞吐量的并发队列操作。通常用于任务调度、工作队列等场景。

    4. BlockingQueue： 它是一组阻塞队列的接口，如 LinkedBlockingQueue、ArrayBlockingQueue、PriorityBlockingQueue 等。这些队列提供了在队列为空或满时阻塞线程的能力，适用于生产者-消费者问题和任务调度等。

    5. Semaphore 和 CountDownLatch： 虽然不是容器，但它们是并发编程中常用的同步工具。

    二、ConcurrentHashMap 

    ConcurrentHashMap 是 Java 中的一个线程安全的哈希表（散列表）实现，它允许多个线程同时读取数据，而不需要显式的同步操作，并且支持高并发的读和写操作。ConcurrentHashMap 的主要特点包括：

    1. 并发读取： 多个线程可以同时读取数据，不会被阻塞，这使得 ConcurrentHashMap 在读多写少的场景下非常高效。

    2. 分段锁： ConcurrentHashMap 内部使用了分段锁机制，将数据分成多个段（Segment），每个段上都有一个锁，不同线程可以同时访问不同段的数据，从而提高并发性能。

    3. 线程安全写入： 写操作（如插入、更新、删除）仍然是线程安全的，但它不会锁住整个数据结构，而只锁住相关的段，使得其他线程仍然可以访问不同段的数据。

    4. 弱一致性： ConcurrentHashMap 提供了一定程度的弱一致性，因为它不保证在某一时刻数据的完全一致性，但保证了线程的安全性。

    5. 扩展性： ConcurrentHashMap 具有较好的扩展性，可以通过调整初始容量和负载因子来优化性能。

    6. 迭代支持： ConcurrentHashMap 提供了安全的迭代器，它可以在遍历时支持并发写操作。

         ConcurrentHashMap用法示例

    1. import java.util.concurrent.ConcurrentHashMap;
    2.  
    3. public class ConcurrentHashMapExample {
    4.     public static void main(String[] args) {
    5.         ConcurrentHashMap map = new ConcurrentHashMap<>();
    6.  
    7.         // 插入数据
    8.         map.put("one", 1);
    9.         map.put("two", 2);
    10.         map.put("three", 3);
    11.  
    12.         // 获取数据
    13.         int value = map.get("two");
    14.         System.out.println("Value for key 'two': " + value);
    15.  
    16.         // 删除数据
    17.         map.remove("three");
    18.  
    19.         // 迭代数据
    20.         for (String key : map.keySet()) {
    21.             int val = map.get(key);
    22.             System.out.println(key + ": " + val);
    23.         }
    24.     }
    25. }

    虽然 ConcurrentHashMap 支持高并发读取和写入，但在一些特定情况下仍然需要考虑同步和竞态条件问题。

    三、CopyOnWriteArrayList

    CopyOnWriteArrayList 是 Java 集合框架中的一种线程安全的并发容器，它提供了一种特殊的并发策略，适用于读多写少的场景。与普通的 ArrayList 不同，CopyOnWriteArrayList 在写操作时不对原有数据进行修改，而是创建一个新的副本，这样可以避免读操作与写操作之间的竞态条件，保证读操作的线程安全。

    主要特点和用途包括：

    1. 线程安全的读取： 多个线程可以同时读取数据，而不需要显式的同步操作。这使得 CopyOnWriteArrayList 在读多写少的场景下非常高效。

    2. 写入时复制（Copy-On-Write）： 写入操作会创建一个新的副本，而不是修改原有数据。这确保了写操作不会影响正在进行的读操作，保证了读操作的一致性。原有的数据在写入完成后会被废弃。

    3. 高效的迭代： CopyOnWriteArrayList 提供了安全的迭代器，可以在迭代集合时进行并发写操作，不会抛出 ConcurrentModificationException 异常。

    4. 适用于不频繁写入的场景： 由于写操作涉及复制数据，因此 CopyOnWriteArrayList 适用于写操作不频繁、但读操作较多的情况，如事件监听器列表、观察者模式等。

     下面是一个简单示例，展示了如何使用 CopyOnWriteArrayList：

    1. import java.util.concurrent.CopyOnWriteArrayList;
    2.  
    3. public class CopyOnWriteArrayListExample {
    4.     public static void main(String[] args) {
    5.         CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();
    6.  
    7.         // 插入数据
    8.         list.add("one");
    9.         list.add("two");
    10.         list.add("three");
    11.  
    12.         // 获取数据
    13.         String value = list.get(1);
    14.         System.out.println("Value at index 1: " + value);
    15.  
    16.         // 迭代数据
    17.         for (String item : list) {
    18.             System.out.println(item);
    19.         }
    20.  
    21.         // 写操作不影响正在进行的读操作
    22.         list.add("four");
    23.  
    24.         // 迭代数据（包含新添加的元素）
    25.         for (String item : list) {
    26.             System.out.println(item);
    27.         }
    28.     }
    29. }

    四、BlockingQueue

    BlockingQueue 是 Java 并发编程中的一个重要接口，它表示一种线程安全的阻塞队列。阻塞队列在多线程编程中非常有用，因为它提供了一种线程安全的方式来实现生产者-消费者模型和其他协作模式。

    BlockingQueue 接口继承自 Queue 接口，它定义了一组用于插入、删除和检查元素的方法，但与普通的队列不同，BlockingQueue 的方法具有阻塞特性，这意味着当队列为空时，从队列中取元素的操作会被阻塞，直到有元素可用；当队列已满时，向队列中插入元素的操作也会被阻塞，直到有空间可用。

    常见的 BlockingQueue 实现包括：

    1. LinkedBlockingQueue： 基于链表的阻塞队列，可以设置容量，当队列为空或已满时，操作会被阻塞。

    2. ArrayBlockingQueue： 基于数组的阻塞队列，需要指定容量，当队列为空或已满时，操作会被阻塞。

    3. PriorityBlockingQueue： 基于优先级的阻塞队列，元素会按照优先级进行排序，不需要容量限制。

    4. DelayQueue： 用于存放实现了 Delayed 接口的元素，元素只能在延迟时间过后才能被取出。

    5. LinkedTransferQueue： 支持多个生产者和消费者的队列，具有高吞吐量。

    6. SynchronousQueue： 一种特殊的阻塞队列，它没有容量，用于直接传递数据的通信。

    使用 BlockingQueue 可以轻松实现一些经典的多线程协作模式，例如生产者-消费者模型。以下是一个简单示例，演示了如何使用 LinkedBlockingQueue 实现生产者-消费者模型：

    1. import java.util.concurrent.*;
    2.  
    3. public class ProducerConsumerExample {
    4.     public static void main(String[] args) {
    5.         BlockingQueue queue = new LinkedBlockingQueue<>(10);
    6.  
    7.         // 生产者线程
    8.         Thread producer = new Thread(() -> {
    9.             try {
    10.                 for (int i = 1; i <= 10; i++) {
    11.                     queue.put(i);
    12.                     System.out.println("Produced: " + i);
    13.                     Thread.sleep(100);
    14.                 }
    15.             } catch (InterruptedException e) {
    16.                 Thread.currentThread().interrupt();
    17.             }
    18.         });
    19.  
    20.         // 消费者线程
    21.         Thread consumer = new Thread(() -> {
    22.             try {
    23.                 for (int i = 1; i <= 10; i++) {
    24.                     int value = queue.take();
    25.                     System.out.println("Consumed: " + value);
    26.                     Thread.sleep(200);
    27.                 }
    28.             } catch (InterruptedException e) {
    29.                 Thread.currentThread().interrupt();
    30.             }
    31.         });
    32.  
    33.         producer.start();
    34.         consumer.start();
    35.     }
    36. }

    在上述示例中，生产者线程不断往队列中放入数据，而消费者线程则不断从队列中取出数据，它们通过阻塞队列实现了线程间的协作。这种模型可以用于处理多个生产者和消费者的情况，并确保线程安全。

    BlockingQueue 是并发编程中的一个重要工具，可以简化线程之间的通信和同步，减少了开发者需要处理的低级细节。根据具体的需求，选择合适的 BlockingQueue 实现非常重要。

    五、Semaphore  

    Semaphore 是 Java 并发编程中的一个同步工具，用于控制同时访问某个资源的线程数量。它允许多个线程并发访问共享资源，但可以限制同时访问的线程数目，从而实现资源的有序分配。

    Semaphore 主要有两个重要的操作：

    1. acquire()： 当一个线程希望获取资源时，它调用 acquire() 方法。如果有可用的资源，线程将获得许可，并继续执行。如果没有可用的资源，线程将被阻塞，直到有资源可用为止。

    2. release()： 当一个线程使用完资源时，它调用 release() 方法来释放资源。这会导致信号量的许可数增加，从而允许其他等待资源的线程获得许可并继续执行。

    Semaphore 可以用于以下一些典型的场景：

    1. 控制资源访问数量： 限制同时访问某个共享资源的线程数量，例如数据库连接池的控制。

    2. 实现有界容器： 可以用 Semaphore 来实现有界的集合，例如有界队列。

    3. 实现并发任务控制： 控制并发任务的数量，例如控制同时运行的线程数量。

    下面是一个简单示例，演示了如何使用 Semaphore 来控制同时执行的线程数量：

     

    1. import java.util.concurrent.Semaphore;
    2.  
    3. public class SemaphoreExample {
    4.     public static void main(String[] args) {
    5.         // 创建一个Semaphore，限制最多同时有两个线程访问共享资源
    6.         Semaphore semaphore = new Semaphore(2);
    7.  
    8.         // 创建多个线程
    9.         for (int i = 1; i <= 5; i++) {
    10.             Thread thread = new Thread(() -> {
    11.                 try {
    12.                     System.out.println(Thread.currentThread().getName() + " is waiting for a permit.");
    13.                     semaphore.acquire();
    14.                     System.out.println(Thread.currentThread().getName() + " has acquired a permit.");
    15.                     Thread.sleep(2000); // 模拟线程在共享资源上的操作
    16.                 } catch (InterruptedException e) {
    17.                     Thread.currentThread().interrupt();
    18.                 } finally {
    19.                     System.out.println(Thread.currentThread().getName() + " is releasing a permit.");
    20.                     semaphore.release();
    21.                 }
    22.             });
    23.             thread.start();
    24.         }
    25.     }
    26. }

    在上述示例中，我们创建了一个 Semaphore，并限制最多同时有两个线程可以获得许可。多个线程尝试获取许可，但只有两个线程能够同时执行，其余的线程会被阻塞，直到有许可可用。

    Semaphore 是一个非常有用的同步工具，可用于管理共享资源的并发访问，控制线程的并发数量，以及其他需要有序控制的场景。

    六、CountDownLatch

    CountDownLatch 是 Java 并发编程中的一个同步工具类，它用于实现一种等待多个线程完成任务的场景。CountDownLatch 通过一个计数器来实现，计数器的值初始化为一个正整数，然后多个线程执行任务，每个任务执行完毕后，计数器的值减一，当计数器的值变为零时，等待的线程可以继续执行。

    CountDownLatch 主要有两个重要的方法：

    1. countDown()： 每个任务执行完毕后调用这个方法来减小计数器的值。通常在任务的最后一步调用。

    2. await()： 等待计数器的值变为零，一直阻塞当前线程，直到计数器值为零才继续执行。

    CountDownLatch 可以用于以下一些典型的场景：

    1. 多个线程协作完成任务： 主线程等待多个子线程完成任务后再继续执行。

    2. 控制并发任务的开始： 多个线程等待某个共同的事件发生后同时开始执行。

    3. 统计多个线程的执行时间： 可以用于测量多个线程完成任务所花费的总时间。

    下面是一个简单示例，演示了如何使用 CountDownLatch 来等待多个线程完成任务：

    1. import java.util.concurrent.CountDownLatch;
    2.  
    3. public class CountDownLatchExample {
    4.     public static void main(String[] args) throws InterruptedException {
    5.         int numThreads = 3;
    6.         CountDownLatch latch = new CountDownLatch(numThreads);
    7.  
    8.         for (int i = 0; i < numThreads; i++) {
    9.             Thread thread = new Thread(() -> {
    10.                 try {
    11.                     // 模拟线程执行任务
    12.                     Thread.sleep(2000);
    13.                     System.out.println(Thread.currentThread().getName() + " has completed.");
    14.                 } catch (InterruptedException e) {
    15.                     Thread.currentThread().interrupt();
    16.                 } finally {
    17.                     latch.countDown(); // 任务执行完毕，减少计数器
    18.                 }
    19.             });
    20.             thread.start();
    21.         }
    22.  
    23.         // 等待所有线程完成
    24.         latch.await();
    25.         System.out.println("All threads have completed.");
    26.     }
    27. }

    在上述示例中，我们创建了一个 CountDownLatch，初始化计数器值为 3（表示有三个线程需要等待）。然后创建了三个线程，每个线程执行完毕后调用 countDown() 来减小计数器的值。主线程使用 await() 来等待计数器的值变为零，一旦所有线程都执行完毕，主线程继续执行。

    CountDownLatch 是一个常用的同步工具，用于协调多个线程的执行，实现任务的并发控制。

  • 相关阅读:
    女朋友让我深夜十二点催她睡觉，我有Python我就不干
    五金机电行业供应商智慧管理平台解决方案：优化供应链管理，带动企业业绩增长
    c# PDFSharp 给已有的pdf文件添加文字页脚（文字水印）
    矩阵初等变换整理
    Ubuntu切换不同版本的cuda
    Python 程序设计结构
    MySQL牛客题组练习
    模型部署——CenterPoint转ONNX(自定义onnx算子)
    Thrift RPC添加access log
    Kafka KRaft模式探索
  • 原文地址：https://blog.csdn.net/TreeShu321/article/details/132733672