将琴存诗
人生 可以不要那么 耀 ,只需要有 一个  平凡的梦想  足以 。—— H.yf. -_^ RSS
Fork me on GitHub

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

posted @ 2017-07-26 19:59 loveincode 阅读(...) 评论(...) 编辑 收藏
最简单即最美
有了信仰,自己要坚持努力 2017.07.09 21:34