forked from plusone/plusone-commons
108 lines
4.2 KiB
Java
108 lines
4.2 KiB
Java
/*
|
|
* Copyright 2022-2023 the original author or authors.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* https://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package xyz.zhouxy.plusone.commons.collection;
|
|
|
|
import java.util.Map;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.function.Function;
|
|
|
|
import javax.annotation.concurrent.ThreadSafe;
|
|
|
|
import xyz.zhouxy.plusone.commons.util.ConcurrentHashMapUtil;
|
|
|
|
// TODO 添加文档注释
|
|
@ThreadSafe
|
|
public class SafeConcurrentHashMap<K, V> extends ConcurrentHashMap<K, V> {
|
|
|
|
private static final long serialVersionUID = 4352954948768449595L;
|
|
|
|
/**
|
|
* Creates a new, empty map with the default initial table size (16).
|
|
*/
|
|
public SafeConcurrentHashMap() {
|
|
}
|
|
|
|
/**
|
|
* Creates a new, empty map with an initial table size
|
|
* accommodating the specified number of elements without the need
|
|
* to dynamically resize.
|
|
*
|
|
* @param initialCapacity The implementation performs internal
|
|
* sizing to accommodate this many elements.
|
|
* @throws IllegalArgumentException if the initial capacity of
|
|
* elements is negative
|
|
*/
|
|
public SafeConcurrentHashMap(int initialCapacity) {
|
|
super(initialCapacity);
|
|
}
|
|
|
|
/**
|
|
* Creates a new map with the same mappings as the given map.
|
|
*
|
|
* @param m the map
|
|
*/
|
|
public SafeConcurrentHashMap(Map<? extends K, ? extends V> m) {
|
|
super(m);
|
|
}
|
|
|
|
/**
|
|
* Creates a new, empty map with an initial table size based on
|
|
* the given number of elements ({@code initialCapacity}) and
|
|
* initial table density ({@code loadFactor}).
|
|
*
|
|
* @param initialCapacity the initial capacity. The implementation
|
|
* performs internal sizing to accommodate this many elements,
|
|
* given the specified load factor.
|
|
* @param loadFactor the load factor (table density) for
|
|
* establishing the initial table size
|
|
* @throws IllegalArgumentException if the initial capacity of
|
|
* elements is negative or the load factor is nonpositive
|
|
* @since 1.6
|
|
*/
|
|
public SafeConcurrentHashMap(int initialCapacity, float loadFactor) {
|
|
super(initialCapacity, loadFactor);
|
|
}
|
|
|
|
/**
|
|
* Creates a new, empty map with an initial table size based on
|
|
* the given number of elements ({@code initialCapacity}), table
|
|
* density ({@code loadFactor}), and number of concurrently
|
|
* updating threads ({@code concurrencyLevel}).
|
|
*
|
|
* @param initialCapacity the initial capacity. The implementation
|
|
* performs internal sizing to accommodate this many elements,
|
|
* given the specified load factor.
|
|
* @param loadFactor the load factor (table density) for
|
|
* establishing the initial table size
|
|
* @param concurrencyLevel the estimated number of concurrently
|
|
* updating threads. The implementation may use this value as
|
|
* a sizing hint.
|
|
* @throws IllegalArgumentException if the initial capacity is
|
|
* negative or the load factor or concurrencyLevel are
|
|
* nonpositive
|
|
*/
|
|
public SafeConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
|
|
super(initialCapacity, loadFactor, concurrencyLevel);
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
@Override
|
|
public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
|
|
return ConcurrentHashMapUtil.computeIfAbsentForJava8(this, key, mappingFunction);
|
|
}
|
|
}
|