先來看一下集合類：
表 1 . Java Collection Implementations
以上 10 個Java 集合的實現類搜不是同步的。（類/成員函數/代碼塊 沒有使用 synchronized 修飾）
可以通過 Collections.synchronizedXxx 來把他們變成同步的。比如：
Map m = Collections.synchronizedMap(new HashMap(...));
來看一下源碼：
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
return new SynchronizedMap<>(m);
}
private static class SynchronizedMap<K,V>
implements Map<K,V>, Serializable {
private static final long serialVersionUID = 1978198479659022715L;
private final Map<K,V> m; // Backing Map
final Object mutex; // Object on which to synchronize
SynchronizedMap(Map<K,V> m) {
this.m = Objects.requireNonNull(m);
mutex = this;
}
SynchronizedMap(Map<K,V> m, Object mutex) {
this.m = m;
this.mutex = mutex;
}
public boolean containsKey(Object key) {
synchronized (mutex) {return m.containsKey(key);}
}
public V get(Object key) {
synchronized (mutex) {return m.get(key);}
}
public V put(K key, V value) {
synchronized (mutex) {return m.put(key, value);}
}
...
}
原來實現很簡單：就是將每個成員函數重新包裝一下，定義一個鎖（mutext），每次操作都上鎖就行了。
表 1 中的集合類都不是同步的，但是下面這 3 個類是同步的： Vector， Stack，HashTable。看了一下他們的版本，明白了：這 3 個 類是 Java 1.0 中就有了，而表 1 中的類是從 Java 1.2 開始纔有的。
應該是這樣的：剛開始的時候，代碼的作者實現的一些類（Vector/Stack/HashTable）考慮到了多線程，就設計成了同步的。後來（Jdk 1.2）發現如果是單線程使用這些類，每個操作都上鎖，有點浪費，於是就出現了表 1 中的類，全部不上鎖，如果需要在多線程中使用，就讓使用者自己通過 Collections.synchronizedXxx 來將集合類變成同步版本。Collections 這個類也是在 Jdk 1.2 纔開始引入的 [5]。
Oracle 的文檔中也說道，這些是 Legacy implementations [1]
Legacy implementations. The collection classes from earlier releases, Vector and Hashtable, were retrofitted to implement the collection interfaces.
下一個專題，我們將會看到，從 Jdk 1.5 開始，引入了 juc (java.util.concurrent) 包，這個包裏面的集合類，專門用於處理多線程情況。
參考鏈接：
1. https://docs.oracle.com/javase/8/docs/technotes/guides/collections/overview.html
2. https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html
3. https://docs.oracle.com/javase/8/docs/api/java/util/Hashtable.html
4. https://docs.oracle.com/javase/8/docs/api/java/util/Stack.html
5. https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html