摘要

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 的同步视图。