线程安全集合的几种方式、性能对比、适用场景分析

Set的底层实际上就是Map，所以线程安全的Set一般都会在Map上做文章，本文介绍的主要是JDK自带的一些方式。

测试方法

没有使用任何专业的测试工具，直接用代码创建线程来模拟，所以为了确保数据相对准确，每种方法都测试了20组。

测试代码

import java.util.Collections;
import java.util.Iterator;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.CountDownLatch;

public class ThreadSafeSet {
    public static void main(String[] args) throws InterruptedException {

        //Set set = ConcurrentHashMap.newKeySet();

        Set<String> set = Collections.newSetFromMap(new ConcurrentHashMap<>());

        //CopyOnWriteArraySet set = new CopyOnWriteArraySet();

        readMoreWriteLess(set);

        System.out.println("==========华丽的分隔符==========");

        //set = ConcurrentHashMap.newKeySet();

        set = Collections.newSetFromMap(new ConcurrentHashMap<>());

        //set = new CopyOnWriteArraySet();

        writeMoreReadLess(set);
    }

    private static void writeMoreReadLess(Set<String> set) throws InterruptedException {
        //测20组
        for (int k = 1; k <= 20; k++) {
            CountDownLatch countDownLatch = new CountDownLatch(10);
            long s = System.currentTimeMillis();
            //创建9个线程，每个线程向set中写1000条数据
            for (int i = 0; i < 9; i++) {
                new Thread(() -> {
                    for (int j = 0; j < 1000; j++) {
                        set.add(UUID.randomUUID().toString());
                    }
                    countDownLatch.countDown();
                }).start();
            }

            //创建1个线程，每个线程从set中读取所有数据，每个线程一共读取10次。
            for (int i = 0; i < 1; i++) {
                new Thread(() -> {
                    for (int j = 0; j < 10; j++) {
                        Iterator<String> iterator = set.iterator();
                        while (iterator.hasNext()) {
                            iterator.next();
                        }
                    }
                    countDownLatch.countDown();
                }).start();
            }
            //阻塞，直到10个线程都执行结束
            countDownLatch.await();
            long e = System.currentTimeMillis();
            System.out.println("写多读少：第" + k + "次执行耗时：" + (e - s) + "毫秒" + "，容器中元素个数为：" + set.size());
        }
    }

    private static void readMoreWriteLess(Set<String> set) throws InterruptedException {
        //测20组
        for (int k = 1; k <= 20; k++) {
            CountDownLatch countDownLatch = new CountDownLatch(10);
            long s = System.currentTimeMillis();
            //创建1个线程，每个线程向set中写10条数据
            for (int i = 0; i < 1; i++) {
                new Thread(() -> {
                    for (int j = 0; j < 10; j++) {
                        set.add(UUID.randomUUID().toString());
                    }
                    countDownLatch.countDown();
                }).start();
            }

            //创建9个线程，每个线程从set中读取所有数据，每个线程一共读取100万次。
            for (int i = 0; i < 9; i++) {
                new Thread(() -> {
                    for (int j = 0; j < 1000000; j++) {
                        Iterator<String> iterator = set.iterator();
                        while (iterator.hasNext()) {
                            iterator.next();
                        }
                    }
                    countDownLatch.countDown();
                }).start();
            }
            countDownLatch.await();
            long e = System.currentTimeMillis();
            System.out.println("读多写少：第" + k + "次执行耗时：" + (e - s) + "毫秒" + "，容器中元素个数为：" + set.size());
        }
    }
}

测试结果

1、ConcurrentHashMap.newKeySet()

2、Collections.newSetFromMap(new ConcurrentHashMap<>())

3、CopyOnWriteArraySet

三种方式对比

1、前两种方式互相比较，在读多写少的时候性能差不多，最后一次读取时耗时4-5秒，在写多读少时性能也差不多。

2、第三种方式与前两种方式相比，在写多读少时，效率要明显低于前两种方式，但在读多写少时，效率又要明显高于前两种方式。

性能影响分析

ConcurrentHashMap.newKeySet()是在JDK1.8时提供的方式，而Collections.newSetFromMap(new ConcurrentHashMap<>())是在JDK1.6时提供的，两种方式从底层上来看都是基于ConcurrentHashMap来保证线程安全的，所以从本次测试结果也可以看出，二者并没有非常明显的差距。1.8的实现方式看起来就比1.6少了一层嵌套，看起来更加的优雅，其他方面我也实在没看出来有什么区别。。。

newKeySet

newSetFromMap

而CopyOnWriteArraySet就与前两种方法的实现思路不一样了，其底层是CopyOnWriteArrayList，主要实现思想就是写时复制，简单的来说就是当多线程读取数据时不会加锁（只要在读之前每个线程先获取一份当前数据集合的快照，然后线程各自从自己的快照中读取数据即可），当有多个线程要写数据时，则每个线程必须要先获取锁才能写，而写的过程是通过复制一份新的数据用来替换旧的数据实现的。

添加元素

遍历元素

适用场景分析

根据写时复制的特点，读的时候不需要加锁，所以当读多写少时应当考虑优先使用CopyOnWriteArraySet，但如果写多的情况下由于CopyOnWriteArraySet每次都需要锁住整个容器并会产生频繁的数组复制过程，所以性能会不太理想，此时就应当考虑使用newKeySet或者newSetFromMap。而newKeySet或newSetFromMap底层都是通过ConcurrentHashMap来实现，所以性能也取决于ConcurrentHashMap本身（分段锁 cas synchronized实现）。

当然使用CopyOnWriteArraySet还需要注意一点，写入的数据可能不会被及时的读取到，因为遍历的是读取之前获取的快照。

这段代码可以测试CopyOnWriteArraySet写入数据不能被及时读取到的问题。

public class COWSetTest {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArraySet<Integer> set = new CopyOnWriteArraySet();
        new Thread(() -> {
            try {
                set.add(1);
                System.out.println("第一个线程启动，添加了一个元素，睡100毫秒");
                Thread.sleep(100);
                set.add(2);
                set.add(3);
                System.out.println("第一个线程添加了3个元素，执行结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        //保证让第一个线程先执行
        Thread.sleep(1);

        new Thread(() -> {
            try {
                System.out.println("第二个线程启动了！睡200毫秒");
                //Thread.sleep(200);//如果在这边睡眠，可以获取到3个元素
                Iterator<Integer> iterator = set.iterator();//生成快照
                Thread.sleep(200);//如果在这边睡眠，只能获取到1个元素
                while (iterator.hasNext()) {
                    System.out.println("第二个线程开始遍历，获取到元素：" + iterator.next());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

    }
}