ConcurrentSkipListMap

ConcurrentSkipListMap 能解决什么问题？什么时候使用 ConcurrentSkipListMap?

  1. 1）ConcurrentSkipListMap 是基于跳表实现的并发排序哈希表，映射可以根据键的自然顺序进行排序，
  2. 也可以根据创建映射时所提供的 Comparator 进行排序，具体取决于使用的构造方法。
  3. 2）ConcurrentSkipListMap 的 containsKey、get、put、remove 操作及其变体提供预期平均 log(n) 时间开销。
  4. 3）ConcurrentSkipListMap 的功能类似于 TreeMap 的线程安全版本。
  5. 4）ConcurrentSkipListMap 提供排序功能的同时，由于其插入、删除时需要维护跳表结构，性能低于 ConcurrentHashMap。

如何使用 ConcurrentSkipListMap?

  1. 1）需要使用 ConcurrentNavigableMap 的一些特性时使用 ConcurrentSkipListMap。

使用 ConcurrentSkipListMap 有什么风险？

  1. 1）ConcurrentSkipListMap 由于底层是通过跳跃表实现的，比较耗内存。
  2. 2）新增、删除元素时需要维护跳表结构，存在一定的性能损耗。

ConcurrentSkipListMap 核心操作的实现原理？

创建实例

  1.     /**
  2.      *  执行键排序的比较器，如果以自然顺序排序则为 null
  3.      */
  4.     final Comparator<? super K> comparator;
  6.     /** 延迟初始化的顶层索引 */
  7.     private transient Index<K,V> head;
  8.     /** 延迟初始化的元素计数 */
  9.     private transient LongAdder adder;
  10.     /** 延迟初始化的键集合 */
  11.     private transient KeySet<K,V> keySet;
  12.     /** 延迟初始化的值集合 */
  13.     private transient Values<K,V> values;
  14.     /** 延迟初始化的映射集合 */
  15.     private transient EntrySet<K,V> entrySet;
  16.     /** 延迟初始化的降序映射 */
  17.     private transient SubMap<K,V> descendingMap;
  19.     /**
  20.      *  头结点和标记节点的 key 为 null，在节点被删除时将 val 置为null
  21.      */
  22.     static final class Node<K,V> {
  23.         final K key; // currently, never detached
  24.         V val;
  25.         Node<K,V> next;
  26.         Node(K key, V value, Node<K,V> next) {
  27.             this.key = key;
  28.             this.val = value;
  29.             this.next = next;
  30.         }
  31.     }
  33.     /**
  34.      *  索引节点以表示跳表的层级
  35.      */
  36.     static final class Index<K,V> {
  37.         // 驻留节点值
  38.         final Node<K,V> node;  // currently, never detached
  39.         // 下节点
  40.         final Index<K,V> down;
  41.         // 右节点
  42.         Index<K,V> right;
  43.         Index(Node<K,V> node, Index<K,V> down, Index<K,V> right) {
  44.             this.node = node;
  45.             this.down = down;
  46.             this.right = right;
  47.         }
  48.     }
  50.     /**
  51.      *  创建一个使用自然顺序进行排序的空 ConcurrentSkipListMap 实例
  52.      */
  53.     public ConcurrentSkipListMap() {
  54.         this.comparator = null;
  55.     }
  57.     /**
  58.      *  创建一个使用比较器 comparator 进行排序的空 ConcurrentSkipListMap 实例
  59.      */
  60.     public ConcurrentSkipListMap(Comparator<? super K> comparator) {
  61.         this.comparator = comparator;
  62.     }

