Collections 的 synchronized XXX方法
摘要
static <T> Collection<T>
synchronizedCollection(Collection<T> c)
返回指定 collection 支持的同步（线程安全的）collection。
static <T> List<T>
synchronizedList(List<T> list)
返回指定列表支持的同步（线程安全的）列表。
static <K,V> Map<K,V>
synchronizedMap(Map<K,V> m)
返回由指定映射支持的同步（线程安全的）映射。
static <T> Set<T>
synchronizedSet(Set<T> s)
返回指定 set 支持的同步（线程安全的）set。
static <K,V> SortedMap<K,V>
synchronizedSortedMap(SortedMap<K,V> m)
返回指定有序映射支持的同步（线程安全的）有序映射。
static <T> SortedSet<T>
synchronizedSortedSet(SortedSet<T> s)
返回指定有序 set 支持的同步（线程安全的）有序 set。
1 synchronizedCollection
public static <T> Collection<T> synchronizedCollection(Collection<T> c)返回指定 collection 支持的同步（线程安全的）collection。为了保证按顺序访问，必须通过返回的 collection 完成所有对底层实现 collection 的访问。
在返回的 collection 上进行迭代时，用户必须手工在返回的 collection 上进行同步：
Collection c = Collections.synchronizedCollection(myCollection); ... synchronized(c) { Iterator i = c.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }
不遵从此建议将导致无法确定的行为。
返回的 collection 不会 将 hashCode 和 equals 操作传递给底层实现 collection，但这依赖于 Object 的 equals 和 hashCode 方法。在底层实现 collection 是一个 set 或一个列表的情况下，有必要遵守这些操作的协定。
如果指定 collection 是可序列化的，则返回的 collection 也将是可序列化的。
参数：
c – 被“包装”在同步 collection 中的 collection。
返回：
指定 collection 的同步视图。
2 synchronizedList
public static <T> List<T> synchronizedList(List<T> list)返回指定列表支持的同步（线程安全的）列表。为了保证按顺序访问，必须通过返回的列表完成所有对底层实现列表的访问。
在返回的列表上进行迭代时，用户必须手工在返回的列表上进行同步：
List list = Collections.synchronizedList(new ArrayList()); ... synchronized(list) { Iterator i = list.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); }
不遵从此建议将导致无法确定的行为。
如果指定列表是可序列化的，则返回的列表也将是可序列化的。
参数：
list – 被“包装”在同步列表中的列表。
返回：
指定列表的同步视图。
3 synchronizedMap
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)返回由指定映射支持的同步（线程安全的）映射。为了保证按顺序访问，必须通过返回的映射完成所有对底层实现映射的访问。
在返回映射的任意 collection 视图上进行迭代时，用户必须手工在返回的映射上进行同步：
Map m = Collections.synchronizedMap(new HashMap()); ... Set s = m.keySet(); // Needn\'t be in synchronized block ... synchronized(m) { // Synchronizing on m, not s! Iterator i = s.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); }
不遵从此建议将导致无法确定的行为。
如果指定映射是可序列化的，则返回的映射也将是可序列化的。
参数：
m – 被“包装”在同步映射中的映射。
返回：
指定映射的同步视图。
4 synchronizedSet
public static <T> Set<T> synchronizedSet(Set<T> s)返回指定 set 支持的同步（线程安全的）set。为了保证按顺序访问，必须通过返回的 set 完成对所有底层实现 set 的访问。
在返回的 set 上进行迭代时，用户必须手工在返回的 set 上进行同步：
Set s = Collections.synchronizedSet(new HashSet()); ... synchronized(s) { Iterator i = s.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }
不遵从此建议将导致无法确定的行为。
如果指定 set 是可序列化的，则返回的 set 也将是可序列化的。
参数：
s – 被“包装”在同步 set 中的 set。
返回：
指定 set 的同步视图。
5 synchronizedSortedMap
public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)返回指定有序映射支持的同步（线程安全的）有序映射。为了保证按顺序访问，必须通过返回的有序映射（或其视图）完成对所有底层有序映射的访问。
当在返回的有序映射的 collection 视图或者其任何 subMap、headMap 或 tailMap 视图进行迭代时，用户必须手工在该映射上进行同步：
SortedMap m = Collections.synchronizedSortedMap(new TreeMap()); ... Set s = m.keySet(); // Needn\'t be in synchronized block ... synchronized(m) { // Synchronizing on m, not s! Iterator i = s.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); }
或者：
SortedMap m = Collections.synchronizedSortedMap(new TreeMap()); SortedMap m2 = m.subMap(foo, bar); ... Set s2 = m2.keySet(); // Needn\'t be in synchronized block ... synchronized(m) { // Synchronizing on m, not m2 or s2! Iterator i = s.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); }
不遵从此建议将导致无法确定的行为。
如果指定的有序映射是可序列化的，则返回的有序映射也将是可序列化的。
参数：
m – 被“包装”在同步有序映射中的有序映射。
返回：
指定有序映射的同步视图。
6 synchronizedSortedSet
public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)返回指定有序 set 支持的同步（线程安全的）有序 set。为了保证按顺序访问，必须通过返回的有序 set（或其视图）完成对所有底层实现有序 set 的访问。
在返回的有序 set 上或者其任意 subSet、headSet 或 tailSet 视图上进行迭代时，用户必须手工在返回的有序 set 上进行同步。
SortedSet s = Collections.synchronizedSortedSet(new TreeSet()); ... synchronized(s) { Iterator i = s.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }
或者：
SortedSet s = Collections.synchronizedSortedSet(new TreeSet()); SortedSet s2 = s.headSet(foo); ... synchronized(s) { // Note: s, not s2!!! Iterator i = s2.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }
不遵从此建议将导致无法确定的行为。
如果指定的有序 set 是可序列化的，则返回的有序 set 也将是可序列化的。
参数：
s – 被“包装”在同步有序 set 中的有序 set。
返回：
指定有序 set 的同步视图。