2015年3月9日

1,概述

java 里面的容器有list,set和map,如果其中线程安全的容器有vector，hashtable，也可以用Collections类里面的synchronizedList(List<T> list),synchronizedSet(Set<T> s)和synchronizedMap(Map<K,V> m)来构造线程安全的容器，不过这些方法都是通过添加synchronized方法来实现线程安全的，即同一时间只能有同一个线程访问其方法。严重影响了程序的性能，java.util.concurrent包里面采用了不同的机制提供了一些线程安全的容器，比如说copyOnWriteArrayList,CopyOnWriteArraySet 和CurrentHashMap，ConcurrentSkipListMap,ConcurrentSkipListSet.等等，那么这些容器与synchrozied方法的实现有哪些不同呢？本文将通过对比hashTable和ConcurrentHashMap来讨论一下二者的区别。

2，HashTable和ConcurrentHashMap的对比。

HashTable中用来存储元素的变量：

private transient Entry<K,V>[] table;

Entry对象：

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

ConcurrentHashMap中用来存储元素的变量：

/**
     * The segments, each of which is a specialized hash table.
     */
    final Segment<K,V>[] segments;

Segment对象里面的变量：

 /**
         * The per-segment table. Elements are accessed via
         * entryAt/setEntryAt providing volatile semantics.
         */
        transient volatile HashEntry<K,V>[] table;

HashEntry对象：

 static final class HashEntry<K,V> {
        final int hash;
        final K key;
        volatile V value;
        volatile HashEntry<K,V> next;

从二者的变量上来看，二者在存储元素的方式上有这很大的不同，hashTable只是采用了一个Entry<> Table来存储元素，而ConcurrentHashMap里面是有一个Segment数组，每一个segement可以看做一个hashTable，这种方式就是“锁分段”或“锁分离”技术，也就是将数据分成几段，把每段分别进行加锁，只要操作的数据不在同一段上，就可以并发的执行，通过这种方式来提高并发性。

HashTable的put方法：

 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 = hash(key);
        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;
            hash = hash(key);
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

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

CurrentHashMap里面的put方法：

 public V put(K key, V value) {
        Segment<K,V> s;
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key);
        int j = (hash >>> segmentShift) & segmentMask;
        if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
            s = ensureSegment(j);
        return s.put(key, hash, value, false);
    }

 final V put(K key, int hash, V value, boolean onlyIfAbsent) {
            HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);
            V oldValue;
            try {
                HashEntry<K,V>[] tab = table;
                int index = (tab.length - 1) & hash;
                HashEntry<K,V> first = entryAt(tab, index);
                for (HashEntry<K,V> e = first;;) {
                    if (e != null) {
                        K k;
                        if ((k = e.key) == key ||
                            (e.hash == hash && key.equals(k))) {
                            oldValue = e.value;
                            if (!onlyIfAbsent) {
                                e.value = value;
                                ++modCount;
                            }
                            break;
                        }
                        e = e.next;
                    }
                    else {
                        if (node != null)
                            node.setNext(first);
                        else
                            node = new HashEntry<K,V>(hash, key, value, first);
                        int c = count + 1;
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                            rehash(node);
                        else
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
        }

HashTable的get操作：

public synchronized V get(Object key) {
        Entry tab[] = table;
        int hash = hash(key);
        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;
    }

CurrentHashMap的get 操作：

public V get(Object key) {
        Segment<K,V> s; // manually integrate access methods to reduce overhead
        HashEntry<K,V>[] tab;
        int h = hash(key);
        long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
        if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
            (tab = s.table) != null) {
            for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                     (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
                 e != null; e = e.next) {
                K k;
                if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                    return e.value;
            }
        }
        return null;
    }

通过以上的对比可以看到，ConcurrentHashMap所采用的“锁分段”的技术，只要修改操作不是发生在同一个segment上面，就可以并发的进行，这样就可以大大的提高并发性。当然这样的副作用是hash的时间比较长，每次定位一个元素需要两次hash过程，第一次找到相应的段，第二次找到元素在段里面的位置。