forked from plusone/plusone-commons
122 lines
4.7 KiB
Java
122 lines
4.7 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.base.JRE;
|
||
import xyz.zhouxy.plusone.commons.util.ConcurrentHashMapUtil;
|
||
|
||
/**
|
||
* SafeConcurrentHashMap
|
||
*
|
||
* <p>
|
||
* Java 8 的 {@link ConcurrentHashMap#computeIfAbsent(Object, Function)} 方法有 bug，
|
||
* 使用 Java 8 时，可使用这个类进行替换。
|
||
*
|
||
* @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a>
|
||
* @since 1.0
|
||
* @see ConcurrentHashMap
|
||
* @see ConcurrentHashMapUtil#computeIfAbsentForJava8(ConcurrentHashMap, Object, Function)
|
||
*/
|
||
@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 JRE.isJava8()
|
||
? ConcurrentHashMapUtil.computeIfAbsentForJava8(this, key, mappingFunction)
|
||
: super.computeIfAbsent(key, mappingFunction);
|
||
}
|
||
}
|