添加元素

  1.     /**
  2.      *  1）如果目标 key 不存在，则写入新的键值对，并返回 null。
  3.      *  2）如果目标 key 存在，则替换其关联的值，并返回旧值。
  4.      */
  5.     @Override
  6.     public V put(K key, V value) {
  7.         if (value == null) {
  8.             throw new NullPointerException();
  9.         }
  10.         return doPut(key, value, false);
  11.     }
  13.     private V doPut(K key, V value, boolean onlyIfAbsent) {
  14.         if (key == null) {
  15.             throw new NullPointerException();
  16.         }
  17.         final Comparator<? super K> cmp = comparator;
  18.         for (;;) {
  19.             /**
  20.              * h：head 头结点
  21.              * b：predecessor 前置节点
  22.              */
  23.             Index<K,V> h; Node<K,V> b;
  24.             VarHandle.acquireFence();
  25.             // 节点所在的层次
  26.             int levels = 0;
  27.             // 1）head==null 表示第一次插入元素
  28.             if ((h = head) == null) {          // try to initialize
  29.                 // 创建一个标记节点
  30.                 final Node<K,V> base = new Node<>(null, null, null);
  31.                 // 创建索引节点
  32.                 h = new Index<>(base, null, null);
  33.                 // 更新头节点
  34.                 b = ConcurrentSkipListMap.HEAD.compareAndSet(this, null, h) ? base : null;
  35.             }
  36.             // 2）跳表已经有元素存在
  37.             else {
  38.                 /**
  39.                  * q：index node
  40.                  * r：right node
  41.                  * d：down node
  42.                  */
  43.                 for (Index<K,V> q = h, r, d;;) { // count while descending
  44.                     // 索引节点的右节点不为 null
  45.                     while ((r = q.right) != null) {
  46.                         Node<K,V> p; K k;
  47.                         /**
  48.                          *  右索引节点的驻留节点为 null ||
  49.                          *  节点的键为 null ||
  50.                          *  节点的值为 null
  51.                          */
  52.                         if ((p = r.node) == null || (k = p.key) == null ||
  53.                                 p.val == null) {
  54.                             // 删除接地啊 q 的右侧节点
  55.                             ConcurrentSkipListMap.RIGHT.compareAndSet(q, r, r.right);
  56.                             // 2）查找键大于当前节点键，则继续往右侧查找
  57.                         } else if (ConcurrentSkipListMap.cpr(cmp, key, k) > 0) {
  58.                             q = r;
  59.                             // 3）查找键小于等于当前键，则当层节点已经查找完毕，往下层查找
  60.                         } else {
  61.                             break;
  62.                         }
  63.                     }
  64.                     // 1）当前索引节点存在下层节点，则往下层查找
  65.                     if ((d = q.down) != null) {
  66.                         // 递增层级
  67.                         ++levels;
  68.                         // 读取下层节点，重新进入循环并尝试往右侧查找
  69.                         q = d;
  70.                     }
  71.                     else {
  72.                         /**
  73.                          *  2）已经到达最后一层
  74.                          *  则读取驻留其上的节点值，开始玩右侧遍历
  75.                          */
  76.                         b = q.node;
  77.                         break;
  78.                     }
  79.                 }
  80.             }
  81.             // 前置节点存在
  82.             if (b != null) {
  83.                 Node<K,V> z = null;              // new node, if inserted
  84.                 for (;;) {
  85.                     /**
  86.                      * n：node
  87.                      * k：key
  88.                      * v：value
  89.                      * c：Comparisons 比较值
  90.                      */
  91.                     Node<K,V> n, p; K k; V v; int c;
  92.                     // 1）前置节点的 next 为 null，则表示当前节点是最后一个节点
  93.                     if ((n = b.next) == null) {
  94.                         if (b.key == null) {
  95.                             ConcurrentSkipListMap.cpr(cmp, key, key);
  96.                         }
  97.                         c = -1;
  98.                     }
  99.                     // 2）节点键为 null
  100.                     else if ((k = n.key) == null) {
  101.                         break;                   // can't append; restart
  102.                         // 3）节点值为 null，该节点已经被删除，需要从链表中踢除
  103.                     } else if ((v = n.val) == null) {
  104.                         ConcurrentSkipListMap.unlinkNode(b, n);
  105.                         c = 1;
  106.                     }
  107.                     // 4）比较查找键和当前键，并且查找键比较大
  108.                     else if ((c = ConcurrentSkipListMap.cpr(cmp, key, k)) > 0) {
  109.                         // 查找下一个节点
  110.                         b = n;
  111.                         /**
  112.                          * 5）如果键相等 && 只有不存在才插入元素，则直接返回；否则尝试更新节点值
  113.                          */
  114.                     } else if (c == 0 &&
  115.                             (onlyIfAbsent || ConcurrentSkipListMap.VAL.compareAndSet(n, v, value))) {
  116.                         // 更新成功则返回旧值
  117.                         return v;
  118.                     }
  119.                     /**
  120.                      *  目标键大于 predecessor.key 小于  predecessor.next.key，
  121.                      *  将目标键值对插入到他们中间。
  122.                      */
  123.                     if (c < 0 &&
  124.                             ConcurrentSkipListMap.NEXT.compareAndSet(b, n,
  125.                                     p = new Node<>(key, value, n))) {
  126.                         // 读取新增节点
  127.                         z = p;
  128.                         break;
  129.                     }
  130.                 }
  132.                 if (z != null) {
  133.                     // 读取随机数
  134.                     final int lr = ThreadLocalRandom.nextSecondarySeed();
  135.                     // 有 1/4 的机会基于新增节点生成索引节点
  136.                     if ((lr & 0x3) == 0) {       // add indices with 1/4 prob
  137.                         final int hr = ThreadLocalRandom.nextSecondarySeed();
  138.                         long rnd = (long)hr << 32 | lr & 0xffffffffL;
  139.                         // 新增节点所在的层级，层级从 0 开始
  140.                         int skips = levels;      // levels to descend before add
  141.                         Index<K,V> x = null;
  142.                         for (;;) {               // create at most 62 indices
  143.                             // 基于新增节点生成顶层索引节点
  144.                             x = new Index<>(z, x, null);
  145.                             if (rnd >= 0L || --skips < 0) {
  146.                                 break;
  147.                             } else {
  148.                                 rnd <<= 1;
  149.                             }
  150.                         }
  151.                         /**
  152.                          *  新增索引节点成功 &&
  153.                          *  如果是新增顶层索引节点 &&
  154.                          *  增加新的一层
  155.                          */
  156.                         if (ConcurrentSkipListMap.addIndices(h, skips, x, cmp) && skips < 0 &&
  157.                                 head == h) {         // try to add new level
  158.                             // 将新增节点加到顶层
  159.                             final Index<K,V> hx = new Index<>(z, x, null);
  160.                             // 创建新的头节点
  161.                             final Index<K,V> nh = new Index<>(h.node, h, hx);
  162.                             // 更新头节点
  163.                             ConcurrentSkipListMap.HEAD.compareAndSet(this, h, nh);
  164.                         }
  165.                         if (z.val == null)
  166.                         {
  167.                             findPredecessor(key, cmp); // clean
  168.                         }
  169.                     }
  170.                     // 增加计数值
  171.                     addCount(1L);
  172.                     return null;
  173.                 }
  174.             }
  175.         }
  176.     }
  178.     /**
  179.      *  在插入元素之后新增索引节点，从高层向低层递归插入，之后建立和前置节点的链接
  180.      *  Recursion depths are exponentially less probable.
  181.      *
  182.      * @param q 当前层级的起始索引
  183.      * @param skips 插入索引时，需要跳过的层级数
  184.      * @param x 插入的目标索引
  185.      * @param cmp comparator
  186.      */
  187.     static <K,V> boolean addIndices(Index<K,V> q, int skips, Index<K,V> x,
  188.             Comparator<? super K> cmp) {
  189.         Node<K,V> z; K key;
  190.         /**
  191.          * 1）新增索引节点不为 null &&
  192.          * 2）驻留数据节点不为 null &&
  193.          * 3）数据节点的键不为 null &&
  194.          * 4）起始索引节点不为 null
  195.          */
  196.         if (x != null && (z = x.node) != null && (key = z.key) != null &&
  197.                 q != null) {                            // hoist checks
  198.             boolean retrying = false;
  199.             for (;;) {                              // find splice point
  200.                 /**
  201.                  * r：right
  202.                  * d：down
  203.                  * c：Comparisons
  204.                  */
  205.                 Index<K,V> r, d; int c;
  206.                 /**
  207.                  *  当前节点的右侧节点不为 null
  208.                  */
  209.                 if ((r = q.right) != null) {
  210.                     Node<K,V> p; K k;
  211.                     // 1）尝试删除索引节点
  212.                     if ((p = r.node) == null || (k = p.key) == null ||
  213.                             p.val == null) {
  214.                         ConcurrentSkipListMap.RIGHT.compareAndSet(q, r, r.right);
  215.                         c = 0;
  216.                     }
  217.                     // 2）目标键比当前节点键大
  218.                     else if ((c = ConcurrentSkipListMap.cpr(cmp, key, k)) > 0) {
  219.                         // 往右侧查找
  220.                         q = r;
  221.                         //  3）目标键和当前键相等
  222.                     } else if (c == 0) {
  223.                         break;                      // stale
  224.                     }
  225.                     // 4）目标键比当前节点键小？
  226.                 } else {
  227.                     // 已经不存在右侧节点
  228.                     c = -1;
  229.                 }
  231.                 if (c < 0) {
  232.                     // 下节点不为 null && 层级数 > 0
  233.                     if ((d = q.down) != null && skips > 0) {
  234.                         // 递减层级后，往下查找
  235.                         --skips;
  236.                         q = d;
  237.                     }
  238.                     /**
  239.                      *  1）下节点不为 null && skip <=0 && 未出现索引添加失败 &&
  240.                      *  尝试在当前层级添加索引
  241.                      */
  242.                     else if (d != null && !retrying &&
  243.                             !ConcurrentSkipListMap.addIndices(d, 0, x.down, cmp)) {
  244.                         // 索引添加失败则退出
  245.                         break;
  246.                     } else {
  247.                         x.right = r;
  248.                         // 插入新增索引节点
  249.                         if (ConcurrentSkipListMap.RIGHT.compareAndSet(q, r, x)) {
  250.                             // 执行成功则退出
  251.                             return true;
  252.                         }
  253.                         else {
  254.                             retrying = true;         // re-find splice point
  255.                         }
  256.                     }
  257.                 }
  258.             }
  259.         }
  260.         return false;
  261.     }

