JUC之集合中的线程安全问题

集合线程安全问题

JDK Version:9

首先说下集合线程安全是什么：当多个线程对同一个集合进行添加和查询的时候，出现异常错误。

复现例子：

package com.JUC;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class ListSecutity04 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,8));

                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

效果图：

可以看到报ConcurrentModificationException并发修改异常；出现该错误的问题是，在ArrayList中的add方法没有加锁。

查看其源码：

public boolean add(E e) {
    modCount++;
    add(e, elementData, size);
    return true;
}
//----------------------------------------
public void add(int index, E element) {
    rangeCheckForAdd(index);
    modCount++;
    final int s;
    Object[] elementData;
    if ((s = size) == (elementData = this.elementData).length)
        elementData = grow();
    System.arraycopy(elementData, index,
                     elementData, index + 1,
                     s - index);
    elementData[index] = element;
    size = s + 1;
}
//----------------------------------------
private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
}

解决方式-：Vector和Conllections

见名知意，标题的两种方法都是比较古老的方法，使用Vector是因为其add方法中加的sychronized关键字修饰的

public synchronized boolean add(E e) {
    modCount++;
    add(e, elementData, elementCount);
    return true;
}

另一种方法是在Collection中的工具类synchronizedCollection(Collection<T> c)返回指定 collection 支持的同步（线程安全的）collection。

反复执行测试，代码通过：

package com.JUC;

import java.util.*;

public class ListSecutity04 {
    public static void main(String[] args) {

//        List<String> list = new ArrayList<>();
//        List<String> list = new Vector<>();
        List<String> list = Collections.synchronizedList(new ArrayList());
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,8));

                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

虽然但是，我们选择CopyOnWriteArrayList;

解决方式二：CopyOnWriteArrayList

写时复制技术：

List<String> list = new CopyOnWriteArrayList<>();

其思想：

在多线程的情况下，当对集合进行写的操作的时候，系统先将原来的内容(A)复制一份为(B)，原来的内容(A)可以进行并发读，复制后的内容(B)写入新的内容，当内容写入完成后，A与B实现覆盖或者说合并。

其中数组的定义我们使用的是volatile定义的，这样，每个线程可以实时的观察到数组的变化。

private transient volatile Object[] array;
final void setArray(Object[] a) {
    array = a;
}

add()方法源码：对lock对象加了锁

final transient Object lock = new Object();

public boolean add(E e) {
    synchronized (lock) {
        Object[] elements = getArray();  //获取原内容
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1); //数组复制
        newElements[len] = e;  //添加新的内容
        setArray(newElements);  //覆盖原数组
        return true;
    }
}

CopyOnWriteArrayList最大特点，读写分离，最终一致。比synchronized悲观锁性能较好。缺点就是，复制需要占用内存，可能出现OOM的情况。

与之类似线程不安全的集合有：HashMap,HashSet,其解决方法类似，在JUC中都有对应，

我们也可以进行代码的编写，并进入源码简单分析一下：

HashSet--CopyOnWriteArraySet

首先查看HashSet中的add方法的源码：(线程不安全)

public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}
//---------map中
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

从中可以看到，set集合底层使用的是map集合中的put方法，进入其方法中查看，是没有同步相关的代码修饰的。

也可以看出来Set集合是无序且不重复的，set中传入的E最后被传入到map中作为key。

然后查看下CopyOnWriteArraySet中add的源码：(线程安全)

public boolean add(E e) {
    return al.addIfAbsent(e);  //CopyOnWriteArrayList<E> al = new CopyOnWriteArrayList<E>()
}
//-------------addIfAbsent---------------
public boolean addIfAbsent(E e) {
    Object[] snapshot = getArray();
    return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
    addIfAbsent(e, snapshot);
}
//---------------------addIfAbsent------------------------
private boolean addIfAbsent(E e, Object[] snapshot) {
    synchronized (lock) {
        Object[] current = getArray();
        int len = current.length;
        if (snapshot != current) {
            // Optimize for lost race to another addXXX operation
            int common = Math.min(snapshot.length, len);
            for (int i = 0; i < common; i++)
                if (current[i] != snapshot[i]
                    && Objects.equals(e, current[i]))
                    return false;
            if (indexOf(e, current, common, len) >= 0)
                return false;
        }
        Object[] newElements = Arrays.copyOf(current, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    }

从源码可以看到，set使用的是CopyOnWriteArrayList，最终添加的数据在addIfAbsent方法中进行了同步。

HashMap--ConcurrentHashMap

HashMap解决的方式就是ConcurrentHashMap，其源码中采用的也是synchronized修饰的，具体的添加的流程，代码没读懂，暂且不表。

欢迎朋友分享下该部分的优质博客。