多线程之旅-集合不安全

ArrayList不安全原因

假如我们定义一个ArrayList集合，然后开启多线程修改这个集合

	public static void listNotSafe() {
        ArrayList<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);
            }, "input thread name").start();
        }
    }

执行结果如下：

上述代码执行后会出现：java.util.ConcurrentModificationException
导致这一现象的原因就是多个线程同事争抢一个资源，并且没有加锁。
下面是add的源码，没有synchronized。

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

解决办法

1.Vector
List list = new Vector<>();

	/**
     * 有 synchronized 线程安全
     */
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

ArrayList 与Vector区别
性能：ArrayList 在性能方面要优于 Vector。
扩容：ArrayList 和 Vector 都会根据实际的需要动态的调整容量，只不过在 Vector 扩容每次会增加 1 倍，而 ArrayList 只会增加 50%。
Vector类的所有方法都是同步的。可以由两个线程安全地访问一个Vector对象。但是一个线程访问Vector的话，代码要在同步操作上耗费大量的时间。Arraylist不是同步的，所以在不需要保证线程安全时建议使用Arraylist。

2.Collections
List list = Collections. synchronizedList ( new ArrayList<>());
Collections提供了方法 synchronizedList保证list是同步线程安全的 。

3.写时复制
List list = new CopyOnWriteArrayList<>();

    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

原理：
	Arrays.copyOf(elements, len + 1);
写一个容器添加元素的时候，不直接往当前容器Object[]添加，而是先将当前容器进行copy，复制出一个新的容器Object[] newElements， 然后新容器添加元素。
之后再将原容器的引用指向当前新容器setArray(newElements)。这样的好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以也是一种读写分离的思想，读和写不同的容器。



HashSet不安全

底层是 HashMap,考察add方法利用map存值key不可重复

	private static final Object PRESENT = new Object();
	public boolean add(E e) {
		return map.put(e, PRESENT)==null;
	}

• 并发也会存在问题，线程不安全 java.util.ConcurrentModificationException
• 解决办法：
  • Collections.synchronizedSet(new HashSet<>());
  • CopyOnWriteArraySet

HashMap不安全

1.HashMap()
	Constructs an empty HashMap with the default initial capacity (16) and the default load factor (0.75).

2.HashMap(int initialCapacity)
	Constructs an empty HashMap with the specified initial capacity and the default load factor (0.75).

3.HashMap(int initialCapacity, float loadFactor)
	Constructs an empty HashMap with the specified initial capacity and load factor.

默认初始值16 负载因子0.75(一般可能会改) 扩容是扩一倍 有时候可以一次申请够，直接设置的初始值固定
底层是 Node类型的数组+Node类型链表+红黑树

• 并发也会存在问题，线程不安全 java.util.ConcurrentModificationException
• 解决办法：
  • Collections.synchronizedMap(new HashMap<>());
  • Map<String,String> map = new ConcurrentHashMap<>();