...

    /**

      * Maps the specified key to the specified value in this table.

      * Neither the key nor the value can be null.

      *

      * <p>The value can be retrieved by calling the {@code get} method

      * with a key that is equal to the original key.

      *

      * @param key key with which the specified value is to be associated

      * @param value value to be associated with the specified key

      * @return the previous value associated with {@code key}, or

      *         {@code null} if there was no mapping for {@code key}

      * @throws NullPointerException if the specified key or value is null

      */

     public V put(K key, V value) {

         return putVal(key, value, false);

     }  

     /** Implementation for put and putIfAbsent */

     final V putVal(K key, V value, boolean onlyIfAbsent) {

         if (key == null || value == null) throw new NullPointerException();

         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();

             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

             }

             else if ((fh = f.hash) == MOVED)

                 tab = helpTransfer(tab, f);

             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;

                                     if (!onlyIfAbsent)

                                         e.val = value;

                                     break;

                                 }

                                 Node<K,V> pred = e;

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

                     if (binCount >= TREEIFY_THRESHOLD)

                         treeifyBin(tab, i);

                     if (oldVal != null)

                         return oldVal;

                     break;

                 }

             }

         }

         addCount(1L, binCount);

         return null;

     }

 ...  

ConcurrentHashMap 在默认并发级别会创建包含 16 个 Segment 对象的数组。每个 Segment 的成员对象 table 包含若干个散列表的桶。每个桶是由 HashEntry 链接起来的一个链表。如果键能均匀散列，每个 Segment 大约守护整个散列表中桶总数的 1/16。

CopyOnWriteArrayList可以用于什么应用场景？

多读少写

 ...

    /**

      * Appends the specified element to the end of this list.

      *

      * @param e element to be appended to this list

      * @return {@code true} (as specified by {@link Collection#add})

      */

     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();

         }

     }  

     /**

      * Inserts the specified element at the specified position in this

      * list. Shifts the element currently at that position (if any) and

      * any subsequent elements to the right (adds one to their indices).

      *

      * @throws IndexOutOfBoundsException {@inheritDoc}

      */

     public void add(int index, E element) {

         final ReentrantLock lock = this.lock;

         lock.lock();

         try {

             Object[] elements = getArray();

             int len = elements.length;

             if (index > len || index < 0)

                 throw new IndexOutOfBoundsException("Index: "+index+

                                                     ", Size: "+len);

             Object[] newElements;

             int numMoved = len - index;

             if (numMoved == 0)

                 newElements = Arrays.copyOf(elements, len + 1);

             else {

                 newElements = new Object[len + 1];

                 System.arraycopy(elements, 0, newElements, 0, index);

                 System.arraycopy(elements, index, newElements, index + 1,

                                  numMoved);

             }

             newElements[index] = element;

             setArray(newElements);

         } finally {

             lock.unlock();

         }

     }

 ...