欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

并发编程陷阱系列(六)高并发环境下使用性能较低的Map

程序员文章站 2022-04-05 22:20:24
...

hashtable是线程安全的,但为了保障线程安全,get, put, contains等多个方法都被添加了synchronized,源码片段如下:

   public synchronized V get(Object key) {
	Entry tab[] = table;
	int hash = key.hashCode();
	int index = (hash & 0x7FFFFFFF) % tab.length;
	for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
	    if ((e.hash == hash) && e.key.equals(key)) {
		return 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;
	for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
	    if ((e.hash == hash) && e.key.equals(key)) {
		V old = e.value;
		e.value = value;
		return old;
	    }
	}

	modCount++;
	if (count >= threshold) {
	    // Rehash the table if the threshold is exceeded
	    rehash();

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

	// Creates the new entry.
	Entry<K,V> e = tab[index];
	tab[index] = new Entry<K,V>(hash, key, value, e);
	count++;
	return null;
    }

 同理,SynchronizedMap也是通过synchronized实现线程安全,代码片段如下:

private static class SynchronizedMap<K,V>
	implements Map<K,V>, Serializable {
	// use serialVersionUID from JDK 1.2.2 for interoperability
	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;
            mutex = this;
        }

	SynchronizedMap(Map<K,V> 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);}
        }
        ...
}

 

首先分析hashmap的数据结构,hashmap实际上就是一个Entry对象的数组

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        final int hash;
... 
}

 数据结构如下:

并发编程陷阱系列(六)高并发环境下使用性能较低的Map
            
    
    博客分类: 多线程  

 以上两种方式,相当于在整个map范围加了锁,这个锁保证了insert、delete或者get的完整性,这样一个锁不会出现多线程同时访问到的情况。

但是,只要这个锁被占有,就从根本上阻止了其他线程访问 Map,即使处理器有空闲也不能访问,这样大大地限制了并发性。

 

大神Brian Goetz给我们提供了解决此类问题的神器---ConcurrentHashMap,相比于上面的同步类,它具有

多个写入锁,hashtable和SynchronizedMap锁定了整个map(map-wide lock),而ConcurrentHashMap使用多个锁锁定hash桶中的元素,32 个独立的锁意味着最多可以有 32 个线程可以同时修改 map。

 

 

 

 

 

  • 并发编程陷阱系列(六)高并发环境下使用性能较低的Map
            
    
    博客分类: 多线程  
  • 大小: 22.4 KB