HashMap中未进行同步考虑，而Hashtable在每个方法上加上了synchronized，锁住了整个Hash表，一个时刻只能有一个线程操作，其他的线程则只能等待，在并发的环境下，这样的操作导致Hashtable的效率低下。

　　Collections的静态方法synchronizedMap(HashMap hm)返回的是一个SynchronizedMap对象，SynchronizedMap也是对原HashMap中的方法加上synchronized，锁的粒度应该减小。

　　ConcurrentHashMap将原来的原来的Hash表分成了16个桶(默认值)，桶内的

读操作是不加锁的，桶内的写操作是加上了锁的。这样的实现允许更多的线程同时地操作Hash表，在并发的环境下，应该选择的是ConcurrentHashMap。

　　

　　ConcurrentHashMap的get读操作中基本没有用到锁，可以看下面的代码：

V get(Object key, int hash) {            if (count != 0) { // read-volatile                HashEntry
     
       e = getFirst(hash);                while (e != null) {                    if (e.hash == hash && key.equals(e.key)) {                        V v = e.value;                        if (v != null)                            return v;                        return readValueUnderLock(e); // recheck                    }                    e = e.next;                }            }            return null;        }
     

　　当读到的value是null时，处理是return readValueUnderLock(e);，因为整个的操作未加锁，上面的if (v != null)为false时，可能同时有其他线程修改了value的值，这里有进行一次同步的取值，如下：

V readValueUnderLock(HashEntry
     
       e) {            lock();            try {                return e.value;            } finally {                unlock();            }        }
     

　　size读操作为了确保读的数据是准确的也进行了部分的加锁操作。

　　写后读或者读后写都会造成数据的不一致，即使用线程安全类，应该做好对象的加锁。

 

　　ConcurrentHashMap的写操作锁住了Segment　

public V put(K key, V value) {        if (value == null)            throw new NullPointerException();        int hash = hash(key.hashCode());        return segmentFor(hash).put(key, hash, value, false);    }

　　下面是针对Segment的写操作：

V put(K key, int hash, V value, boolean onlyIfAbsent) {            lock();            try {                int c = count;                if (c++ > threshold) // ensure capacity                    rehash();                HashEntry
     
      [] tab = table;                int index = hash & (tab.length - 1);                HashEntry
      
        first = tab[index];                HashEntry
       
         e = first;                while (e != null && (e.hash != hash || !key.equals(e.key)))                    e = e.next;                V oldValue;                if (e != null) {                    oldValue = e.value;                    if (!onlyIfAbsent)                        e.value = value;                }                else {                    oldValue = null;                    ++modCount;                    tab[index] = new HashEntry
        
         (key, hash, first, value);                    count = c; // write-volatile                }                return oldValue;            } finally {                unlock();            }        }
        
       
      
     

 

　　CopyOnWriteArrayList应用于读多写少的场景，对读操作不加锁，对写操作，先复制一份新的集合，在新的集合上面修改，然后将新集合赋值给旧的引用，并通过volatile 保证其可见性，当然写操作的锁是必不可少的了。

　　CopyOnWriteArrayList应用于读多写少的场景，在有较多写操作的情况下，CopyOnWriteArrayList性能不佳，而且如果容器容量较大的话容易造成溢出，应该使用Vector。使用ReadWriteLock是另外一种思路。

 

　　下面是的CopyOnWriteArrayList的set操作：

public E set(int index, E element) {        final ReentrantLock lock = this.lock;        lock.lock();        try {            Object[] elements = getArray();            E oldValue = get(elements, index);            if (oldValue != element) {                int len = elements.length;                Object[] newElements = Arrays.copyOf(elements, len);                newElements[index] = element;                setArray(newElements);            } else {                // Not quite a no-op; ensures volatile write semantics                setArray(elements);            }            return oldValue;        } finally {            lock.unlock();        }    }

　　 Arrays.copyOf创建一个新的数组，在新数组上做了修改后将新数组的引用赋给原对象。

private transient volatile Object[] array; final void setArray(Object[] a) {        array = a;    }

　　set方法中的

　else {                // Not quite a no-op; ensures volatile write semantics                setArray(elements);            }

　　元素都没有发生变化，为什么还要重新做一次赋值操作呢。

　　为了保持“volatile”的语义，任何一个读操作都应该是一个写操作的结果，也就是说线程的读操作看到的数据一定是某个线程写操作的结果。这里即使不设置也没有问题，仅仅是为了一个语义上的补充。

 

　　LinkedHashMap实现与HashMap的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。

  

　　注意，此实现不是同步的。如果多个线程同时访问链接的哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。

　　LinkedHashMap中的Entry是这样的，维护了before Entry和after Entry。

static class Entry
     
       extends HashMap.Node
      
        {        Entry
       
         before, after;        Entry(int hash, K key, V value, Node
        
          next) {            super(hash, key, value, next);        }    }