读取元素

  1.     /**
  2.      *  返回指定 key 映射的值，如果 key 不存在，则返回 null
  3.      */
  4.     @Override
  5.     public V get(Object key) {
  6.         return doGet(key);
  7.     }
  9.     /**
  10.      * Gets value for key. Same idea as findNode, except skips over
  11.      * deletions and markers, and returns first encountered value to
  12.      * avoid possibly inconsistent rereads.
  13.      */
  14.     private V doGet(Object key) {
  15.         Index<K,V> q;
  16.         VarHandle.acquireFence();
  17.         if (key == null) {
  18.             throw new NullPointerException();
  19.         }
  20.         final Comparator<? super K> cmp = comparator;
  21.         V result = null;
  22.         if ((q = head) != null) {
  23.             outer: for (Index<K,V> r, d;;) {
  24.                 /**
  25.                  * 首先向右侧查找，之后向下查找
  26.                  */
  27.                 while ((r = q.right) != null) {
  28.                     Node<K,V> p; K k; V v; int c;
  29.                     // 节点已经被删除
  30.                     if ((p = r.node) == null || (k = p.key) == null ||
  31.                             (v = p.val) == null) {
  32.                         ConcurrentSkipListMap.RIGHT.compareAndSet(q, r, r.right);
  33.                     // 目标键 > 节点键，则向右侧查找
  34.                     } else if ((c = ConcurrentSkipListMap.cpr(cmp, key, k)) > 0) {
  35.                         q = r;
  36.                     // 找到目标键
  37.                     } else if (c == 0) {
  38.                         // 读取值后返回
  39.                         result = v;
  40.                         break outer;
  41.                     } else {
  42.                         break;
  43.                     }
  44.                 }
  45.                 // 尝试向下层查找
  46.                 if ((d = q.down) != null) {
  47.                     q = d;
  48.                 } else {
  49.                     // 已经到达底层
  50.                     Node<K,V> b, n;
  51.                     // 读取索引节点驻留的数据节点之后，往右侧遍历查找
  52.                     if ((b = q.node) != null) {
  53.                         while ((n = b.next) != null) {
  54.                             V v; int c;
  55.                             final K k = n.key;
  56.                             // 跳过被删除节点和标记节点，如果目标键 > 节点键，也向右侧查找
  57.                             if ((v = n.val) == null || k == null ||
  58.                                     (c = ConcurrentSkipListMap.cpr(cmp, key, k)) > 0) {
  59.                                 b = n;
  60.                             // 目标键 <= 节点键
  61.                             } else {
  62.                                 // 如果相等，则直接返回其值
  63.                                 if (c == 0) {
  64.                                     result = v;
  65.                                 }
  66.                                 // 不存在相等的键，则返回 null
  67.                                 break;
  68.                             }
  69.                         }
  70.                     }
  71.                     break;
  72.                 }
  73.             }
  74.         }
  75.         return result;
  76.     }
  78.     /**
  79.      *  返回目标 key 关联的值，如果键不存在，则返回 defaultValue
  80.      */
  81.     @Override
  82.     public V getOrDefault(Object key, V defaultValue) {
  83.         V v;
  84.         return (v = doGet(key)) == null ? defaultValue : v;
  85.     }

