线程安全的Map在JDK 1.5及其更高版本环境 有哪几种方法可以实现?

线程安全的Map在JDK 1.5及其更高版本环境 有哪几种方法可以实现? 

1、Map map = Collections.synchronizedMap(new HashMap()); 

Map map = Collections.synchronizedMap(new HashMap());private static class SynchronizedMap implements Map,
Serializable {
// use serialVersionUID from JDK 1.2.2 for interoperability
private static final long serialVersionUID = 1978198479659022715L;

private Map m; // Backing Map
Object mutex; // Object on which to synchronize
SynchronizedMap(Map m) {
if (m == null)
throw new NullPointerException();
this.m = m;
mutex = this;
}

SynchronizedMap(Map 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 map) {
synchronized (mutex) {
m.putAll(map);
}
}

public void clear() {
synchronized (mutex) {
m.clear();
}
}

private transient Set keySet = null;
private transient Set> entrySet = null;
private transient Collection values = null;

public Set keySet() {
synchronized (mutex) {
if (keySet == null)
keySet = new SynchronizedSet(m.keySet(), mutex);
return keySet;
}
}

public Set> entrySet() {
synchronized (mutex) {
if (entrySet == null)
entrySet = new SynchronizedSet>(
(Set>) m.entrySet(), mutex);
return entrySet;
}
}

public Collection values() {
synchronized (mutex) {
if (values == null)
values = new SynchronizedCollection(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();
}
}
}

2、Map map2= new ConcurrentHashMap();
ConcurrentHashMap是Java 5中支持高并发、高吞吐量的线程安全HashMap实现， concurrenthashmap是一个非常好的map实现，在高并发操作的场景下会有非常好的效率。实现的目的主要是为了避免同步操作时对整个map对象进行锁定从而提高并发访问能力 

实现原理 

锁分离 (Lock Stripping)

ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术。它使用了多个锁来控制对hash表的不同部分进行的修改。ConcurrentHashMap内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个小的hash table，它们有自己的锁。只要多个修改操作发生在不同的段上，它们就可以并发进行。

有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁。这里“按顺序”是很重要的，否则极有可能出现死锁，在ConcurrentHashMap内部，段数组是final的，并且其成员变量实际上也是final的，但是，仅仅是将数组声明为final的并不保证数组成员也是final的，这需要实现上的保证。这可以确保不会出现死锁，因为获得锁的顺序是固定的。

不变(Immutable)和易变(Volatile)

ConcurrentHashMap完全允许多个读操作并发进行，读操作并不需要加锁。如果使用传统的技术，如HashMap中的实现，如果允许可以在hash链的中间添加或删除元素，读操作不加锁将得到不一致的数据。ConcurrentHashMap实现技术是保证HashEntry几乎是不可变的。HashEntry代表每个hash链中的一个节点，其结构如下所示：

static final class HashEntry {
    final K key;
    final int hash;
    volatile V value;
    final HashEntry next;
}

可以看到除了value不是final的，其它值都是final的，这意味着不能从hash链的中间或尾部添加或删除节点，因为这需要修改next引用值，所有的节点的修改只能从头部开始。对于put操作，可以一律添加到Hash链的头部。但是对于remove操作，可能需要从中间删除一个节点，这就需要将要删除节点的前面所有节点整个复制一遍，最后一个节点指向要删除结点的下一个结点。这在讲解删除操作时还会详述。为了确保读操作能够看到最新的值，将value设置成volatile，这避免了加锁。

refference: