Collections.synchronizedMap 笔记

这个是学习LinkedHashMap 关联的关于线程安全的学习。 使用方法：

Map<String, Bitmap> maps = Collections.synchronizedMap(new LinkedHashMap<String, Bitmap>());

原理：

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

//通过静态类SynchronizedMap进行包装，内部维护了map和mutex排斥锁

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

潜在的线程安全问题

if(map.containsKey('key')){ 
    map.remove(key); 
}

虽然对于每个方法都包裹了synchronized,只能保证多个线程用同一个方法时候线程安全，如果不同方法，如上述代码. 线程A执行了containsKey方法返回 true，准备执行remove操作；这时另一个线程B开始执行，同样执行了containsKey方法返回true，并接着执行了remove操作；然 后线程A接着执行remove操作时发现此时已经没有这个元素了。就需要：

synchronized(map) {
    if(map.containsKey(key)) {
        map.remove(key); 
    }
}

所以引出ConcurrentHashMap