疑问：同样都是加了锁的集合，为什么synchronizedList比Vector快呢？

---

探究ArrayList为什么查询快、增删慢，实现add方法底层原理详解
ArrayList源码分析（基于JDK8）

---

因为Vector和ArrayList除了在主要的方法上加锁外而使Vector买进了线程安全的行列外，底层实现大约是没有什么区别的！

Vector是java.util包下的一个集合。而synchronizedList是java.util.Collections中的一个静态内部类。首先先看一下怎么使用！

	//synchronizedListList<Object> list = new ArrayList<Object>();List<Object> safeList Collections.synchronizedList(list);//VectorList<Object> vector = new Vector<Object>();

那它们两个都是线程安全的集合为什么synchronizedList比Vector快呢？两个有什么区别呢？让我们带着小问号去追一下源码！

这里我们就举一个例子，拿集合当中常用的add方法说事。

Vector add的实现方法

//注意：Vector是在方法上加的锁！
public synchronized boolean add(E e) {modCount++;ensureCapacityHelper(elementCount + 1);elementData[elementCount++] = e;return true;
}private void ensureCapacityHelper(int minCapacity) {// overflow-conscious codeif (minCapacity - elementData.length > 0)grow(minCapacity);
}private void grow(int minCapacity) {// overflow-conscious codeint oldCapacity = elementData.length;int newCapacity = oldCapacity + ((capacityIncrement > 0) ?capacityIncrement : oldCapacity);if (newCapacity - minCapacity < 0)newCapacity = minCapacity;if (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);elementData = Arrays.copyOf(elementData, newCapacity);
}

synchronizedList add的实现方法

//注意：synchronizedList是用同步代码块给传入的集合对象加锁！
public boolean add(E e) {synchronized (mutex) {return c.add(e);}
}

---

从我在源码中标记“注意”总结：Vector使用同步方法实现，synchronizedList使用同步代码块实现！

首先、详解剖析synchronizedList。Collections句点synchronizedList之后可以放入一个集合这是它的用法！而我们点入synchronizedList时，进入的是Collections类，出现的源码是以下这样的！

public static <T> List<T> synchronizedList(List<T> list) {return (list instanceof RandomAccess ?new SynchronizedRandomAccessList<>(list) :new SynchronizedList<>(list));
}

当你传入一个集合对象时，先进行三元表达式判断是否是一个支持随机访问的类型。无论是与否（不关注），都会给你new（创建）一个对象，把你传入的集合作参数放在这个对象构造方法中！
而这时我们点进入一个SynchronizedList继续追！

SynchronizedList(List<E> list) {super(list);this.list = list;
}
SynchronizedList(List<E> list, Object mutex) {super(list, mutex);this.list = list;
}

看见的即是SynchronizedList静态内部类的两个构造方法。而传入的参数即是我们要传入的普通集合！第二个构造方法传入的是一个集合还有一个mutex。而在源码中可以看出 ，把你传入的list参数给了父类，即super(list)。又把参数赋给了自己！即是每个构造方法里都有this.list = list; 。
而类中的list是最终的所有类型的List集合，即：final List< E > list;
然后再去看看它的父类对他做了什么！

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

它在类中定义了一个父接口（Collection< E >）的final集合，即：final Collection c;（给集合包装起来）。而第二个构造方法中也是这样操作的，但都多出了一个Object类型的mutex参数，即：final Object mutex; （要在其上同步的对象）；
具体操作呢？就是首先this.c = Objects.requireNonNull©;判断父接口集合接收的你的参数是不是null（空对象）

public static <T> T requireNonNull(T obj) {if (obj == null)throw new NullPointerException();return obj;
}

是空的话抛出空指针异常，不是空的话this.c = Objects.requireNonNull©;将传入的集合参数c赋给父接口定义的集合this.c ，然后继续往下走走就到了这里，即：mutex = this;。mutex就是定义的Object类型对象，而this赋给了mutex。那么this是什么呢？this就是内部类SynchronizedCollection< E >对象实例。这番操作就是将自身的内部类对象实例赋给了mutex。而mutex在add方法中发挥了很大的作用！充当了一个重要的角色！向下看~

public boolean add(E e) {synchronized (mutex) {return c.add(e);}
}

在这段源码中给mutex对象加了锁，从而把让它也迈进了线程安全的行列！
而我们在使用的时候是这样的：

List<Object> list = new ArrayList<Object>();
List<Object> safeList Collections.synchronizedList(list);

用一个名为safeList的List集合去接收这个线程安全的集合对象，从而可以使用safeList add方法功能！
而你使用safeList去调用add方法的时，传入你原来的list集合参数，你真正使用的safeList实际上是这个工具synchronizedList给你提供的一个地址，然后你的所有的操作（包括add）都必须经过静态内部类SynchronizedCollection< E >以上的一番加工包装操作，其实而这个内部类的属性mutex才是你开始传入的参数集合。

因为ArrayList集合是线程不安全的集合，你经过这一系列的包装，而你使用包装后的safeList去调用add方法操作时，你把要添加的这个参数（比如：你要添加一个Integer类型的数字）传给了内部类对象，而这个内部类对象去调用ArrayList集合的add方法！举个栗子！

List<Object> list = new ArrayList<Object>();		//比如：ArrayList集合对象地址为0x112233
List<Object> safeList Collections.synchronizedList(list);		//比如：包装后的safeList集合对象地址为0x445566

我们创建的ArrayList（0x112233）集合对象交给了Collections.synchronizedList加工包装，而我们在调用add方法时，是用加工后的SynchronizedCollection类型的safeList（0x445566）去调用的。传入的Integer类型数字，你原ArrayList集合通过包装后final Collection c; 类型c调用的add方法。最后，看下面一条代码！

synchronized (mutex) {return c.add(e);}

当调用add方法的时候，你必须拿到mutex（传入内部类的对象地址）的锁才能进行add操作！

这样以来摇身一变，不影响ArrayList内部方法操作，而且还变成了一个线程安全的集合，所以它的效率才比Vector要快的！

---

同步代码块和同步方法的区别：

因为SynchronizedList只是使用同步代码块包裹了ArrayList的方法，而ArrayList和Vector中同名方法的方法体内容并无太大差异，所以在锁定范围和锁的作用域上两者并无却别。 在锁定的对象区别上，SynchronizedList的同步代码块锁定的是mutex对象，Vector锁定的是this对象
而其实mutex对象就是SynchronizedList有一个构造函数可以传入一个Object类型对象，如果在调用的时候显示的传入一个对象，那么锁定的就是用户传入的对象。如果没有指定，那么锁定的也是this对象。结果就是SynchronizedList可以指定锁定的对象

基于我们将ArrayList转成SynchronizedList。那么如果我们想把LinkedList变成线程安全的，或者说我想要方便在中间插入和删除的同步的链表，那么我可以将已有的LinkedList直接转成SynchronizedList，而不用改变他的底层数据结构。而这一点是Vector无法做到的，因为他的底层结构就是使用数组实现的，这个是无法更改的

---

SynchronizedList和Vector区别：

• SynchronizedList有很好的扩展和兼容功能。他可以将所有的List的子类转成线程安全的类。
  使用SynchronizedList的时候，进行遍历时要手动进行同步处理
• SynchronizedList可以指定锁定的对象

---