ConcurrentSkipListSet - 秒懂

• 瘋狂創客圈 經典圖書 ： 《Netty Zookeeper Redis 高併發實戰》 面試必備 + 面試必備 + 面試必備 【博客園總入口 】

• 瘋狂創客圈 經典圖書 ： 《SpringCloud、Nginx高併發核心編程》 大廠必備 + 大廠必備 + 大廠必備 【博客園總入口 】

• 入大廠+漲工資必備： 高併發【 億級流量IM實戰】 實戰系列 【 SpringCloud Nginx秒殺】 實戰系列 【博客園總入口 】

---

說明：閱讀本文以前，請先掌握本文前置知識： 跳錶 核心原理 圖解，以及ConcurrentSkipListMap - 秒懂。

JUC 高併發工具類（3文章）與高併發容器類（N文章） ：

• 1 CyclicBarrier 使用&核心原理 圖解
• 2 countDownLatch 使用&核心原理 圖解
• 3 Semaphore 使用&核心原理 圖解
• 4 跳錶 核心原理 圖解
• 5 ConcurrentSkipListMap - 秒懂
• 6 ConcurrentSkipListSet - 秒懂

---

1 ConcurrentSkipListSet簡介

ConcurrentSkipListSet，是J.U.C新增的一個集合工具類，顧名思義，它是一種SET類型。

SET類型，在數學上稱爲「集合」，具備互異性、無序性的特色，也就是說SET中的任意兩個元素均不相同（即不包含重複元素），且元素是無序的。

JDK提供的默認SET實現——HashSet，其實就是採用「組合」的方式——內部引用了一個HashMap對象，以此實現SET的功能。

ConcurrentSkipListSet與ConcurrentSkipListMap的關係，與SET與HashMap的關係相似，就是採用「組合」的方式: ConcurrentSkipListSet組合了一個ConcurrentSkipListMap，將元素做爲 ConcurrentSkipListMap的key存放。

2 ConcurrentSkipListSet原理

2.1 ConcurrentSkipListSet的類繼承圖

咱們來看下ConcurrentSkipListSet的類繼承圖：

2.2 內部結構

ConcurrentSkipListSet的數據結構，以下圖所示：

說明：

(01) ConcurrentSkipListSet繼承於AbstractSet。所以，它本質上是一個集合。

(02) ConcurrentSkipListSet實現了NavigableSet接口。所以，ConcurrentSkipListSet是一個有序的集合。

(03) ConcurrentSkipListSet是經過組合ConcurrentSkipListMap實現的。它包含一個ConcurrentNavigableMap對象m，而m對象其實是ConcurrentNavigableMap的實現類ConcurrentSkipListMap的實例。ConcurrentSkipListMap中的元素是key-value鍵值對；而ConcurrentSkipListSet是集合，它只用到了ConcurrentSkipListMap中的key！

2.3 構造器

ConcurrentSkipListSet的實現很是簡單，其內部引用了一個ConcurrentSkipListMap對象，全部API方法均委託ConcurrentSkipListMap對象完成：

public class ConcurrentSkipListSet<E> extends AbstractSet<E>
    implements NavigableSet<E>, Cloneable, java.io.Serializable {

    /**
     * The underlying map. Uses Boolean.TRUE as value for each
     * element.  This field is declared final for the sake of thread
     * safety, which entails some ugliness in clone().
     */
    private final ConcurrentNavigableMap<E, Object> m;

    public ConcurrentSkipListSet() {
        m = new ConcurrentSkipListMap<E, Object>();
    }

    public ConcurrentSkipListSet(Comparator<? super E> comparator) {
        m = new ConcurrentSkipListMap<E, Object>(comparator);
    }

    public ConcurrentSkipListSet(Collection<? extends E> c) {
        m = new ConcurrentSkipListMap<E, Object>();
        addAll(c);
    }

    public ConcurrentSkipListSet(SortedSet<E> s) {
        m = new ConcurrentSkipListMap<E, Object>(s.comparator());
        addAll(s);
    }

    ConcurrentSkipListSet(ConcurrentNavigableMap<E, Object> m) {
        this.m = m;
    }
    
    // ...
}

從上述代碼能夠看出，ConcurrentSkipListSet在構造時建立了一個ConcurrentSkipListMap對象，並由字段m引用，因此其實ConcurrentSkipListSet就是一種跳錶類型的數據結構，其平均增刪改查的時間複雜度均爲O(logn)。

2.4 核心方法

咱們來看下ConcurrentSkipListSet是如何實現API方法的：

public int size() {
    return m.size();
}

