ConcurrentCollection

Author: CodePrometheus

Collection/Collection.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

Collection/src/CollectionSummary.java

@@ -0,0 +1,15 @@
+/**
+ * 并发容器总结
+ *
+ * @Author: zzStar
+ * @Date: 10-12-2020 13:39
+ */
+public class CollectionSummary {
+    /**
+     * java.util.concurrent包提供的容器，分为3类：
+     *      Concurrent*、CopyOnWrite*、Blocking*
+     *
+     * Concurrent*的特点大部分通过CAS实现并发，而CopyOnWrite*则是通过复制一份原数据来实现
+     * Blocking*是通过AQS实现
+     */
+}

Collection/src/concurrenthashmap/CollectionSummary.java

@@ -0,0 +1,19 @@
+package concurrenthashmap;
+
+/**
+ * 并发容器概览
+ *
+ * @Author: zzStar
+ * @Date: 10-11-2020 19:57
+ */
+public class CollectionSummary {
+
+    /**
+     * ConcurrentHashMap    线程安全的HashMap
+     * CopyOnWriteArrayList 线程安全的List
+     *
+     * BlockingQueue 接口，阻塞队列，适合用于作为数据共享的通道
+     * ConcurrentLinkedQueue 高效的非阻塞并发队列，使用链表实现，可看作线程安全的LinkedList
+     */
+
+}

Collection/src/concurrenthashmap/ConcurrentHashMapAnalysis.java

@@ -0,0 +1,133 @@
+package concurrenthashmap;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * jdk1.8后，结构和1.8后的hashmap类似
+ * <p>
+ * 1.7是16个Segment，每个Segment里面是类似hashmap的结构
+ * 1.8是链表+红黑树
+ * <p>
+ * ConcurrentHashMap源码浅析
+ *
+ * @Author: zzStar
+ * @Date: 10-11-2020 20:22
+ */
+public class ConcurrentHashMapAnalysis {
+}
+
+/*
+    public V get(Object key) {
+        ConcurrentHashMap.Node<K,V>[] tab; ConcurrentHashMap.Node<K,V> e, p; int n, eh; K ek;
+        //得到hash值
+        int h = spread(key.hashCode());
+        if ((tab = table) != null && (n = tab.length) > 0 &&
+                (e = tabAt(tab, (n - 1) & h)) != null) {
+            if ((eh = e.hash) == h) {
+            //槽点和key符合则直接返回value
+                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
+                    return e.val;
+            }
+            //负数说明，得到的是一个红黑树结点或者为转移结点，调用find方法取值
+            else if (eh < 0)
+                return (p = e.find(h, key)) != null ? p.val : null;
+            //若均不是，则遍历链表取值
+            while ((e = e.next) != null) {
+                if (e.hash == h &&
+                        ((ek = e.key) == key || (ek != null && key.equals(ek))))
+                    return e.val;
+            }
+        }
+        return null;
+    }
+*/
+
+
+/*
+    final V putVal(K key, V value, boolean onlyIfAbsent) {
+        //判断是否为空，不允许为空
+        if (key == null || value == null) throw new NullPointerException();
+        //计算hash值
+        int hash = spread(key.hashCode());
+        int binCount = 0;
+        //根据对应位置节点的类型来赋值，或者helpTransfer，或者增长链表，或者给红黑树增加节点
+        for (ConcurrentHashMap.Node<K,V>[] tab = table;;) {
+            ConcurrentHashMap.Node<K,V> f; int n, i, fh; K fk; V fv;
+            if (tab == null || (n = tab.length) == 0)
+                //初始化tab
+                tab = initTable();
+            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
+                //cas操作，直接放进去
+                if (casTabAt(tab, i, null, new ConcurrentHashMap.Node<K,V>(hash, key, value)))
+                    break;                   // no lock when adding to empty bin
+            }
+            //MOVED转移结点，说明槽点正在扩容，帮助进行
+            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 {
+                V oldVal = null;
+                synchronized (f) {
+                    if (tabAt(tab, i) == f) {
+                        if (fh >= 0) {
+                            binCount = 1;
+                            for (ConcurrentHashMap.Node<K,V> e = f;; ++binCount) {
+                                K ek;
+                                //判断当前是否存在这个key
+                                if (e.hash == hash &&
+                                        ((ek = e.key) == key ||
+                                                (ek != null && key.equals(ek)))) {
+                                    oldVal = e.val;
+                                    if (!onlyIfAbsent)
+                                        e.val = value;
+                                    break;
+                                }
+                                //不存在就新创建一个结点
+                                ConcurrentHashMap.Node<K,V> pred = e;
+                                if ((e = e.next) == null) {
+                                    pred.next = new ConcurrentHashMap.Node<K,V>(hash, key, value);
+                                    break;
+                                }
+                            }
+                        }
+                        //红黑树
+                        else if (f instanceof ConcurrentHashMap.TreeBin) {
+                            ConcurrentHashMap.Node<K,V> p;
+                            binCount = 2;
+                            if ((p = ((ConcurrentHashMap.TreeBin<K,V>)f).putTreeVal(hash, key,
+                                    value)) != null) {
+                                oldVal = p.val;
+                                if (!onlyIfAbsent)
+                                    p.val = value;
+                            }
+                        }
+                        else if (f instanceof ConcurrentHashMap.ReservationNode)
+                            throw new IllegalStateException("Recursive update");
+                    }
+                }
+                //完成添加后，判断是否需要将链表转为树
+                if (binCount != 0) {
+                    //大于阈值8，则转为树
+                    if (binCount >= TREEIFY_THRESHOLD)
+                        //treeifyBin还要满足最低容量条件64
+                        treeifyBin(tab, i);
+                    if (oldVal != null)
+                        return oldVal;
+                    break;
+                }
+            }
+        }
+        addCount(1L, binCount);
+        return null;
+    }
+*/
+
+/**
+ * 为什么超过8要转为红黑树？
+ * 1.默认是链表，红黑树每个节点占用的空间是链表的2倍
+ * 2.经过泊松分布，hash冲突到达8的时候概率小于千万分之1 (0.00000006)，正常情况下，链表的长度不会达到8，但为保证极端情况下，仍有较高的查询效率，转为红黑树
+ */

