Java中Map实现线程安全的3种方式

Java中Map实现线程安全的3种方式

目录方式1. 使用Hashtable方式2. 使用Collections.synchronizedMap(newHashtable())方式3. 使用ConcurrentHashMap

方式1.  使用Hashtable

Map hashtable=new Hashtable();

这是所有人最先想到的，那为什么它是线程安全的？那就看看它的源码,我们可以看出我们常用的put,get，containsKey等方法都是同步的，所以它是线程安全的

public synchronized boolean containsKey(Object key) {

Entry,?> tab[] = table;

int hash = key.hashCode();

int index = (hash & 0x7FFFFFFF) % tab.length;

for (Entry,?> e = tab[index] ; e != null ; e = e.next) {

if ((e.hash == hash) && e.key.equals(key)) {

return true;

}

}

return false;

}

public synchronized V get(Object key) {

Entry,?> tab[] = table;

int hash = key.hashCode();

int index = (hash & 0x7FFFFFFF) % tab.length;

for (Entry,?> e = tab[index] ; e != null ; e = e.next) {

if ((e.hash == hash) && e.key.equals(key)) {

return (V)e.value;

}

}

return null;

}

public synchronized V put(K key, V value) {

// Make sure the value is not null

if (value == null) {

throw new NullPointerException();

}

// Makes sure the key is not already in the hashtable.

Entry,?> tab[] = table;

int hash = key.hashCode();

int index = (hash & 0x7FFFFFFF) % tab.length;

@SuppressWarnings("unchecked")

Entry entry = (Entry)tab[index];

for(; entry != null ; entry = entry.next) {

if ((entry.hash == hash) && entry.key.equals(key)) {

V old = entry.value;

entry.value = value;

return old;

}

}

addEntry(hash, key, value, index);

return null;

}

其实现原理是在增删改查的方法上使用了synchronized锁机制，在多线程环境下，无论是读数据，还是修改数据，在同一时刻只能有一个线程在执行synchronize方法，因为是对整个表进行vWFOR锁定。所以线程越多，对该map的竞争越激烈，效率越低，不推荐使用。

方式2.  使用Collections.synchronizedMap(new Hashtable())

其实现原理是使用工具类里面的静态方法，把传入进来的Hashtable包装成同步的，即在增删改查的方法上增加了synchronized所机制，其实现方式与Hashtable差不多，效率也差不多，不推荐使用。

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

以下是JDK源码

public static Map synchronizedMap(Map m) {

return new SynchronizedMap<>(m);

}

private static class SynchronizedMap

implements Map, Serializable {

private static final long serialVersionUID = 1978198479659022715L;

private final Map m; // Backing Map

final Object mutex; // Object on which to synchronize

SynchronizedMap(Map m) {

this.m = Objects.requireNonNull(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() {

synchronizedvWFOR (mutex) {return m.isEmpty();}

}

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

}

......

}

方式3.  使用ConcurrentHashMap

其实现原理是Hashtable是对整个表进行加锁，而ConcurrentHashMap是把表进行分段，初始情况下分成16段，每一段都有一把锁，当多个线程访问不同的段时，因为获取到的锁是不同的，所以可以并行的访问。效率比Hashtable高多了，推荐使用。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。