替换值

  1.     /**
  2.      *  如果目标 key 存在，则替换其值为 value，并返回旧值；否则返回 null。
  3.      */
  4.     @Override
  5.     public V replace(K key, V value) {
  6.         // 键和值都非 null
  7.         if (key == null || value == null) {
  8.             throw new NullPointerException();
  9.         }
  10.         for (;;) {
  11.             Node<K,V> n; V v;
  12.             // 没找到目标键
  13.             if ((n = findNode(key)) == null) {
  14.                 // 则返回 null
  15.                 return null;
  16.             }
  17.             // 尝试原子设置值，并返回旧值
  18.             if ((v = n.val) != null && ConcurrentSkipListMap.VAL.compareAndSet(n, v, value)) {
  19.                 return v;
  20.             }
  21.         }
  22.     }
  24.     /**
  25.      *  返回指定 key 映射的节点，如果键不存在，则返回 null。
  26.      *  查找过程中会踢除已经被删除键值对的索引节点，并且重新通过 findPredecessor 方法
  27.      *  查找基础节点进行再次遍历【如果节点的 key 为 null，则表示它是一个标记节点，
  28.      *  它的前置节点将被删除。】
  29.      *  The traversal loops in doPut, doRemove, and findNear all include the same checks.
  30.      */
  31.     private Node<K,V> findNode(Object key) {
  32.         if (key == null)
  33.         {
  34.             throw new NullPointerException(); // don't postpone errors
  35.         }
  36.         final Comparator<? super K> cmp = comparator;
  37.         Node<K,V> b;
  38.         // 读取底层有效的前置节点
  39.         outer: while ((b = findPredecessor(key, cmp)) != null) {
  40.             for (;;) {
  41.                 Node<K,V> n; K k; V v; int c;
  42.                 // 1）已经到达尾部，则直接退出
  43.                 if ((n = b.next) == null) {
  44.                     break outer;               // empty
  45.                 // 2）当前节点是标记节点
  46.                 } else if ((k = n.key) == null) {
  47.                     break;                     // b is deleted
  48.                 // 3）当前索引节点驻留的数据节点关联的键值对已经被删除，则踢除当前节点
  49.                 } else if ((v = n.val) == null) {
  50.                     ConcurrentSkipListMap.unlinkNode(b, n);          // n is deleted
  51.                 // 4）目标键 > 节点键，则往右侧查找
  52.                 } else if ((c = ConcurrentSkipListMap.cpr(cmp, key, k)) > 0) {
  53.                     b = n;
  54.                 // 5）找到目标节点，则直接返回
  55.                 } else if (c == 0) {
  56.                     return n;
  57.                 } else {
  58.                     break outer;
  59.                 }
  60.             }
  61.         }
  62.         return null;
  63.     }
  65.     /**
  66.      *  删除节点 n
  67.      */
  68.     static <K,V> void unlinkNode(Node<K,V> b, Node<K,V> n) {
  69.         if (b != null && n != null) {
  70.             Node<K,V> f, p;
  71.             for (;;) {
  72.                 if ((f = n.next) != null && f.key == null) {
  73.                     p = f.next;               // already marked
  74.                     break;
  75.                 }
  76.                 // 被删除节点是尾节点
  77.                 else if (ConcurrentSkipListMap.NEXT.compareAndSet(n, f,
  78.                         new Node<>(null, null, f))) {
  79.                     p = f;                    // add marker
  80.                     break;
  81.                 }
  82.             }
  83.             ConcurrentSkipListMap.NEXT.compareAndSet(b, n, p);
  84.         }
  85.     }
  87.     /**
  88.      *  如果目标 key 存在 && 旧值为  oldValue，则替换其值为 value，替换成功返回 true
  89.      */
  90.     @Override
  91.     public boolean replace(K key, V oldValue, V newValue) {
  92.         if (key == null || oldValue == null || newValue == null) {
  93.             throw new NullPointerException();
  94.         }
  95.         for (;;) {
  96.             Node<K,V> n; V v;
  97.             // 节点不存在
  98.             if ((n = findNode(key)) == null) {
  99.                 return false;
  100.             }
  101.             if ((v = n.val) != null) {
  102.                 // 节点值和 oldValue 不相等
  103.                 if (!oldValue.equals(v)) {
  104.                     return false;
  105.                 }
  106.                 // 原子更新旧值
  107.                 if (ConcurrentSkipListMap.VAL.compareAndSet(n, v, newValue)) {
  108.                     return true;
  109.                 }
  110.             }
  111.         }
  112.     }