Collection/src/concurrenthashmap/HashMapEndLessLoop.java

@@ -0,0 +1,35 @@
+package concurrenthashmap;
+
+import java.util.HashMap;
+
+/**
+ * 演示hashmap在多线程情况下造成死循环的情况 导致循环链表，造成CPU100%，出现OOM
+ * 注意：仅在JDK7及以前存在！
+ * hashmap定位就不是高并发
+ *
+ * hashmap非线程安全，但只读的并发是安全的
+ *
+ * @Author: zzStar
+ * @Date: 10-12-2020 09:02
+ */
+public class HashMapEndLessLoop {
+
+    //扩容的时候问题出现,当内容超过4，触发扩容机制
+    private static HashMap<Integer, String> map = new HashMap<>(2, 1.5f);
+
+    public static void main(String[] args) {
+        map.put(5, "c");
+        map.put(7, "b");
+        map.put(3, "a");
+        new Thread(() -> {
+            map.put(15, "d");
+            System.out.println(map);
+        }, "thread1").start();
+
+        new Thread(() -> {
+            map.put(1, "e");
+            System.out.println(map);
+        }, "thread2").start();
+
+    }
+}

Collection/src/concurrenthashmap/HashtableDemo.java

@@ -0,0 +1,32 @@
+package concurrenthashmap;
+
+import java.util.Hashtable;
+
+/**
+ * 同样大量在方法上加上synchronized，并发性能差
+ *
+ * @Author: zzStar
+ * @Date: 10-11-2020 20:10
+ */
+public class HashtableDemo {
+    public static void main(String[] args) {
+        Hashtable<String, String> hashtable = new Hashtable<>();
+        hashtable.put("I love Java", "forever");
+        String s = hashtable.get("I love Java");
+        System.out.println("s = " + s);
+    }
+}
+
+/*
+    public synchronized V get(Object key) {
+        Hashtable.Entry<?,?> tab[] = table;
+        int hash = key.hashCode();
+        int index = (hash & 0x7FFFFFFF) % tab.length;
+        for (Hashtable.Entry<?,?> e = tab[index]; e != null ; e = e.next) {
+            if ((e.hash == hash) && e.key.equals(key)) {
+                return (V)e.value;
+            }
+        }
+        return null;
+    }
+*/

