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

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

1、Mapmap=Collections.synchronizedMap(newHashMap());

点击(此处)折叠或打开

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

private static class SynchronizedMapimplements Map,

Serializable {

// use serialVersionUID from JDK 1.2.2 for interoperability

private static final long serialVersionUID = 1978198479659022715L;

private Mapm; // Backing Map

Object mutex; // Object on which to synchronize

SynchronizedMap(Mapm) {

if (m == null)

throw new NullPointerException();

this.m = m;

mutex = this;

}

SynchronizedMap(Mapm, 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 extends K, ? extends V> map) {

synchronized (mutex) {

m.putAll(map);

}

}

public void clear() {

synchronized (mutex) {

m.clear();

}

}

private transient SetkeySet = null;

private transient Set> entrySet = null;

private transient Collectionvalues = null;

public SetkeySet() {

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 Collectionvalues() {

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链中的一个节点，其结构如下所示：

Java代码 static final class HashEntry{

final K key;

final int hash;

volatile V value;

final HashEntrynext;

}

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

refference:http://www.iteye.com/topic/344876