List下如何保证线程安全

之前在看一些模拟面试的视频时，面试官问到：“List如何保证线程安全“。
我脑海中首先想到的是使用List接口下的Vector集合。
然后面试者也同样简单的说出使用Vector集合。
但是面试官显然对这个回答并不满意。
那么List应该如何保证线程安全呢？

这个问题其实可以从《深入理解Java虚拟机》这本书中找到答案

绝对线程安全

绝对的线程安全能够完全满足Brian Goetz给出的线程安全的定义，这个定义其实是很严格的，一 个类要达到“不管运行时环境如何，调用者都不需要任何额外的同步措施”可能需要付出非常高昂的， 甚至不切实际的代价。在Java API中标注自己是线程安全的类，大多数都不是绝对的线程安全。我们 可以通过Java API中一个不是“绝对线程安全”的“线程安全类型”来看看这个语境里的“绝对”究竟是什么 意思。
如果说java.util.Vector是一个线程安全的容器，相信所有的Java程序员对此都不会有异议，因为它 的add()、get()和size()等方法都是被synchronized修饰的，尽管这样效率不高，但保证了具备原子性、 可见性和有序性。不过，即使它所有的方法都被修饰成synchronized，也不意味着调用它的时候就永远 都不再需要同步手段了，请看看代码清单13-2中的测试代码。

对Vector线程安全的测试

private static Vector<Integer> vector = new Vector<Integer>();

    public static void main(String[] args) {

        while (true) {
            for (int i = 0; i < 10; i++) {
                vector.add(i);
            }
            Thread removeThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < vector.size(); i++) {
                        vector.remove(i);
                    }
                }
            });
            Thread printThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < vector.size(); i++) {
                        System.out.println((vector.get(i)));
                    }
                }
            });
            removeThread.start();
            printThread.start();
            while (Thread.activeCount() > 20) ;
        }
    }

运行结果如下：

Exception in thread "Thread-45907" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 17
    at java.base/java.util.Vector.get(Vector.java:780)
    at com.sleep.Demo01$2.run(Demo01.java:27)
    at java.base/java.lang.Thread.run(Thread.java:834)

很明显，尽管这里使用到的Vector的get()、remove()和size()方法都是同步的，但是在多线程的环境 中，如果不在方法调用端做额外的同步措施，使用这段代码仍然是不安全的。因为如果另一个线程恰 好在错误的时间里删除了一个元素，导致序号i已经不再可用，再用i访问数组就会抛出一个 ArrayIndexOutOfBoundsException异常。如果要保证这段代码能正确执行下去，我们不得不把 removeThread和printThread的定义改成代码所示的这样。

必须加入同步保证Vector访问的线程安全性

private static Vector<Integer> vector = new Vector<Integer>();

    public static void main(String[] args) {

        while (true) {
            for (int i = 0; i < 10; i++) {
                vector.add(i);
            }
            Thread removeThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (vector) {
                        for (int i = 0; i < vector.size(); i++) {
                            vector.remove(i);
                        }
                    }
                }
            });
            Thread printThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (vector) {
                        for (int i = 0; i < vector.size(); i++) {
                            System.out.println((vector.get(i)));
                        }
                    }
                }
            });
            removeThread.start();
            printThread.start();
            while (Thread.activeCount() > 20) ;
        }
    }

假如Vector一定要做到绝对的线程安全，那就必须在它内部维护一组一致性的快照访问才行，每次 对其中元素进行改动都要产生新的快照，这样要付出的时间和空间成本都是非常大的。

相对线程安全

相对线程安全就是我们通常意义上所讲的线程安全，它需要保证对这个对象单次的操作是线程安 全的，我们在调用的时候不需要进行额外的保障措施，但是对于一些特定顺序的连续调用，就可能需 要在调用端使用额外的同步手段来保证调用的正确性。

CopyOnWriteArrayList

1.CopyOnWriteArrayList（字译名称：写时复制），它可以看成是线程安全且读操作无锁的ArrayList。

2.使用场景：

读操作远远大于写操作，比如有些系统级别的信息，往往需要加载或者修改很少的次数，但是会被系统内的所有模块频繁的访问。

3.原理：

CopyOnWriteArrayList容器允许并发读，读操作时无锁的，性能高。写操作，比如向容器中添加一个元素，则首先将当前容器复制一份，然后在新的副本上执行写操作(此时仍然可以读取，读取的时旧的容器中的数据)，结束之后再将原容器的引用指向新容器。

特点：这种链表，读取完全不用加锁，写入也不会阻塞读取，只有写入和写入之间需要进行同步等待。

缺点：1）占用内存，每次执行写操作都要将原容器拷贝一份，数据量大时，对内存压力较大，可能会引起频繁GC

       2）无法保证实时性，Vector对于读写操作都同步，保证了读和写的一致性，但是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();
        }
    }

关于Collections.synchronizedList(List list)

CopyOnWriteArrayList和Collections.synchronizedList是实现线程安全的列表的两种方式。两种实现方式分别针对不同情况有不同的性能表现，其中CopyOnWriteArrayList的写操作性能较差，而多线程的读操作性能较好。而Collections.synchronizedList的写操作性能比CopyOnWriteArrayList在多线程操作的情况下要好很多，而读操作因为是采用了synchronized关键字的方式，其读操作性能并不如CopyOnWriteArrayList。因此在不同的应用场景下，应该选择不同的多线程安全实现类。

public boolean equals(Object o) {
            if (this == o)
                return true;
            synchronized (mutex) {return list.equals(o);}
        }
        public int hashCode() {
            synchronized (mutex) {return list.hashCode();}
        }

        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);}
        }

        public int indexOf(Object o) {
            synchronized (mutex) {return list.indexOf(o);}
        }
        public int lastIndexOf(Object o) {
            synchronized (mutex) {return list.lastIndexOf(o);}
        }

        public boolean addAll(int index, Collection<? extends E> c) {
            synchronized (mutex) {return list.addAll(index, c);}
        }

        public ListIterator<E> listIterator() {
            return list.listIterator(); // Must be manually synched by user
        }

        public ListIterator<E> listIterator(int index) {
            return list.listIterator(index); // Must be manually synched by user
        }