集合类不安全之ArrayList

1. 不安全的ArrayList

大家都知道ArrayList线程不安全，怎么个不安全法呢？上代码：

public class ContainerNotSafeDemo {

    public static void main(String[] args) throws InterruptedException {

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

        for (int i = 0;i<5;i++){

            new Thread(()->{

                list.add(Thread.currentThread().getName());

                System.out.println(Thread.currentThread().getName()+"\t"+list);

            }).start();

        }

    }

}

//运行结果如下： 多个线程同时修改列表的元素，产生了并发修改异常

java.util.ConcurrentModificationException

	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)

	at java.util.ArrayList$Itr.next(ArrayList.java:859)

	at java.util.AbstractCollection.toString(AbstractCollection.java:461)

	at java.lang.String.valueOf(String.java:2994)

	at java.lang.StringBuilder.append(StringBuilder.java:131)

	at juc.ContainerNotSafeDemo.lambda$main$0(ContainerNotSafeDemo.java:26)

	at java.lang.Thread.run(Thread.java:748)

为啥呢？看一下add()方法的源码：

    public boolean add(E e) {

        ensureCapacityInternal(size + 1);  // Increments modCount!!

        elementData[size++] = e;

        return true;

    }

可以看到仅仅是在扩容和添加操作，并没有任何的线程安全控制。所以在实际的高并发场景下，ArrayList的应用很有局限。

2. 安全的解决方式

2.1 使用Vector解决

注意到，ArrayList的add方法并没有任何保证线程安全的机制 ~ 所以不安全了。怎么解决呢？首先想到的是加锁，凑巧的是Vector已经为我们提供了安全的add方法：

public class ContainerNotSafeDemo {

    public static void main(String[] args) throws InterruptedException {

        List<String> list = new Vector<>();//修改为Vector对象

        for (int i = 0;i<3;i++){

            new Thread(()->{

                list.add(Thread.currentThread().getName());

                System.out.println(Thread.currentThread().getName()+"\t"+list);

            }).start();

        }

    }

}

//结果如下：

Thread-0	[Thread-0]

Thread-2	[Thread-0, Thread-2]

Thread-1	[Thread-0, Thread-2, Thread-1]

这么看来，在这种情况下多线程的添加操作是没有任何问题的？那么，这么做真的可取嘛？尝试查看Vector的add()方法源码：

    public synchronized boolean add(E e) {

        modCount++;

        ensureCapacityHelper(elementCount + 1);

        elementData[elementCount++] = e;

        return true;

    }

可以看到：Vector使用了synchronized关键字来保证线程安全。可是为了添加一个的操作，加了个重锁，这样做在多线程环境下会造成严重的资源浪费与性能损耗！！高并发情况下是万万不可取的。矛盾来了：ArrayList可以提升并发性，但是牺牲了线程安全性，而Vector恰恰与之相反。所以，我们在不同的场合下可以根据业务需求有所取舍。

### 2.4 使用Collections解决

一个神奇的工具类——Collections，看一下它的结构：

可以看到这个工具类提供了SynchronizedList、SynchronizedMap、SynchronizedSet等看名字就很安全的类，怎么实现的嗫？看Collections.synchronizedList(List list) 方法源码：

    public static <T> List<T> synchronizedList(List<T> list) {

        return (list instanceof RandomAccess ?

                new SynchronizedRandomAccessList<>(list) :

                new SynchronizedList<>(list));

    }

我们在传值的时候传的是ArrayList的对象，ArrayList它又实现了RandomAccess，所以返回 new SynchronizedRandomAccessList<>(list, mutex)对象，但是：

    static class SynchronizedRandomAccessList<E>

        extends SynchronizedList<E>

        implements RandomAccess {

        ...

        }

 //它又继承了SynchronizedList，所以返回的还是SynchronizedList对象

看SynchronizedList它的源码怎么写：

static class SynchronizedList<E>

        extends SynchronizedCollection<E>

        implements List<E> {

        ...

        final List<E> list;

        SynchronizedList(List<E> list) {

            super(list);

            this.list = list;

        }

        SynchronizedList(List<E> list, Object mutex) {

            super(list, mutex);

            this.list = list;

        }

        ...

        ...

        public E get(int index) {

            synchronized (mutex) {return list.get(index);}

        }

        public E set(int index, E element) {

            synchronized (mutex) {return list.set(index, element);}

        }

        public void add(int index, E element) {

            synchronized (mutex) {list.add(index, element);}

        }

        public E remove(int index) {

            synchronized (mutex) {return list.remove(index);}

        }

    ...

 }

可以看到，SynchronizedList 的实现里，get, set, add 等操作都加了 mutex 对象锁，再将操作委托给最初传入的 list。mutex来自哪里？

        SynchronizedCollection(Collection<E> c) {

            this.c = Objects.requireNonNull(c);

            mutex = this;    //mutex就是这个list本身咯~

        }

### 2.4 使用CopyOnWriteArrayList解决

还是下边这段代码，进行了一下简单的修改：

public class ContainerNotSafeDemo {

    public static void main(String[] args) throws InterruptedException {

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

        for (int i = 0;i<3;i++){

            new Thread(()->{

                list.add(Thread.currentThread().getName());

                System.out.println(Thread.currentThread().getName()+"\t"+list);

            }).start();

        }

    }

}

使用到了new CopyOnWriteArrayList<>();，字面意思看来时：写时复制集合。

先来了解一下Copy-On-Write(写时复制技术)：通俗的讲，写时复制技术就是不同进程访问同一资源的时候，只有在写操作，才会去复制一份新的数据，否则都是访问同一个资源。

CopyOnWriteArrayList，是一个写入时复制的容器，它是如何工作的呢？简单来说，就是平时查询的时候，都不需要加锁，随便访问，只有在写入/删除的时候，才会从原来的数据复制一个副本出来，然后修改这个副本，最后把原数据替换成当前的副本。修改操作的同时，读操作不会被阻塞，而是继续读取旧的数据。这点要跟读写锁区分一下。

那么java里面是如何实现的，看源码：

    /**

     * Appends the specified element to the end of this list.【添加元素至列表末尾】

     * @param e element to be appended to this list          【e:新增的元素】

     * @return {@code true} (as specified by {@link Collection#add})

     */

    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);  //拷贝一份旧容器，并且扩容+1

            newElements[len] = e;                  //填充元素

            setArray(newElements);                 //新的集合列表替换掉旧的

            return true;

        } finally {

            lock.unlock();

        }

    }

我们看到Java中JDK的源码实现其实也是非常的简单，往一个容器里添加元素的时候，不直接往当前容器object[]添加，而是先将当前容器object[]进行cpoy，复制出来一个新的容器object[] newElements，然后往新的容器newElements里面添加元素。添加完成之后再将原容器的引用指向新的容器setArray(newElements);。

优点：对于一些读多写少的数据，这种做法的确很不错，对容器并发的读不需要加锁，因为此时容器内不会添加任何新的元素。所以CopyOnWriteArrayList也是一种读写分离的思想，读和写操作的是不同的容器。

缺点：这种实现只保证数据的最终一致性，在副本未替换掉旧数据时，读到的仍然是旧数据。如果对象比较大，频繁地进行替换会消耗内存，从而引发频繁的GC，此时，应考虑其他的容器，例如ConcurrentHashMap。

巴特西

集合类不安全之ArrayList

1. 不安全的ArrayList

2. 安全的解决方式

2.1 使用Vector解决

最新文章

热门文章