public boolean isEmpty() {
    return m.isEmpty();
}

public boolean contains(Object o) {
    return m.containsKey(o);
}


public boolean add(E e) {
    return m.putIfAbsent(e, Boolean.TRUE) == null;
}

public boolean remove(Object o) {
    return m.remove(o, Boolean.TRUE);
}

public void clear() {
    m.clear();
}
 
//...

從上述代碼能夠看出，全部操做均是委託ConcurrentSkipListMap對象完成的。重點看下add方法：

public boolean add(E e) {

​ return m.putIfAbsent(e, Boolean.TRUE) == null;

}

ConcurrentSkipListMap對鍵值對的要求是均不能爲null，因此ConcurrentSkipListSet在插入元素的時候，用一個Boolean.TRUE對象（至關於一個值爲true的Boolean型對象）做爲value，同時putIfAbsent能夠保證不會存在相同的Key。

因此，最終跳錶中的全部Node結點的Key均不會相同，且值都是Boolean.True。

3 ConcurrentSkipListSet適用場景

ConcurrentSkipListSet是線程安全的有序的集合，適用於高併發的場景。

ConcurrentSkipListSet和TreeSet

ConcurrentSkipListSet和TreeSet，它們雖然都是有序的集合。可是，第一，它們的線程安全機制不一樣，TreeSet是非線程安全的，而ConcurrentSkipListSet是線程安全的。第二，ConcurrentSkipListSet是經過ConcurrentSkipListMap實現的，而TreeSet是經過TreeMap實現的。

4 使用例子

import java.util.*;
import java.util.concurrent.*;

/*
 *   ConcurrentSkipListSet是「線程安全」的集合，而TreeSet是非線程安全的。
 *
 *   下面是「多個線程同時操做而且遍歷集合set」的示例
 *   (01) 當set是ConcurrentSkipListSet對象時，程序能正常運行。
 *   (02) 當set是TreeSet對象時，程序會產生ConcurrentModificationException異常。
 *
 * @author skywang
 */
public class ConcurrentSkipListSetDemo1 {

    // TODO: set是TreeSet對象時，程序會出錯。
    //private static Set<String> set = new TreeSet<String>();
    private static Set<String> set = new ConcurrentSkipListSet<String>();
    public static void main(String[] args) {

        // 同時啓動兩個線程對set進行操做！
        new MyThread("a").start();
        new MyThread("b").start();
    }

    private static void printAll() {
        String value = null;
        Iterator iter = set.iterator();
        while(iter.hasNext()) {
            value = (String)iter.next();
            System.out.print(value+", ");
        }
        System.out.println();
    }

    private static class MyThread extends Thread {
        MyThread(String name) {
            super(name);
        }
        @Override
        public void run() {
                int i = 0;
            while (i++ < 10) {
                // 「線程名」 + "序號"
                String val = Thread.currentThread().getName() + (i%6);
                set.add(val);
                // 經過「Iterator」遍歷set。
                printAll();
            }
        }
    }
}

運行程序，結果以下：

a1, b1, 
a1, a1, a2, b1, 
b1, a1, a2, a3, b1,

a1, a2, a3, a1, a4, b1, b2, 
a2, a1, a2, a3, a4, a5, b1, b2, 
a3, a0, a4, a5, a1, b1, a2, b2, 
a3, a0, a4, a1, a5, a2, b1, a3, b2, a4, b3, 
a5, a0, b1, a1, b2, a2, b3, 
a3, a0, a4, a1, a5, a2, b1, a3, b2, a4, b3, a5, b4, 
b1, a0, b2, a1, b3, a2, b4, 
a3, a0, a4, a1, a5, a2, b1, a3, b2, a4, b3, a5, b4, b1, b5, 
b2, a0, a1, a2, a3, a4, a5, b3, b1, b4, b2, b5, 
b3, a0, b4, a1, b5, 
a2, a0, a3, a1, a4, a2, a5, a3, b0, a4, b1, a5, b2, b0, b3, b1, b4, b2, b5, b3, 
b4, a0, b5, 
a1, a2, a3, a4, a5, b0, b1, b2, b3, b4, b5, 
a0, a1, a2, a3, a4, a5, b0, b1, b2, b3, b4, b5, 
a0, a1, a2, a3, a4, a5, b0, b1, b2, b3, b4, b5, 
a0, a1, a2, a3, a4, a5, b0, b1, b2, b3, b4, b5,

---

回到◀瘋狂創客圈▶

瘋狂創客圈 - Java高併發研習社羣，爲你們開啓大廠之門