线程不安全的ArrayList, Set, Map

众所周知,ArrayList -> List -> Collection, ArrayList线程不安全。同理,Map, Set都是线程不安全。ArrayList总结起来就是: 初始化size为10的Object类型的数组。多并发修改值时可能: ConcurrentModificationException.

出现ConcurrentModificationExceptionArrayList举例:30个线程同时对list进行add:

public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }

各种exception:

  1. 同时对list读写: ConcurrentModificationException. 解决办法: Vector, Collections.synchronizedList(new ArrayList<>()), CopyOnWriteArrayList
  2. IllegalMonitorStateException: 没有加lock/synchronized: 多线程争抢操作资源类
  3. java自带的类.getClass().getClassLoader().**getParent()**...: NullPointerException;
  4. thread.start()调用多次: IllegalThreadStateException

ArrayList -> CopyOnWriteArrayList
HashSet  -> CopyOnWriteArraySet
   |
   v
HashMap  -> ConcurrentHashMap
  1. ArrayList: default cap: 10; grow strategy: newCap= = oldCap + (oldCap >> 1): 15, 22...
  2. HashMap: default cap: 16; grow strategy: newCap = oldCap << 1; 是2^n;

ArrayList扩容中,new/old交替赋值元素用的方法是Arrays.copyOf:

elementData = Arrays.copyOf(elementData, newCapacity);

如何用线程安全的ArrayList?

Vector. 但是,不好👎,因为这是JDK 1.0的, 加了synchronized并发性下降。实际上ArrayList是JDK 1.2的(Doug Lea),就是为了解决并发性能低才有的这个类.

怎么办?
Collections是工具类:Collections.synchronizedList(new ArrayList<>()).可以点进去看源码, 和ArrayList的add方法的区别就是, 方法前面有没有synchronized修饰.

还有更吊的: java.util.concurrent包中的类: CopyOnWriteArrayList, 写时复制。也是线程安全的.

为什么? 点进去:

public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

点进去:

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

点进去:

/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;

add方法

/**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#add})
     */
public boolean add(E e) {
        final ReentrantLock lock = this.lock; // only 1 write/read happens at a time
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1); // add just 1 element
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

可以看出来, CopyOnWrite这种写时复制的容器,不是直接往那个容器添加元素,而是将当前的容器elements进行copy得到一个新的容器newElements,然后往新的容器中写。写完之后,把指向原来容器的引用指向新的容器setArray(newElements), 这样在写的时候并不影响从之前的容器中读, i.e. 可以对CopyOnWrite容器进行并发的读,这个读不需要加锁,因为当前容器不会添加任何元素。所以CopyOnWrite是一种读写分离的思想,读写分离的容器。

当然,这种Arrays.copyOf过于频繁也不好,这种就看场景,如果是读多写少的场景, e.g. 跟mysql那种类似的场景,用这个就很合适。

Set:

public static void main(String[] args) {
//        listNotSafe();
        Set<String> set = new HashSet<>();
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(set);
            }, String.valueOf(i)).start();
        }
    }

因为HashSet和前面的ArrayList类似,也不是线程安全的,所以上面的会有ConcurrentModificationException;
问: HashSet是怎么实现的?

public HashSet() {
        map = new HashMap<>();
    }

诶?那一个KV对一个是就只是单个元素,怎么搞的?
找add:

public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

PRESENT是个常量:

// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();

噢,原来value就是个new Object().

为什么value不是null? 因为既然set底层是map, 而map在remove(Object key``时返回value, 如果底层都是null`,不能区分是否是否remove成功

Map: 同:

Map<String, String> map = new HashMap<>();
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 8));
                System.out.println(map);
            }, String.valueOf(i)).start();
        }

报错: ConcurrentModificationException;
换map: ConcurrentHashMap:


碰到bug,四步走:

  1. 故障现象
  2. 导致原因
  3. 解决方案
  4. 优化建议

天下武功根本没有高低之分,只有习武之人有强弱之别

推荐阅读更多精彩内容