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<String> set = ConcurrentHashMap.newKeySet();
Set<String> set = Collections.newSetFromMap(new ConcurrentHashMap<>());
//CopyOnWriteArraySet<String> 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();
}
}