集合-Collection.SynchronizeMap方法-源码解读

1、从HashMap出发

• HashMap 本身非线程安全的，但是当使用 Collections.synchronizedMap(new HashMap()) 进行包装后就返回一个线程安全的Map。

2、源码分析

  public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
  	  //返回一个SynchronizedMap对象
      return new SynchronizedMap<K,V>(m);
  }

  private static class SynchronizedMap<K,V> implements Map<K,V>, Serializable {
      // 使用JDK 1.2.2中的serialVersionUID进行互操作
      private static final long serialVersionUID = 1978198479659022715L;
  
      private final Map<K,V> m;     // 要返回的Map
          final Object      mutex;    // 要同步的对象
  
      SynchronizedMap(Map<K,V> m) {//构造函数1
              if (m==null)
                  throw new NullPointerException();
              this.m = m;
              mutex = this;
          }
  
      SynchronizedMap(Map<K,V> m, Object mutex) {//构造函数2
              this.m = m;
              this.mutex = mutex;
          }
  
      public int size() {
          synchronized(mutex) {return m.size();}
          }
      public boolean isEmpty(){
          synchronized(mutex) {return m.isEmpty();}
          }
      public boolean containsKey(Object key) {
          synchronized(mutex) {return m.containsKey(key);}
          }
      public boolean containsValue(Object value){
          synchronized(mutex) {return m.containsValue(value);}
          }
      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);}
          }
      public V remove(Object key) {
          synchronized(mutex) {return m.remove(key);}
          }
      public void putAll(Map<? extends K, ? extends V> map) {
          synchronized(mutex) {m.putAll(map);}
          }
      public void clear() {
          synchronized(mutex) {m.clear();}
      }
  
      private transient Set<K> keySet = null;
      private transient Set<Map.Entry<K,V>> entrySet = null;
      private transient Collection<V> values = null;
  
      public Set<K> keySet() {
              synchronized(mutex) {
                  if (keySet==null)
                      keySet = new SynchronizedSet<K>(m.keySet(), mutex);
                  return keySet;
              }
      }
  
      public Set<Map.Entry<K,V>> entrySet() {
              synchronized(mutex) {
                  if (entrySet==null)
                      entrySet = new SynchronizedSet<Map.Entry<K,V>>(m.entrySet(), mutex);
                  return entrySet;
              }
      }
  
      public Collection<V> values() {
              synchronized(mutex) {
                  if (values==null)
                      values = new SynchronizedCollection<V>(m.values(), mutex);
                  return values;
              }
          }
  
      public boolean equals(Object o) {
              if (this == o)
                  return true;
              synchronized(mutex) {return m.equals(o);}
          }
      public int hashCode() {
              synchronized(mutex) {return m.hashCode();}
          }
      public String toString() {
          synchronized(mutex) {return m.toString();}
          }
          private void writeObject(ObjectOutputStream s) throws IOException {
          synchronized(mutex) {s.defaultWriteObject();}
          }
      }

可以看到将每个方法都用synchronized关键字修饰后再返回，实现线程安全。