删除键值对

  1.     /**
  2.      *  如果指定的 key 存在，则删除键值对，并返回旧值；否则返回 null
  3.      */
  4.     @Override
  5.     public V remove(Object key) {
  6.         return doRemove(key, null);
  7.     }
  9.     /**
  10.      *  定位节点，将其值置为 null，在其后添加一个删除标记节点，断开前置节点，
  11.      *  移除关联的索引节点，并尝试递减层级。
  12.      */
  13.     final V doRemove(Object key, Object value) {
  14.         if (key == null) {
  15.             throw new NullPointerException();
  16.         }
  17.         final Comparator<? super K> cmp = comparator;
  18.         V result = null;
  19.         Node<K,V> b;
  20.         outer: while ((b = findPredecessor(key, cmp)) != null &&
  21.                 result == null) {
  22.             for (;;) {
  23.                 Node<K,V> n; K k; V v; int c;
  24.                 // 1）无后继节点
  25.                 if ((n = b.next) == null) {
  26.                     break outer;
  27.                 // 2）当前节点是一个删除标记节点
  28.                 } else if ((k = n.key) == null) {
  29.                     break;
  30.                 // 3）当前节点的数据节点被删除，则将其踢除
  31.                 } else if ((v = n.val) == null) {
  32.                     ConcurrentSkipListMap.unlinkNode(b, n);
  33.                 // 4）目标键 > 节点键，则往右侧查找
  34.                 } else if ((c = ConcurrentSkipListMap.cpr(cmp, key, k)) > 0) {
  35.                     b = n;
  36.                 // 5）无匹配键，则直接返回
  37.                 } else if (c < 0) {
  38.                     break outer;
  39.                 // 6）如果值匹配，则删除的场景
  40.                 } else if (value != null && !value.equals(v)) {
  41.                     break outer;
  42.                 // 7）将节点值置为 null
  43.                 } else if (ConcurrentSkipListMap.VAL.compareAndSet(n, v, null)) {
  44.                     // 读取旧值
  45.                     result = v;
  46.                     // 踢除节点
  47.                     ConcurrentSkipListMap.unlinkNode(b, n);
  48.                     break; // loop to clean up
  49.                 }
  50.             }
  51.         }
  52.         if (result != null) {
  53.             // 尝试递减层级
  54.             tryReduceLevel();
  55.             addCount(-1L);
  56.         }
  57.         return result;
  58.     }
  60.     /**
  61.      *  如果指定的 key 存在 && 键关联的值和 value 相等，则删除键值对，并返回 true。
  62.      */
  63.     @Override
  64.     public boolean remove(Object key, Object value) {
  65.         if (key == null) {
  66.             throw new NullPointerException();
  67.         }
  68.         return value != null && doRemove(key, value) != null;
  69.     }

