Collections中的 SynchronizedList 源码阅读

SynchronizedList

SynchronizedList是一个基于同步锁实现的List，是Collections工具类里面的一个静态类，与ArrayList相比，它是线程安全的，与Vector相比他性能又要好一些，因为Vector实现同步锁是基于方法级别，而SynchronizedList实现同步锁是在代码级别范围更小，性能更高效。(与其他使用轻量级锁的并发容器相比效率还是比较低，虽然jdk1.8又所优化)

    /**
     * 该类继承了SynchronizedCollection同步锁类，在这个类里面可以看到使用mutex来实现同步锁的当这个锁对象是this,也就是这个Synchronized本地的对象作为同步锁。
     */
    static class SynchronizedList<E>
        extends SynchronizedCollection<E>
        implements List<E> {
        private static final long serialVersionUID = -7754090372962971524L;

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

        public List<E> subList(int fromIndex, int toIndex) {
            synchronized (mutex) {
                return new SynchronizedList<>(list.subList(fromIndex, toIndex),
                                            mutex);
            }
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            synchronized (mutex) {list.replaceAll(operator);}
        }
        @Override
        public void sort(Comparator<? super E> c) {
            synchronized (mutex) {list.sort(c);}
        }
        private Object readResolve() {
            return (list instanceof RandomAccess
                    ? new SynchronizedRandomAccessList<>(list)
                    : this);
        }
    }

总结：在代码中可以看到添加、删除、修改、查询等操作都在代码级别通过synchronized实现了同步锁来保证这些操作是线程安全的，但是在迭代器操作是没有添加同步锁的因此使用迭代器进行操作使会出现线程不安全的情况，同时我们也可以手动添加同步锁来实现迭代的时候线程安全
HashTable源码分析
LinkedList源码分析
Vector源码分析
CopyOnWriteArrayList源码分析
SynchorincedList源码分析