Collection/src/concurrenthashmap/OptionNotSafe.java

@@ -0,0 +1,48 @@
+package concurrenthashmap;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * 组合操作并不保证ConcurrentHashMap的线程安全
+ *
+ * @Author: zzStar
+ * @Date: 10-12-2020 10:08
+ */
+public class OptionNotSafe implements Runnable {
+    private static ConcurrentHashMap<String, Integer> scores = new ConcurrentHashMap<String, Integer>();
+
+    public static void main(String[] args) throws InterruptedException {
+        scores.put("zzStar", 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 < 1000; i++) {
+/*
+            //同步的类锁实现线程安全
+            synchronized (concurrenthashmap.OptionNotSafe.class) {
+                Integer score = scores.get("zzStar");
+                int newScore = score + 1;
+                scores.put("zzStar", newScore);
+            }
+*/
+            while (true) {
+                Integer score = scores.get("zzStar");
+                int newScore = score + 1;
+                //运用replace先检查值是否为原值，是则替换，线程安全
+                boolean replace = scores.replace("zzStar", score, newScore);
+                if (replace) {
+                    break;
+                }
+            }
+
+        }
+    }
+}

Collection/src/concurrenthashmap/SynList.java

@@ -0,0 +1,47 @@
+package concurrenthashmap;
+
+import java.util.*;
+import java.util.ArrayList;
+
+/**
+ * Collections.synchronizedList同样性能不高
+ *
+ * @Author: zzStar
+ * @Date: 10-11-2020 20:16
+ */
+public class SynList {
+    public static void main(String[] args) {
+        List<Integer> list = Collections.synchronizedList(new ArrayList<>());
+        list.add(5);
+        System.out.println(list.get(0));
+    }
+}
+
+/*
+    public static <T> List<T> synchronizedList(List<T> list) {
+        return (list instanceof RandomAccess ?
+                new Collections.SynchronizedRandomAccessList<>(list) :
+                new Collections.SynchronizedList<>(list));
+    }
+*/
+
+/*
+public class ArrayList<E> extends AbstractList<E>
+        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
+*/
+
+/*
+    public E get(int index) {
+        synchronized (mutex) {return list.get(index);}
+    }
+    public E set(int index, E element) {
+        synchronized (mutex) {return list.set(index, element);}
+    }
+    public void add(int index, E element) {
+        synchronized (mutex) {list.add(index, element);}
+    }
+    public E remove(int index) {
+        synchronized (mutex) {return list.remove(index);}
+    }
+*/
+

Collection/src/concurrenthashmap/VectorDemo.java

@@ -0,0 +1,28 @@
+package concurrenthashmap;
+
+import java.util.Vector;
+
+/**
+ * Vector源码
+ * 大量的synchronized导致性能缺失
+ *
+ * @Author: zzStar
+ * @Date: 10-11-2020 20:05
+ */
+public class VectorDemo {
+    public static void main(String[] args) {
+        Vector<String> vector = new Vector<>();
+        vector.add("Vector");
+        System.out.println(vector.get(0));
+    }
+}
+
+//下面是源码
+/*
+    public synchronized E get(int index) {
+        if (index >= elementCount)
+            throw new ArrayIndexOutOfBoundsException(index);
+
+        return elementData(index);
+    }
+*/