Java Collections.synchronizedMap方法分析

Collections.synchronizedMap如何创建线程安全的map。

static Map<Long, User> users = Collections.synchronizedMap(new HashMap<Long, User>());

创建了一个synchronizedMap，于是就翻了一下源码，看了一下具体的实现，发现底层其实是通过synchronized锁机制实现的，在此记录一下，当作学习心得。按住ctrl点击进去发现创建了一个synchronizedMap 的实例：

---

synchronizedMap()返回由指定映射支持的同步（线程安全的）映射。实际上该方法只是一个工具方法, 将传入Map的实现方法加一个同步(synchronized)锁代理,内部还是调用实现的对应方法.

Collections.synchronizedMap源码如下：

  //Collections.synchronizedMap(Map<K, V>) 
  public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
        return new SynchronizedMap<K,V>(m);
  }

  /**
   * 可以看到实际上是在Collections类中维护了一个静态内部类SynchronizedMap， 
   * 该内部类中维护了一个普通的map和一个对象排斥锁mutex
   */  
  //SynchronizedMap<K,V>
  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) {
            if (m==null)
                throw new NullPointerException();
            this.m = m;
            //把this本身作为锁监视器, 这样任何线程访问他的方法都要获取该监视器.
            mutex = this;
        }


        SynchronizedMap(Map<K,V> m, Object mutex) {
            this.m = m;
            this.mutex = mutex;
        }

        public int size() {
            synchronized(mutex) {return m.size();}
        }
        //重写map的emty方法
        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;

        //重写keySet方法
        public Set<K> keySet() {
            synchronized(mutex) {
                if (keySet==null)
                    //mutex传给SynchronizedSet, 这样对于set内部操作也需要获取锁.
                    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) {
            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();}
        }
    }