请谈谈你知道的几个常用的 Java 并发容器类？

参考回答

Java 提供了一些常用的并发容器类，这些类在多线程环境下能够保证线程安全，同时提供了较高的性能。以下是几个常用的并发容器类：

1. ConcurrentHashMap：高效的线程安全哈希表，支持并发读写。
2. CopyOnWriteArrayList：适用于读多写少的线程安全列表。
3. ConcurrentLinkedQueue：基于链表的高效非阻塞队列。
4. BlockingQueue：支持阻塞操作的队列，常用于生产者-消费者模式。
5. ConcurrentSkipListMap 和 ConcurrentSkipListSet：支持并发访问的有序集合和映射。

这些并发容器在多线程编程中非常重要，能够简化复杂的同步逻辑。

详细讲解与拓展

1. ConcurrentHashMap

ConcurrentHashMap 是一个线程安全的哈希表，用于存储键值对。它通过分段锁（Java 8 之前）和 CAS 操作（Java 8 之后）实现高效并发。

特点：

1. 高并发：

• 读操作无锁，写操作通过 CAS 和锁分段减少竞争。
• 在 Java 8 中，使用 synchronized 替代分段锁，提高性能。

2. 线程安全：支持多线程并发读写，而无需显式同步。

3. 不支持 `null：

• 键和值都不能为 null，避免空值导致线程安全问题。

常见用法：

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        // 添加键值对
        map.put("A", 1);
        map.put("B", 2);

        // 原子更新
        map.computeIfAbsent("C", k -> 3);

        // 遍历
        map.forEach((key, value) -> System.out.println(key + ": " + value));
    }
}

适用场景：

• 高并发环境下的键值对存储，如缓存实现。

2. CopyOnWriteArrayList

CopyOnWriteArrayList 是线程安全的 ArrayList 实现，在修改操作时会复制整个底层数组。

特点：

1. 读写分离：

• 读操作无锁，适合频繁读取的场景。
• 写操作时，复制数组，操作完成后替换原数组。

2. 线程安全：通过复制机制避免了写操作对读操作的影响。

3. 性能开销：

• 写操作较重，适合读多写少的场景。

常见用法：

import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

        // 添加元素
        list.add("A");
        list.add("B");

        // 遍历
        for (String s : list) {
            System.out.println(s);
        }

        // 修改操作
        list.add("C");
        System.out.println(list);
    }
}

适用场景：

• 多线程环境下的只读列表，如配置文件加载。

3. ConcurrentLinkedQueue

ConcurrentLinkedQueue 是一个基于链表的非阻塞队列，实现了无锁的并发访问。

特点：

1. 无锁：基于 CAS 操作实现线程安全，无需显式锁。
2. FIFO（先进先出）：插入和删除操作均遵循队列的 FIFO 规则。
3. 性能高：适合高并发环境下的队列操作。

常见用法：

import java.util.concurrent.ConcurrentLinkedQueue;

public class ConcurrentLinkedQueueExample {
    public static void main(String[] args) {
        ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();

        // 添加元素
        queue.add("A");
        queue.add("B");

        // 查看队头元素
        System.out.println(queue.peek());

        // 移除队头元素
        System.out.println(queue.poll());
    }
}

适用场景：

• 多线程环境下的任务队列。

4. BlockingQueue

BlockingQueue 是一个支持阻塞操作的队列，主要用于生产者-消费者模式。

子类：

• ArrayBlockingQueue：基于数组的有界阻塞队列。
• LinkedBlockingQueue：基于链表的阻塞队列，支持有界和无界。
• PriorityBlockingQueue：支持优先级排序的阻塞队列。
• SynchronousQueue：不存储元素的阻塞队列。

特点：

1. 阻塞操作：

• put() 和 take() 方法会阻塞线程，直到队列可用。

2. 线程安全：通过锁和条件变量实现线程安全。

常见用法：

import java.util.concurrent.ArrayBlockingQueue;

public class BlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(2);

        // 启动生产者线程
        new Thread(() -> {
            try {
                queue.put("A");
                System.out.println("Produced A");
                queue.put("B");
                System.out.println("Produced B");
                queue.put("C");
                System.out.println("Produced C");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        // 启动消费者线程
        new Thread(() -> {
            try {
                Thread.sleep(1000);
                System.out.println("Consumed: " + queue.take());
                System.out.println("Consumed: " + queue.take());
                System.out.println("Consumed: " + queue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

适用场景：

• 生产者-消费者模式下的任务分发。

5. ConcurrentSkipListMap 和 ConcurrentSkipListSet

这两个容器基于跳表（SkipList）实现，提供线程安全的有序集合和映射。

特点：

1. 有序性：基于跳表，所有元素按自然顺序或指定比较器排序。
2. 线程安全：支持并发访问。

常见用法：

import java.util.concurrent.ConcurrentSkipListMap;

public class ConcurrentSkipListMapExample {
    public static void main(String[] args) {
        ConcurrentSkipListMap<String, Integer> map = new ConcurrentSkipListMap<>();

        // 添加键值对
        map.put("C", 3);
        map.put("A", 1);
        map.put("B", 2);

        // 按顺序遍历
        map.forEach((key, value) -> System.out.println(key + ": " + value));
    }
}

适用场景：

• 需要线程安全的排序集合或映射，如排行榜。

总结

帅地永久会员

打赏 收藏 海报挣佣金 推广链接