呕心沥血，独到的见解：JUC集合类，独到的见解。

put核心流程
先判断不为空，key和v都不为空，hashMap则是key可以为空
1key进行重hash，spread
2对当前table无条件循环
3没有初始化table，则初始化
4没有hash冲突，则用cas插入新节点，成功后判断是否需要扩容再结束
5如果是MOVED的状态，则先扩容
6存在hash冲突，通过synchronized加锁，进行链表或者红黑树安全的插入 
7插入链表会有红黑树的转换，大于8的时候
8最后再检查是否需要扩容

final V putVal(K key, V value, boolean onlyIfAbsent) {
        //这里于hashmap不一样，不允许null值
        if (key == null || value == null) throw new NullPointerException();
        //算出自己的hash值，spread是重hash，减少碰撞
        int hash = spread(key.hashCode());
        int binCount = 0;
        //用for做死循环，这里就是配合cas使用的，cas，和预期值不符合的话，就再一次进入逻辑，直到cas成功
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh; K fk; V fv;
            //为空则初始化，健壮性就看一眼就先过哈，往后看
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            //tabAt,获取table中索引为i的元素， 
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { 
                //casTabAt(i)利用cas实现无锁插入，实际上属于乐观锁
                if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
                    break;                   // no lock when adding to empty bin
            }
            //MOVED为-1的时候，进行扩容
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
           
            else if (onlyIfAbsent // check first node without acquiring lock
                     && fh == hash
                     && ((fk = f.key) == key || (fk != null && key.equals(fk)))
                     && (fv = f.val) != null)
                return fv;
            //最后一个else，既不为null，也不需要扩容，剩下的就是算出来的位置冲突了
            else {
                V oldVal = null;
                //这时候就需要加synchronized锁来保证并发安全，锁住红黑树或者是链表
                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);
                                    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;
                            }
                        }
                        else if (f instanceof ReservationNode)
                            throw new IllegalStateException("Recursive update");
                    }
                }
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
    //扩容
        addCount(1L, binCount);
        return null;
    } 

/**
 * @Author：Joseph
 * 演示：组合操作不能保证线程安全
 */
public class OptionNotSafe implements Runnable{
    private static ConcurrentHashMap<String,Integer> scores = new ConcurrentHashMap<>();
​
    public static void main(String[] args) throws InterruptedException {
        scores.put("小明",0);
        Thread thread1 = new Thread(new OptionNotSafe());
        Thread thread2 = new Thread(new OptionNotSafe());
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(scores);
    }
​
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            Integer socre = scores.get("小明");
            int newScore = socre + 1;
            scores.put("小明",newScore);
        }
    }
}

for (int i = 0; i < 10; i++) {
    while (true){
        Integer socre = scores.get("小明");
        int newScore = socre + 1;
        boolean b = scores.replace("小明", socre, newScore);
        while (b){
            break;
        }
    }
}

/**
 * @Author：Joseph
 * 演示迭代的时候copyOnWriteArrayList可以在迭代的时候修改数据
 * 而ArrayList不行
 */
public class CopyOnwriteArrayListDemo1 {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println("list is " +list);
            String next = iterator.next();
            System.out.println(next);
            if(next == "2"){
                list.remove("5");
            }
            if(next=="3"){
                list.add("3 found");
            }
        }
    }
}
//结果
list is [1, 2, 3, 4, 5]
1
list is [1, 2, 3, 4, 5]
2
list is [1, 2, 3, 4]
3
list is [1, 2, 3, 4, 3 found]
4
list is [1, 2, 3, 4, 3 found]
5

public class CopyOnwriteArrayListDemo2 {
    public static void main(String[] args) {
        CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>(new Integer[]{1, 2, 3});
        System.out.println(list);
        Iterator<Integer> itr1 = list.iterator();
        list.add(4);
        System.out.println(list);
        Iterator<Integer> itr2 = list.iterator();
​
        itr1.forEachRemaining(System.out::print);
        System.out.println();
        itr2.forEachRemaining(System.out::print);
    }
}
//结果
[1, 2, 3]
[1, 2, 3, 4]
123
1234

public void sort(Comparator<? super E> c) {
    synchronized (lock) {
        sortRange(c, 0, getArray().length);
    }
}

/**
 * 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) {
   //对象锁，保证并发安全
    synchronized (lock) {
        //拷贝旧的数组
        Object[] es = getArray();
        int len = es.length;
        //扩容长度
        es = Arrays.copyOf(es, len + 1);
        //赋值
        es[len] = e;
        //set新的引用
        setArray(es);
        return true;
    }
}

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

/**
 * @Author：Joseph
 * 面试场景，一个面试官
 * 3个座位
 * 但是有10个面试者
 *
 */
public class ArrayBlockingQueueDemo {


    public static void main(String[] args) {
        //模拟只有3个等待座位
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(3);
        Interviewer r1 = new Interviewer(queue);
        Consumer r2 = new Consumer(queue);
        new Thread(r1).start();
        new Thread(r2).start();
    }
}
//面试官
class Interviewer implements Runnable{
    BlockingQueue<String> queue;
    public Interviewer(BlockingQueue queue){
        this.queue = queue;
    }

    @Override
    public void run() {
        System.out.println("10个候选人都来了");
        for (int i = 0; i < 10; i++) {
            String candidate = "Candidate"+i;
            try {
                queue.put(candidate);
                System.out.println("安排好了"+candidate+"坐着等待面试");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //结束信号，让消费者知道结束了
        try {
            queue.put("stop");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Consumer implements Runnable{
    BlockingQueue<String> queue;
    public Consumer(BlockingQueue queue) {
        this.queue = queue;
    }


    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String msg;
        try {
            while (!(msg = queue.take()).equals("stop")){
                System.out.println(msg+"在面试");
            }
            System.out.println("面试完了10个人了");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println();
    }

public void put(E e) throws InterruptedException {
    Objects.requireNonNull(e);
    final ReentrantLock lock = this.lock;
    //lock可中断锁，put等待时候，可以被线程中断方法打断，而不是非要获取到这个锁
    lock.lockInterruptibly();
    try {	
        //满了，则等待，
        while (count == items.length)
            //等待不满
            notFull.await();
        //入队
        enqueue(e);
    } finally {
        //解锁。
        lock.unlock();
    }
}