线程安全的容器

线程安全的容器

List ,Set

SynchronizedList, SynchronizedSet

和名字一样为了保证线程安全，在List 和 Set的所有方法上加上了Synchronized关键字保证线程安全

优点：无论读取还是更新都保证时最新的数据

缺点：对于高并发读的业务性能不高

CopyOnWrite集合类

java.util.concurrent.CopyOnWriteArrayList
java.util.concurrent.CopyOnWriteArraySet

public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

private E get(Object[] a, int index) {
    return (E) a[index];
}

public E get(int index) {
    return get(getArray(), index);
}

可以看到只有在更新数据时才会上锁，读取并不会上锁，大大提高了并发读取的效率

缺点：对于更新操作会先将数据复制一份，加大了开销，并且由于读取不上锁，不保证共享数据的可见性，数据可能不是最新的

结论：该类只适合用于高并发读的场景，对于高并发写的场景不仅提升不了速度还加大了内存开销

Map

ConcurrentHashMap 1.7

1.7的版本采用分段锁的方式保证线程安全，Segment继承ReentrantLock

1    /**
2     * Segment 数组，存放数据时首先需要定位到具体的 Segment 中。
3     */
4    final Segment<K,V>[] segments;
5
6    transient Set<K> keySet;
7    transient Set<Map.Entry<K,V>> entrySet;

 1    static final class Segment<K,V> extends ReentrantLock implements Serializable {
 2
 3        private static final long serialVersionUID = 2249069246763182397L;
 4
 5        // 和 HashMap 中的 HashEntry 作用一样，真正存放数据的桶
 6        transient volatile HashEntry<K,V>[] table;
 7
 8        transient int count;
 9
10        transient int modCount;
11
12        transient int threshold;
13
14        final float loadFactor;
1
16    }

并在关键的共享变量：value, next上加volatile关键字保证线程可见性

put操作

对于多个线程争抢同个分段锁的情况，1.7中，获取锁失败的线程会尝试通过自旋的方式获取分段锁，如果尝试次数达到最大，就会采用阻塞获取锁的方式，获取了对应的分段锁后才会在改分段进行更新操作

get操作

get操作整个过程不上锁，仅通过volatile关键字来保证数据的一致性

ConcurrentHashMap 1.8

抛弃了原有的分段锁机制，采用CAS+Synchronized来保证线程安全

同样采用volatile关键字来保证可见性

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        volatile V val;
        volatile Node<K,V> next;

        Node(int hash, K key, V val, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.val = val;
            this.next = next;
        }

put

和HashMap不同，该类不能插入null值

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    //得到key的hashCode
    int hash = spread(key.hashCode());
    
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        //是否需要初始化
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        //如果没有产生hash冲突，则尝试利用CAS在该位置写入数据
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        //MOVED = -1 说明需要扩容
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        
        //如果产生hash冲突则改用Synchronized的方式获取该位置的锁,进行put
        else {
            V oldVal = null;
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    //说明是链表
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                //如果key已经存在并且标志为可以修改直接覆盖值
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            //如果Key不存在则在
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }
            if (binCount != 0) {
                //链表长度达到8则转化为红黑树
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

get

• 根据计算出来的 hashcode 寻址，如果就在桶上那么直接返回值。
• 如果是红黑树那就按照树的方式获取值。
• 就不满足那就按照链表的方式遍历获取值。