总共有两大接口:Collection 和 Map ,一个元素集合,一个是键值对集合; 其中 List 和 Set 接口继承了 Collection 接口,一个是有序元素集合,一个是无序元素集合; 而 ArrayList 和 LinkedList 实现了 List 接口,HashSet 实现了 Set 接口,这几个都比较常用; HashMap 和 HashTable 实现了 Map 接口,并且 HashTable 是线程安全的,但是 HashMap 性能更好;
java.util.Collection 是一个集合接口(集合类的一个顶级接口)。它提供了对集合对象进行基本操作的通用接口方法。Collection 接口在 Java 类库中有很多具体的实现。Collection 接口的意义是为各种具体的集合提供了最大化的统一操作方式,其直接继承接口有 List 与 Set。
Collections 则是集合类的一个工具类/帮助类,其中提供了一系列静态方法,用于对集合中元素进行排序、搜索以及线程安全等各种操作。
快速失败:当你在迭代一个集合的时候,如果有另一个线程正在修改你正在访问的那个集合时,就会抛出一个 ConcurrentModification 异常。
在 java.util 包下的都是快速失败,不能在多线程下发生并发修改(迭代过程中被修改)。
安全失败:你在迭代的时候会去底层集合做一个拷贝,所以你在修改上层集合的时候是不会受影响的,不会抛出 ConcurrentModification 异常。
在 java.util.concurrent 包下的全是安全失败的。可以在多线程下并发使用,并发修改。
首先我们查看如下案例:
public class ListTest { public static void main(String[] args) { List<String> list = new ArrayList<>(); for(int i=0;i<10;i++){ new Thread(()->{ list.add(UUID.randomUUID().toString().substring(0,5)); System.out.println(list); },String.valueOf(i)).start(); } } } 复制代码
执行上述代码,会抛出 java.util.ConcurrentModificationException
并发异常。
public class ListTest { public static void main(String[] args) { List<String> list = new Vector<>(); for(int i=0;i<10;i++){ new Thread(()->{ list.add(UUID.randomUUID().toString().substring(0,5)); System.out.println(list); },String.valueOf(i)).start(); } } } 复制代码
Vector 类是在 JDK1.0 出现的,比 ArrayList 还早,那为什么不推荐该方法呢?查看源码得知:
public synchronized boolean add(E var1) { ++this.modCount; this.ensureCapacityHelper(this.elementCount + 1); this.elementData[this.elementCount++] = var1; return true; } 复制代码
使用 Synchronized 关键字来实现同步操作,效率较低。原因:在 Java 早期版本中,synchronized 属于重量级锁,效率低下,因为监视器锁(monitor)是依赖于底层的操作系统的 Mutex Lock 来实现的,Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程,都需要操作系统帮忙完成,而操作系统实现线程之间的切换时需要从用户态转换到内核态,这个状态之间的转换需要相对比较长的时间,时间成本相对较高,这也是为什么早期的 synchronized 效率低的原因。庆幸的是在 Java 6 之后 Java 官方对从 JVM 层面对 synchronized 较大优化,所以现在的 synchronized 锁效率也优化得很不错了。JDK1.6 对锁的实现引入了大量的优化,如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。
List<String> list = Collections.synchronizedList(new ArrayList<>()); 复制代码
同样我们来查看源码, Collections.synchronizedList()
的定义如下:
public static <T> List<T> synchronizedList(List<T> var0) { return (List)(var0 instanceof RandomAccess ? new Collections.SynchronizedRandomAccessList(var0) : new Collections.SynchronizedList(var0)); } 复制代码
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable 复制代码
一路跳转后,最终定位到 SynchronizedCollection 静态内部类,List 对象也就变为了 SynchronizedCollection 类型,查看其 add 方法定义:
public boolean add(E var1) { synchronized(this.mutex) { return this.c.add(var1); } } 复制代码
同 Vector 一样,还是采用的 Synchronized 关键字来做同步操作,只是封装在 Collections 工具类中。
我们来通过看源码的方式来理解 CopyOnWriteArrayList,实际上 CopyOnWriteArrayList 内部维护的也是一个数组
private transient volatile Object[] array; 复制代码
只是该数组是被 volatile 修饰,注意这里 仅仅修饰的是数组引用 ,与被 volatile 修饰的普通变量有所区别,关于这点我在之前的文章中有分析,对 volatile 还不是太了解的朋友也可以去看一下。对 list 来说,我们自然而然最关心的就是读写的时候,分别为 get 和 add 方法的实现。
以下方式利用 CopyOnWriteArrayList 来保证线程安全。
List<String> list = new CopyOnWriteArrayList<>(); 复制代码
CopyOnWriteArrayList 比 Vector 更高级,因为加锁的方式不一样,前者使用 Lock 锁。查看其 add 方法定义:
public boolean add(E var1) { ReentrantLock var2 = this.lock; var2.lock(); boolean var6; try { Object[] var3 = this.getArray(); int var4 = var3.length; Object[] var5 = Arrays.copyOf(var3, var4 + 1); var5[var4] = var1; this.setArray(var5); var6 = true; } finally { var2.unlock(); } return var6; } 复制代码
除了通过 Lock 来加锁处理,每次写数据前,都会另外通过 Arrays.copyOf 方法复制一份数据,在写入的时候避免覆盖,造成数据问题。
我们需要注意 CopyOnWriteArrayList 中的这两个字段属性以及相关方法。
final transient ReentrantLock lock = new ReentrantLock(); private transient volatile Object[] array; final Object[] getArray() { return this.array; } final void setArray(Object[] var1) { this.array = var1; } 复制代码
注意事项:
CopyOnWriteArrayList 的缺点:
CopyOnWriteArrayList 的优点:
关于优缺点中各自的第二条,通过以下案例向大家说明:
public class CowTest { public static void main(String[] args) { // 初始化一个list,放入5个元素 final List<Integer> list = new CopyOnWriteArrayList<>(); // final List<Integer> list = new Vector<>(); // final List<Integer> list = Collections.synchronizedList(new ArrayList<>()); for(int i = 0; i < 5; i++) { list.add(i); } // 线程一:通过Iterator遍历List Thread t1 = new Thread(()-> { for(int item : list) { System.out.println("遍历元素:" + item); // 由于程序跑的太快,这里sleep了1秒来调慢程序的运行速度 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); // 线程二:add一个元素 Thread t2 = new Thread(() ->{ // 由于程序跑的太快,这里sleep了1秒来调慢程序的运行速度 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } list.add(5); }); t1.start(); t2.start(); try { t1.join(); t2.join(); System.out.println(list); } catch (InterruptedException e) { e.printStackTrace(); } } } 复制代码
执行结果为:
遍历元素:0 遍历元素:1 遍历元素:2 遍历元素:3 遍历元素:4 [0, 1, 2, 3, 4, 5] 复制代码
当线程1在遍历集合,线程2往集合中新增一个数据,如果使用前两种线程安全的替换方案,有可能产生 ConcurrentModificationException 异常。为什么 CopyOnWriteArrayList 就没问题呢?原因在于它保证线程安全采用的是 写时复制并加锁 ,所以线程1在遍历时拿到的集合是旧的,这也就是结果中为啥没有输出5的原因,虽然拿到的是旧集合,但是至少不会报错。
CopyOnWriteArrayList 只能保证数据最终一致性,这点从结果中可以看出来,当在线程2中给集合新增了元素,但是无法立即通知到线程1,所以无法保证数据实时性。但是当其他线程再次读取集合时,才能读取到完整的新数据。
CopyOnWriteArrayList
适合在读多写少的场景使用,实时性要求不高,不然读取到的可能是旧数据。添加数据可以采用批量添加 addAll 方法,减少内存占用。 首先我们查看如下案例:
public class SetTest { public static void main(String[] args) { Set<String> set= new HashSet<>(); for (int i = 0; i < 20; i++) { new Thread(()->{ set.add(UUID.randomUUID().toString().substring(0,5)); System.out.println(set); },String.valueOf(i)).start(); } } } 复制代码
执行上述代码,会抛出 java.util.ConcurrentModificationException
并发异常。
Set<String> set = Collections.synchronizedSet(new HashSet<>()); 复制代码
同 List 使用 Collections.synchronizedList()
一样,通过 synchronized 来实现线程安全。
Set<String> set = new CopyOnWriteArraySet<>(); 复制代码
我们点击查看 CopyOnWriteArraySet 类,发现其背后通过 CopyOnWriteArrayList 来存储数据。
private final CopyOnWriteArrayList<E> al; public CopyOnWriteArraySet() { this.al = new CopyOnWriteArrayList(); } 复制代码
我们知道 Set 集合中的元素是不可重复,那么这是怎么做到的呢?首先来查看 add 方法。
public boolean add(E var1) { return this.al.addIfAbsent(var1); } 复制代码
实际上是执行 CopyOnWriteArrayList 中的 addIfAbsent 方法。
public boolean addIfAbsent(E var1) { Object[] var2 = this.getArray(); //获取当前数组信息 //indexOf方法用于比对新增值在原数组中是否存在,若存在,则返回值不小于0,否则返回-1,即要执行addIfAbsent方法 return indexOf(var1, var2, 0, var2.length) >= 0 ? false : this.addIfAbsent(var1, var2); } private boolean addIfAbsent(E var1, Object[] var2) { ReentrantLock var3 = this.lock; var3.lock(); try { Object[] var4 = this.getArray(); int var5 = var4.length; boolean var13; if (var2 != var4) { int var6 = Math.min(var2.length, var5); for(int var7 = 0; var7 < var6; ++var7) { if (var4[var7] != var2[var7] && eq(var1, var4[var7])) { boolean var8 = false; return var8; } } if (indexOf(var1, var4, var6, var5) >= 0) { var13 = false; return var13; } } Object[] var12 = Arrays.copyOf(var4, var5 + 1); var12[var5] = var1; this.setArray(var12); var13 = true; return var13; } finally { var3.unlock(); } } 复制代码
同 CopyOnWriteArrayList 中的 add 方法类似,addIfAbsent 方法也是先加锁,然后写前复制来保证线程安全。
首先我们查看如下案例:
public class MapTest { public static void main(String[] args) { // Map<String,Object> map = new HashMap<>(); //加载因子和初始容量 //等价于:new HashMap(16,0.75) for (int i = 0; i < 30; i++) { new Thread(()->{ map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5)); System.out.println(map); },String.valueOf(i)).start(); } } } 复制代码
执行上述代码,会抛出 java.util.ConcurrentModificationException
并发异常。
Map<String,Object> map = Collections.synchronizedMap(new HashMap<>()); 复制代码
Map<String,Object> map = new Hashtable<>(); 复制代码
该类通过对读写进行加锁(synchronized)操作,一个线程在读写元素,其余线程必须等待,性能较低。
Map<String,Object> map = new ConcurrentHashMap<>(); 复制代码
关于 ConcurrentHashMap 的详细学习,可以参考这篇 文章 。
并发容器之CopyOnWriteArrayList
先简单说一说Java中的CopyOnWriteArrayList
如何线程安全地遍历List:Vector、CopyOnWriteArrayList