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

生成方式如下：

//HashtableMap<String, String> hashtable = new Hashtable<>();//synchronizedMapMap<String, String> synchronizedHashMap = Collections.synchronizedMap(new HashMap<String, String>());//ConcurrentHashMapMap<String, String> concurrentHashMap = new ConcurrentHashMap<>();

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

//synchronizedMapMap<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是同一个历史，我就不再多说一遍了！！

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