聊聊Elasticsearch的ConcurrentMapLong

摘要：序本文主要研究一下的继承了接口，并指定类型为实现了接口，它内部使用实现提供了及两个静态方法用于创建其中方法创建为，为，为的小结继承了接口，并指定类型为实现了接口，它内部使用实现提供了及两个静态方法用于创建其中方法创建为，为，为的

本文主要研究一下Elasticsearch的ConcurrentMapLong

elasticsearch-7.0.1/server/src/main/java/org/elasticsearch/common/util/concurrent/ConcurrentMapLong.java

public interface ConcurrentMapLong extends ConcurrentMap {

    T get(long key);

    T remove(long key);

    T put(long key, T value);

    T putIfAbsent(long key, T value);
}

ConcurrentMapLong继承了ConcurrentMap接口，并指定key类型为Long

elasticsearch-7.0.1/server/src/main/java/org/elasticsearch/common/util/concurrent/ConcurrentHashMapLong.java

public class ConcurrentHashMapLong implements ConcurrentMapLong {

    private final ConcurrentMap map;

    public ConcurrentHashMapLong(ConcurrentMap map) {
        this.map = map;
    }

    @Override
    public T get(long key) {
        return map.get(key);
    }

    @Override
    public T remove(long key) {
        return map.remove(key);
    }

    @Override
    public T put(long key, T value) {
        return map.put(key, value);
    }

    @Override
    public T putIfAbsent(long key, T value) {
        return map.putIfAbsent(key, value);
    }

    // MAP DELEGATION

    @Override
    public boolean isEmpty() {
        return map.isEmpty();
    }

    @Override
    public int size() {
        return map.size();
    }

    @Override
    public T get(Object key) {
        return map.get(key);
    }

    @Override
    public boolean containsKey(Object key) {
        return map.containsKey(key);
    }

    @Override
    public boolean containsValue(Object value) {
        return map.containsValue(value);
    }

    @Override
    public T put(Long key, T value) {
        return map.put(key, value);
    }

    @Override
    public T putIfAbsent(Long key, T value) {
        return map.putIfAbsent(key, value);
    }

    @Override
    public void putAll(Map m) {
        map.putAll(m);
    }

    @Override
    public T remove(Object key) {
        return map.remove(key);
    }

    @Override
    public boolean remove(Object key, Object value) {
        return map.remove(key, value);
    }

    @Override
    public boolean replace(Long key, T oldValue, T newValue) {
        return map.replace(key, oldValue, newValue);
    }

    @Override
    public T replace(Long key, T value) {
        return map.replace(key, value);
    }

    @Override
    public void clear() {
        map.clear();
    }

    @Override
    public Set keySet() {
        return map.keySet();
    }

    @Override
    public Collection values() {
        return map.values();
    }

    @Override
    public Set> entrySet() {
        return map.entrySet();
    }

    @Override
    public boolean equals(Object o) {
        return map.equals(o);
    }

    @Override
    public int hashCode() {
        return map.hashCode();
    }

    @Override
    public String toString() {
        return map.toString();
    }
}

ConcurrentHashMapLong实现了ConcurrentMapLong接口，它内部使用ConcurrentMap实现

elasticsearch-7.0.1/server/src/main/java/org/elasticsearch/common/util/concurrent/ConcurrentCollections.java

public abstract class ConcurrentCollections {

    static final int aggressiveConcurrencyLevel;

    static {
        aggressiveConcurrencyLevel = Math.max(Runtime.getRuntime().availableProcessors() * 2, 16);
    }

    //......

    public static  ConcurrentMap newConcurrentMap() {
        return new ConcurrentHashMap<>();
    }

    public static  ConcurrentMapLong newConcurrentMapLong() {
        return new ConcurrentHashMapLong<>(ConcurrentCollections.newConcurrentMap());
    }

    public static  ConcurrentMapLong newConcurrentMapLongWithAggressiveConcurrency() {
        return new ConcurrentHashMapLong<>(ConcurrentCollections.newConcurrentMapWithAggressiveConcurrency());
    }

    public static  ConcurrentMap newConcurrentMapWithAggressiveConcurrency() {
        return newConcurrentMapWithAggressiveConcurrency(16);
    }

    public static  ConcurrentMap newConcurrentMapWithAggressiveConcurrency(int initalCapacity) {
        return new ConcurrentHashMap<>(initalCapacity, 0.75f, aggressiveConcurrencyLevel);
    }    
    //......
}

ConcurrentCollections提供了newConcurrentMapLong及newConcurrentMapLongWithAggressiveConcurrency两个静态方法用于创建ConcurrentMapLong；其中newConcurrentMapLongWithAggressiveConcurrency方法创建initalCapacity为16，loadFactor为0.75f，concurrencyLevel为aggressiveConcurrencyLevel(Math.max(Runtime.getRuntime().availableProcessors() * 2, 16))的ConcurrentHashMap

ConcurrentMapLong继承了ConcurrentMap接口，并指定key类型为Long

ConcurrentHashMapLong实现了ConcurrentMapLong接口，它内部使用ConcurrentMap实现

ConcurrentCollections提供了newConcurrentMapLong及newConcurrentMapLongWithAggressiveConcurrency两个静态方法用于创建ConcurrentMapLong；其中newConcurrentMapLongWithAggressiveConcurrency方法创建initalCapacity为16，loadFactor为0.75f，concurrencyLevel为aggressiveConcurrencyLevel(Math.max(Runtime.getRuntime().availableProcessors() * 2, 16))的ConcurrentHashMap

ConcurrentMapLong

ConcurrentHashMapLong

ConcurrentCollections