Collections.synchronizedList---JDK1.8源码分析

一. Collections.synchronizedList介绍

• SynchronizedList是一个基于同步锁实现的List，是Collections工具类里面的一个静态类，与ArrayList相比，它是线程安全的，与Vector相比他性能又要好一些，因为Vector实现同步锁是基于方法级别，而SynchronizedList实现同步锁是在代码级别范围更小，性能更高效。

使用方式

 List list = Collections.synchronizedList(new ArrayList());

二. Collections.synchronizedList构造函数和属性

   //synchronizedList是java.util.Collections中的一个静态内部类
    static class SynchronizedList<E> extends SynchronizedCollection<E> implements List<E> {

        private static final long serialVersionUID = -7754090372962971524L;

        //final属性的list
        final List<E> list;

        SynchronizedList(List<E> list) {
            // 调用父类SynchronizedCollection的构造方法
            super(list);
            this.list = list;
        }
        SynchronizedList(List<E> list, Object mutex) {
            super(list, mutex);
            this.list = list;
        }

走父类SynchronizedCollection进行构造方法操作

    static class SynchronizedCollection<E> implements Collection<E>, Serializable {
        private static final long serialVersionUID = 3053995032091335093L;

        final Collection<E> c;  // Backing Collection
        final Object mutex;    // Synchronized本地的对象作为同步锁。

        SynchronizedCollection(Collection<E> c) {
            //判断非空进行复制
            this.c = Objects.requireNonNull(c);
            //当前对象this作为互斥锁
            mutex = this;
        }

        SynchronizedCollection(Collection<E> c, Object mutex) {
            this.c = Objects.requireNonNull(c);
            this.mutex = Objects.requireNonNull(mutex);
        }

三. Collections.synchronizedList关键方法_同步

        // 注意：synchronizedList是用同步代码块给传入的集合对象加锁！
        // 可以看到所有的操作都是上了锁的，synchronized (mutex),锁对象是mutex是来自SynchronizedCollection父类
        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);}
        }

四. Collections.synchronizedList_未同步方法

        // 但是有一个地方很值得注意的是迭代器的使用是没有上锁的，而且源码是标注了
        // 需要用户去自己做同步处理， 迭代器，分割，流操作都需要自己实现同步处理。
        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
        }

• 转换包装后的list可以实现add，remove，get等操作的线程安全性，但是对于迭代操作，Collections.synchronizedList并没有提供相关机制，所以迭代时需要对包装后的list（必须对包装后的list进行加锁，锁其他的不行）进行手动加锁。

List list = Collections.synchronizedList(new ArrayList());
//必须对list进行加锁
synchronized (list) {
  Iterator i = list.iterator();
  while (i.hasNext())
      foo(i.next());
}

1. 迭代操作必须加锁，可以使用synchronized关键字修饰;
2. synchronized持有的监视器对象必须是synchronized (list),即包装后的list,使用其他对象如synchronized (new Object())会使add,remove等方法与迭代方法使用的锁不一致，无法实现完全的线程安全性。

五. SynchronizedList、Vector概述

①. 构造机制不同

• SynchronizedList：可将所有的List的子类转成线程安全的类，例如可以把ArrayList和LinkedList直接转换成SynchronizedList，而无需改变底层数据结构

• Vector：底层结构固定，无法转换

②. 扩容机制不同

• SynchronizedList：如果用ArrayList构建SynchronizedList的话，那么SynchronizedList为1.5倍扩容

• Vector：Vector缺省情况下2倍扩容

③. 同步机制不同

• SynchronizedList：使用同步代码块实现同步，锁定的对象为mutex（构造函数可以传入一个Object，如果在调用的时候显示的传入一个对象，那么锁定的就是用户传入的对象，反之锁定this对象）

• Vector：使用同步方法实现同步，锁定this对象