ArrayList，CopyOnWriteArrayList，concurrenthashmap，hashtable，hashMap

1、ArrayList和CopyOnWriteArrayList；hashMap和concurrenthashmap

ArrayList和hashMap都是集合中的一些重要类。我们知道在list里面arrayList是线程不安全的， vector是线程安全的，map里面hashMap也是线程不安全的，hashTable是线程安全的。当然了在效率方面，arrayList和hashMap要高点。那map里面我想用线程安全的map怎么办呢？目前有如下三种方法：

a：使用hashTable     b：使用Synchronized map      c: 使用concurrentHashMap

生成方式如下：

//Hashtable
Map<String, String> hashtable = new Hashtable<>();

//synchronizedMap
Map<String, String> synchronizedHashMap = Collections.synchronizedMap(new HashMap<String, String>());

//ConcurrentHashMap
Map<String, String> concurrentHashMap = new ConcurrentHashMap<>();

hashTable是锁住了整张表，而SynchronizedMap相当于是同步的hashMap，对每一个方法加锁。SynchronizedMap其实是一个工具类，

//synchronizedMap
Map<String, String> synchronizedHashMap = Collections.synchronizedMap(new HashMap<String, String>());



首先讲一下Synchronized map，使用Synchronized map并不完全线程安全，

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

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


但synchronizedMap有一个问题，比方


Java代码
// shm是SynchronizedMap的一个实例   
if(shm.containsKey('key')){   
        shm.remove(key);   
}  
 这段代码用于从map中删除一个元素之前判断是否存在这个元素。这里的containsKey和reomve方法都是同步的，但是整段代码却不是。考虑这么一个使用场景：线程A执行了containsKey方法返回true，准备执行remove操作；这时另一个线程B开始执行，同样执行了containsKey方法返回true，并接着执行了remove操作；然后线程A接着执行remove操作时发现此时已经没有这个元素了。要保证这段代码按我们的意愿工作，一个办法就是对这段代码进行同步控制，但是这么做付出的代价太大。

一开始我不太明白为什么，后面我知道了，如果你只是看源码的话就会知道，Collections.synchronizedMap(new HashMa<>);传进去是一个成员变量，synchronizedMap只是给传进去的hashMap实现一下线程安全，那为什么我上面的例子没有实现线程同步呢！，这个你要仔细看源码了，看源码我们可以看出，它只是对synchronizedMap本身加锁了，但当另一个线程执行Collections.synchronizedMap(new
 HashMa<>);的时候又有一个synchronizedMap对象产生，那对于上面的代码，2个对象的锁肯定不冲突，这也是synchronizedMap的缺点， 不能全部线程安全。如果大家还是不能明白为什么，可以多看几遍源码。
然后说到HashTable，它是线程安全的，但由于它很“霸道”，所以现在也基本上不用了。怎么个霸道法呢？它所有的方法都是 加锁，也就是对象锁，锁住的是整个对象，所有其霸道之处就在于，当线程a调用put方法时，线程b不但不能调用put方法，也不能调用其它方法，这种方式虽然能改变synchronizedMap的缺点，做到完全安全，但 效率太低，代价太大。如果你的hashTable容量小的话，还相对来说代价小点，毕竟数据少，代表操作也少了，等待的时间也少了。
至于concurrentHashMap就是一个比较完美的方案，现在基本上在高并发上会使用它。其原理我也不多讲了，有一篇文章讲的毕竟详细，哈哈，
http://blog.csdn.net/xuefeng0707/article/details/40834595
 



至于list，完全跟map是同一个历史，我就不再多说一遍了！！

 
有什么不对的地方，欢迎大家来讨教！！