ConcurrentSkipListMap 源码分析的更多相关文章

  1. 【死磕 Java 集合】— ConcurrentSkipListMap源码分析

    转自:http://cmsblogs.com/?p=4773 [隐藏目录] 前情提要 简介 存储结构 源码分析 主要内部类 构造方法 添加元素 添加元素举例 删除元素 删除元素举例 查找元素 查找元素 ...

  2. 死磕 java集合之ConcurrentSkipListMap源码分析——发现个bug

    前情提要 点击链接查看"跳表"详细介绍. 拜托,面试别再问我跳表了! 简介 跳表是一个随机化的数据结构,实质就是一种可以进行二分查找的有序链表. 跳表在原有的有序链表上面增加了多级 ...

  3. 【JUC】JDK1.8源码分析之ConcurrentSkipListMap（二）

    一.前言 最近在做项目的同时也在修复之前项目的一些Bug,所以忙得没有时间看源代码,今天都完成得差不多了,所以又开始源码分析之路,也着笔记录下ConcurrentSkipListMap的源码的分析过程 ...

  4. 【JUC】JDK1.8源码分析之ConcurrentSkipListSet（八）

    一.前言 分析完了CopyOnWriteArraySet后,继续分析Set集合在JUC框架下的另一个集合,ConcurrentSkipListSet,ConcurrentSkipListSet一个基于 ...

  5. 死磕 java集合之ConcurrentSkipListSet源码分析——Set大汇总

    问题 (1)ConcurrentSkipListSet的底层是ConcurrentSkipListMap吗? (2)ConcurrentSkipListSet是线程安全的吗? (3)Concurren ...

  6. 死磕 java集合之CopyOnWriteArraySet源码分析——内含巧妙设计

    问题 (1)CopyOnWriteArraySet是用Map实现的吗? (2)CopyOnWriteArraySet是有序的吗? (3)CopyOnWriteArraySet是并发安全的吗? (4)C ...

  7. 并发-ConcurrentHashMap源码分析

    ConcurrentHashMap 参考: http://www.cnblogs.com/chengxiao/p/6842045.html https://my.oschina.net/hosee/b ...

  8. 4. SOFAJRaft源码分析— RheaKV初始化做了什么？

    前言 由于RheaKV要讲起来篇幅比较长,所以这里分成几个章节来讲,这一章讲一讲RheaKV初始化做了什么? 我们先来给个例子,我们从例子来讲: public static void main(fin ...

  9. JUC源码分析-集合篇：并发类容器介绍

    JUC源码分析-集合篇:并发类容器介绍 同步类容器是 线程安全 的,如 Vector.HashTable 等容器的同步功能都是由 Collections.synchronizedMap 等工厂方法去创 ...

随机推荐

  1. Spring如何读取xml配置文件的

    我们通过一个小案例来看xml解析过程. 1. 导包 <dependencies> <!-- xml解析工具 --> <dependency> <groupId ...

  2. Scala学习笔记(6)对象

    1.单例对象.Scala没有静态方法或字段,可以使用object这个语法结构来达到同样的目的.对象定义了单个实例,包含了你想要的特性. object Accounts{ def newUniqueNu ...

  3. myeclipse2014下卸载，安装maven插件。

    转自:https://blog.csdn.net/gaoshang10/article/details/21177893 一.卸载方法: 点击Help->About Myeclipse Ente ...

  4. vue-cli proxyTable中跨域中pathRewrite 解释

      问:proxyTable 里面的pathRewrite里面的‘^/iclient’:'' 什么意思? 答:用代理, 首先你得有一个标识, 告诉他你这个连接要用代理. 不然的话, 可能你的 html ...

  5. Ubuntu16.04 php7.1安装redis扩展

    sudo apt install php7.1-redis //修改php配置 vi /etc/php.ini 添加extension=redis.so

  6. springboot之学习搭建

    什么是**SpringBoot?** Spring Boot 是由 Pivotal 团队提供的全新框架,其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程.该框架使用了特定的方式来进行配 ...

  7. Python3 获取当前文件名

    #__author: mac#date: 2018/12/16 import osimport sys print(__file__)print(sys.argv[0])print(os.path.d ...

  8. Codeforces 957 水位标记思维题

    A #include <bits/stdc++.h> #define PI acos(-1.0) #define mem(a,b) memset((a),b,sizeof(a)) #def ...

  9. hdu 1059 Dividing bitset 多重背包

    bitset做法 #include <bits/stdc++.h> #define PI acos(-1.0) #define mem(a,b) memset((a),b,sizeof(a ...

  10. 10年前文章_eclipse下perl环境搭建

    eclipse下perl环境搭建1．Eclipse下安装perl插件Help -Software Updates…- Available .- Add Site… :http://e-p-i-c ...