ArrayList解决线程不安全问题？

  我们都知道ArrayList是一个线程不安全的容器,哪在高并发多线程的情况下可能导致程序错误,可能出现的有三种情况,我们一一来分析一下.

static ArrayList list = new ArrayList(1000);
    @Override
    public void run() {
        for (int i = 0;i< 1000; i++ ){
            list.add(i);
        }
        System.out.println(list.size());
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new A());
        Thread t2 = new Thread(new A());
        t1.start();
        t2.start();
        Thread.sleep(1000);
        System.out.println("我们期待的值:" + list.size());
    }

这里我简单的模拟一下,线程抢占资源的情况,两个线程同时对一个ArrayList进行add操作.可能会出现三种情况
1.运气过分好,什么异常也没有抛出,也得到我们的期待值系统输出的值为2000.

2.抛出索引越界异常:

1367
Exception in thread "Thread-1" java.lang.ArrayIndexOutOfBoundsException: 750
    at java.util.ArrayList.add(ArrayList.java:463)
    at com.zto.test.A.run(ArraysListTest.java:18)
    at java.lang.Thread.run(Thread.java:748)

我们来分析一下为什么会出现这个情况,我们知道ArrayList底层是数组,在创建的时候会申请一块连续的内存的空间,在每次自动扩容的时候也会重新申请一块内存空间,简单的理解就是每次扩容的时候等于new了一个新的长度更大的ArrayList再把旧的数据回填.

之所以会出现这个异常,内部的一致性遭到破坏,由于没有锁,另外一个线程访问到了不一样的内存状态.简单来说是因为此时我们是多线程的,两个线程同时读取到我现在要添加的元素为ArrayList的最后一个,第一个线程申请自动扩容,此时自动扩容流程还未完成,而第二个线程执行add方法,就会出现索引越界异常.

3.不抛出异常,输出的值小于我们期待的值.

我们期待的值:1972

显然这也是一个多线程问题,两个线程同时访问到相同位置,后一个线程将前一个线程覆盖.所以导致最后得到的值远远小于我们期待的值.
这是一个隐蔽且最讨厌的错误.我们系统正常运行,得到值不正确,又不抛出异常,此时就需要我们开发人员凭借自己的丰富的经验去检查,如果此时系统过于庞大逻辑过于复杂,可能这个小错误,需要你好几天的时间.解决ArrayList线程安全的方法也很多.

解决ArrayList线程不安全问题：

(1)

改成线程安全的vector数组.这样当然效率很低. 或者上锁.最好的情况还是保证单一线程的修改

(2)

Collections.synchronizedLList(new ArrayList<><>());

（3）写时复制CopyOnWriteArrayList

CopyOnWriteArrayList的解决方案如下：
读读并行不做任何处理；
写写并行通过对写操作进行上锁来解决(使用锁机制ReentrantLock来串行化所有写操作)
读写并行通过对写方式的改造来解决(所有写操作完成，替换整个array内容)

       final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();  
            E oldValue = get(elements, index);
            if (oldValue != element) {
                int len = elements.length;
                Object[] newElements = Arrays.copyOf(elements, len);
                newElements[index] = element;
                setArray(newElements);
            } else {
                // Not quite a no-op; ensures volatile write semantics
                setArray(elements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }

因为有锁的限制,保证了写操作的原子性，使得读写操作可以并行
综上所述：读读 读写 写读均可以安全并行，仅仅将写写串行化了，减少了资源竞争的程度。