Java之通过Collections.synchronizedMap创建线程安全的HashMap

1 问题

我们知道hashMap线程是不安全的，一般而言，我们怎么创建线程安全的HashMap呢？

2 解决办法

我们可以使用Collections.synchronizedMap来创建HashMap,如下

static Map<String, String> results = Collections.synchronizedMap(new HashMap<String, String>());
 

3 Collections.synchronizedMap源码部分实现

我们先看synchronizedMap如果创建

  

   

    

     

    
    

     

      public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
     
    
   

    

     

    
    

     
 return new SynchronizedMap<K,V>(m);
     
    
   

    

     

    
    

     

      }
     
    
  
 

我们看下具体的SynchronizedMap类的部分

  

   

    

     

    
    

     

      private static class SynchronizedMap<K,V>
     
    
   

    

     

    
    

     
 implements Map<K,V>, Serializable {
     
    
   

    

     

    
    

     
 // use serialVersionUID from JDK 1.2.2 for interoperability
     
    
   

    

     

    
    

     
 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;
     
    
   

    

     

    
    

     

       mutex = this;
     
    
   

    

     

    
    

     

       }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

       SynchronizedMap(Map<K,V> m, Object mutex) {
     
    
   

    

     

    
    

     
 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();}
     
    
   

    

     

    
    

     

       }
     
    
   

    

     

    
    

     

       }
     
    
  
 

SynchronizedMap 实现了Map接口的代理类，该类中对Map接口中的方法还是使用synchronized 同步关键字来保证对Map的操作是线程安全的。

synchronized(mutex) {/*****/}
 

文章来源: chenyu.blog.csdn.net，作者：chen.yu，版权归原作者所有，如需转载，请联系作者。

原文链接：chenyu.blog.csdn.net/article/details/103640286