在Java中，哪些Set实现是线程安全的？

在 Java 中，Set 接口的默认实现（如 HashSet、TreeSet、LinkedHashSet 等）不是线程安全的。如果需要线程安全的 Set，可以通过以下方式实现：

1. 线程安全的 Set 实现

1.1 Collections.synchronizedSet

• 简介：
  • Java 提供了 Collections.synchronizedSet 方法，用于将普通的 Set 包装为线程安全的 Set。
  • 内部通过同步锁（synchronized）来保证线程安全。
• 用法：
  • 将任意非线程安全的 Set（如 HashSet）包装为线程安全的 Set。
• 注意事项：
  • 迭代时需要手动同步，否则可能抛出 ConcurrentModificationException。

代码示例：

import java.util.*;

public class SynchronizedSetExample {
    public static void main(String[] args) {
        // 创建普通的 HashSet
        Set<String> hashSet = new HashSet<>();

        // 转换为线程安全的 Set
        Set<String> synchronizedSet = Collections.synchronizedSet(hashSet);

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

        // 遍历时需要手动同步
        synchronized (synchronizedSet) {
            for (String s : synchronizedSet) {
                System.out.println(s);
            }
        }
    }
}

1.2 CopyOnWriteArraySet

• 简介：
  • CopyOnWriteArraySet 是一个线程安全的 Set，底层基于 CopyOnWriteArrayList 实现。
  • 在每次写操作（如 add、remove）时，会复制底层数组，从而保证线程安全。
• 特点：
  • 读操作非常快，不需要加锁。
  • 写操作性能较低，因为每次写都会复制数组。
  • 遍历时不会抛出 ConcurrentModificationException。
• 适用场景

  ：

  • 读多写少的场景，例如缓存、配置数据存储。

代码示例：

import java.util.concurrent.CopyOnWriteArraySet;

public class CopyOnWriteArraySetExample {
    public static void main(String[] args) {
        // 创建线程安全的 CopyOnWriteArraySet
        CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<>();

        // 添加元素
        set.add("A");
        set.add("B");
        set.add("A"); // 重复元素不会被添加

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

1.3 ConcurrentSkipListSet

• 简介：
  • ConcurrentSkipListSet 是一个基于跳表（Skip List）的线程安全有序 Set。
  • 它实现了 NavigableSet 接口，支持自然排序或自定义排序。
  • 线程安全是通过 非阻塞算法（CAS） 和细粒度锁实现的。
• 特点：
  • 动态排序，线程安全。
  • 支持高效的有序操作，如范围查询、头尾查询等。
• 适用场景：
  • 需要线程安全的同时，要求集合中的元素保持有序。

代码示例：

import java.util.concurrent.ConcurrentSkipListSet;

public class ConcurrentSkipListSetExample {
    public static void main(String[] args) {
        // 创建线程安全的 ConcurrentSkipListSet
        ConcurrentSkipListSet<Integer> set = new ConcurrentSkipListSet<>();

        // 添加元素
        set.add(3);
        set.add(1);
        set.add(2);

        // 遍历元素（自然排序）
        for (Integer i : set) {
            System.out.println(i); // 输出：1, 2, 3
        }
    }
}

2. 比较常见的线程安全 Set 实现

3. 如何选择合适的线程安全 Set？

3.1 根据是否需要排序

• 如果需要 有序集合：
  • 使用 ConcurrentSkipListSet（适合高并发、需要排序）。
• 如果不需要排序：
  • 使用 Collections.synchronizedSet 或 CopyOnWriteArraySet。

3.2 根据读写操作的频率

• 读多写少：
  • 推荐使用 CopyOnWriteArraySet。
  • 示例：缓存场景，数据变更不频繁，但读取频繁。
• 读写均衡或写多：
  • 推荐使用 ConcurrentSkipListSet 或 Collections.synchronizedSet。

4. 注意事项

4.1 手动同步问题

• 使用Collections.synchronizedSet时，迭代操作需要手动加锁：

  Set<String> set = Collections.synchronizedSet(new HashSet<>());
  synchronized (set) {
    for (String s : set) {
        System.out.println(s);
    }
  }
  

4.2 写时复制性能开销

• CopyOnWriteArraySet 在每次写操作时会复制底层数组，写操作性能较低。
• 不适合高频写入的场景。

4.3 内存消耗

• CopyOnWriteArraySet 的写时复制会增加内存消耗。
• 在高并发场景下，如果内存有限，建议使用 ConcurrentSkipListSet。

5. 示例对比

场景：高并发环境中访问线程安全的 Set

import java.util.*;
import java.util.concurrent.*;

public class ThreadSafeSetExample {
    public static void main(String[] args) {
        // 创建不同的线程安全 Set
        Set<String> synchronizedSet = Collections.synchronizedSet(new HashSet<>());
        CopyOnWriteArraySet<String> copyOnWriteSet = new CopyOnWriteArraySet<>();
        ConcurrentSkipListSet<String> concurrentSet = new ConcurrentSkipListSet<>();

        // 创建线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 执行多线程操作
        Runnable task = () -> {
            for (int i = 0; i < 5; i++) {
                synchronizedSet.add(Thread.currentThread().getName() + "-" + i);
                copyOnWriteSet.add(Thread.currentThread().getName() + "-" + i);
                concurrentSet.add(Thread.currentThread().getName() + "-" + i);
            }
        };

        for (int i = 0; i < 3; i++) {
            executor.submit(task);
        }

        executor.shutdown();
        try {
            executor.awaitTermination(1, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 输出结果
        System.out.println("SynchronizedSet: " + synchronizedSet);
        System.out.println("CopyOnWriteArraySet: " + copyOnWriteSet);
        System.out.println("ConcurrentSkipListSet: " + concurrentSet);
    }
}

6. 总结

• Java 提供了多种线程安全的 Set实现：
  • Collections.synchronizedSet：通用线程安全解决方案，但需要手动同步迭代。
  • CopyOnWriteArraySet：适合读多写少的场景。
  • ConcurrentSkipListSet：适合高并发场景，同时支持排序和范围查询。

帅地永久会员

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