Disclaimer: This article is a blogger original article, shall not be reproduced without the bloggers allowed. https://blog.csdn.net/nimasike/article/details/91432574
class UnpaddedInternalThreadLocalMap {
//ThreadLocal内部封装slowThreadLocalMap
static final ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap = new ThreadLocal<InternalThreadLocalMap>();
//计数器
static final AtomicInteger nextIndex = new AtomicInteger();
/** Used by {@link FastThreadLocal} */
Object[] indexedVariables;
//成员变量
// Core thread-locals
int futureListenerStackDepth;
int localChannelReaderStackDepth;
Map<Class<?>, Boolean> handlerSharableCache;
IntegerHolder counterHashCode;
ThreadLocalRandom random;
Map<Class<?>, TypeParameterMatcher> typeParameterMatcherGetCache;
Map<Class<?>, Map<String, TypeParameterMatcher>> typeParameterMatcherFindCache;
// String-related thread-locals
StringBuilder stringBuilder;
Map<Charset, CharsetEncoder> charsetEncoderCache;
Map<Charset, CharsetDecoder> charsetDecoderCache;
// ArrayList-related thread-locals
ArrayList<Object> arrayList;
UnpaddedInternalThreadLocalMap(Object[] indexedVariables) {
this.indexedVariables = indexedVariables;
}
}
//集成了UnpaddedInternalThreadLocalMap
//内部包含了一个静态的threadlocal类slowThreadLocalMap和一些数据结构
public final class InternalThreadLocalMap extends UnpaddedInternalThreadLocalMap {
private static final InternalLogger logger = InternalLoggerFactory.getInstance(InternalThreadLocalMap.class);
private static final int DEFAULT_ARRAY_LIST_INITIAL_CAPACITY = 8;
private static final int STRING_BUILDER_INITIAL_SIZE;
private static final int STRING_BUILDER_MAX_SIZE;
public static final Object UNSET = new Object();
private BitSet cleanerFlags;
static {
STRING_BUILDER_INITIAL_SIZE =
SystemPropertyUtil.getInt("io.netty.threadLocalMap.stringBuilder.initialSize", 1024);
logger.debug("-Dio.netty.threadLocalMap.stringBuilder.initialSize: {}", STRING_BUILDER_INITIAL_SIZE);
STRING_BUILDER_MAX_SIZE = SystemPropertyUtil.getInt("io.netty.threadLocalMap.stringBuilder.maxSize", 1024 * 4);
logger.debug("-Dio.netty.threadLocalMap.stringBuilder.maxSize: {}", STRING_BUILDER_MAX_SIZE);
}
//如果设置了就获取否则返回null
public static InternalThreadLocalMap getIfSet() {
//拿到当前线程
Thread thread = Thread.currentThread();
//如果是FastThreadLocalThread类型，则直接获取InternalThreadLocalMap对象
if (thread instanceof FastThreadLocalThread) {
return ((FastThreadLocalThread) thread).threadLocalMap();
}
//否则上ThreadLocal获取
return slowThreadLocalMap.get();
}
//获取InternalThreadLocalMap对象，没有就创建一个
public static InternalThreadLocalMap get() {
Thread thread = Thread.currentThread();
if (thread instanceof FastThreadLocalThread) {
return fastGet((FastThreadLocalThread) thread);
} else {
return slowGet();
}
}
private static InternalThreadLocalMap fastGet(FastThreadLocalThread thread) {
//获取线程的成员变量threadLocalMap();
InternalThreadLocalMap threadLocalMap = thread.threadLocalMap();
//如果为空则创建一个新的设置到线程当中
if (threadLocalMap == null) {
thread.setThreadLocalMap(threadLocalMap = new InternalThreadLocalMap());
}
return threadLocalMap;
}
private static InternalThreadLocalMap slowGet() {
//在ThreadLocal当中获取InternalThreadLocalMap对象
ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap = UnpaddedInternalThreadLocalMap.slowThreadLocalMap;
InternalThreadLocalMap ret = slowThreadLocalMap.get();
//如果为null则创建一个新的设置到ThreadLocal当中并返回
if (ret == null) {
ret = new InternalThreadLocalMap();
slowThreadLocalMap.set(ret);
}
return ret;
}
//移除InternalThreadLocalMap
public static void remove() {
//获取当前线程
Thread thread = Thread.currentThread();
//如果是FastThreadLocalThread类型则直接把成员变量设置为null
if (thread instanceof FastThreadLocalThread) {
((FastThreadLocalThread) thread).setThreadLocalMap(null);
} else {
//在ThreadLocal当中移除
slowThreadLocalMap.remove();
}
}
//在ThreadLocal当中移除
public static void destroy() {
slowThreadLocalMap.remove();
}
//计数器++
public static int nextVariableIndex() {
int index = nextIndex.getAndIncrement();
//如果为负数说明已经++到Int的最大值
if (index < 0) {
//计数器-- 后抛出异常
nextIndex.decrementAndGet();
throw new IllegalStateException("too many thread-local indexed variables");
}
return index;
}
//获取最后一个变量的index
public static int lastVariableIndex() {
return nextIndex.get() - 1;
}
// Cache line padding (must be public)
// With CompressedOops enabled, an instance of this class should occupy at least 128 bytes.
public long rp1, rp2, rp3, rp4, rp5, rp6, rp7, rp8, rp9;
//构造参数 传入32个长度的数组里面全部都是相同的object引用
private InternalThreadLocalMap() {
super(newIndexedVariableTable());
}
//创建一个32长队数组，里面全部引用一个相同的object对象
private static Object[] newIndexedVariableTable() {
Object[] array = new Object[32];
Arrays.fill(array, UNSET);
return array;
}
//统计数量
public int size() {
int count = 0;
if (futureListenerStackDepth != 0) {
count ++;
}
if (localChannelReaderStackDepth != 0) {
count ++;
}
if (handlerSharableCache != null) {
count ++;
}
if (counterHashCode != null) {
count ++;
}
if (random != null) {
count ++;
}
if (typeParameterMatcherGetCache != null) {
count ++;
}
if (typeParameterMatcherFindCache != null) {
count ++;
}
if (stringBuilder != null) {
count ++;
}
if (charsetEncoderCache != null) {
count ++;
}
if (charsetDecoderCache != null) {
count ++;
}
if (arrayList != null) {
count ++;
}
for (Object o: indexedVariables) {
if (o != UNSET) {
count ++;
}
}
// We should subtract 1 from the count because the first element in 'indexedVariables' is reserved
// by 'FastThreadLocal' to keep the list of 'FastThreadLocal's to remove on 'FastThreadLocal.removeAll()'.
return count - 1;
}
//返回StringBuilder
public StringBuilder stringBuilder() {
StringBuilder sb = stringBuilder;
if (sb == null) {
//没有则新创建一个返回 STRING_BUILDER_INITIAL_SIZE=初始容量
return stringBuilder = new StringBuilder(STRING_BUILDER_INITIAL_SIZE);
}
//如果之前存在sb， 则判断容量是否 大于 STRING_BUILDER_MAX_SIZE
if (sb.capacity() > STRING_BUILDER_MAX_SIZE) {
//长度设置为初始容量
sb.setLength(STRING_BUILDER_INITIAL_SIZE);
sb.trimToSize();
}
//把长度设置为0，相当于清空sb
sb.setLength(0);
return sb;
}
//返回Map<Charset, CharsetEncoder>没有则创建
public Map<Charset, CharsetEncoder> charsetEncoderCache() {
Map<Charset, CharsetEncoder> cache = charsetEncoderCache;
if (cache == null) {
charsetEncoderCache = cache = new IdentityHashMap<Charset, CharsetEncoder>();
}
return cache;
}
//返回Map<Charset, CharsetDecoder>没有则创建
public Map<Charset, CharsetDecoder> charsetDecoderCache() {
Map<Charset, CharsetDecoder> cache = charsetDecoderCache;
if (cache == null) {
charsetDecoderCache = cache = new IdentityHashMap<Charset, CharsetDecoder>();
}
return cache;
}
public <E> ArrayList<E> arrayList() {
return arrayList(DEFAULT_ARRAY_LIST_INITIAL_CAPACITY);
}
//返回一个minCapacity大小的list
@SuppressWarnings("unchecked")
public <E> ArrayList<E> arrayList(int minCapacity) {
ArrayList<E> list = (ArrayList<E>) arrayList;
if (list == null) {
arrayList = new ArrayList<Object>(minCapacity);
return (ArrayList<E>) arrayList;
}
list.clear();
list.ensureCapacity(minCapacity);
return list;
}
public int futureListenerStackDepth() {
return futureListenerStackDepth;
}
public void setFutureListenerStackDepth(int futureListenerStackDepth) {
this.futureListenerStackDepth = futureListenerStackDepth;
}
//获得线程的Random对象
public ThreadLocalRandom random() {
ThreadLocalRandom r = random;
if (r == null) {
random = r = new ThreadLocalRandom();
}
return r;
}
public Map<Class<?>, TypeParameterMatcher> typeParameterMatcherGetCache() {
Map<Class<?>, TypeParameterMatcher> cache = typeParameterMatcherGetCache;
if (cache == null) {
typeParameterMatcherGetCache = cache = new IdentityHashMap<Class<?>, TypeParameterMatcher>();
}
return cache;
}
public Map<Class<?>, Map<String, TypeParameterMatcher>> typeParameterMatcherFindCache() {
Map<Class<?>, Map<String, TypeParameterMatcher>> cache = typeParameterMatcherFindCache;
if (cache == null) {
typeParameterMatcherFindCache = cache = new IdentityHashMap<Class<?>, Map<String, TypeParameterMatcher>>();
}
return cache;
}
public IntegerHolder counterHashCode() {
return counterHashCode;
}
public void setCounterHashCode(IntegerHolder counterHashCode) {
this.counterHashCode = counterHashCode;
}
public Map<Class<?>, Boolean> handlerSharableCache() {
Map<Class<?>, Boolean> cache = handlerSharableCache;
if (cache == null) {
// Start with small capacity to keep memory overhead as low as possible.
handlerSharableCache = cache = new WeakHashMap<Class<?>, Boolean>(4);
}
return cache;
}
public int localChannelReaderStackDepth() {
return localChannelReaderStackDepth;
}
public void setLocalChannelReaderStackDepth(int localChannelReaderStackDepth) {
this.localChannelReaderStackDepth = localChannelReaderStackDepth;
}
public Object indexedVariable(int index) {
Object[] lookup = indexedVariables;
return index < lookup.length? lookup[index] : UNSET;
}
/**
* @return {@code true} if and only if a new thread-local variable has been created
*/
//存储对象
public boolean setIndexedVariable(int index, Object value) {
//对象数组
Object[] lookup = indexedVariables;
//判断下标小于数组长度
if (index < lookup.length) {
//拿出旧值
Object oldValue = lookup[index];
//设置新值
lookup[index] = value;
//判断oldValue == UNSET第一次设置
return oldValue == UNSET;
} else {
//下标大于数组长度需要扩容
expandIndexedVariableTableAndSet(index, value);
return true;
}
}
private void expandIndexedVariableTableAndSet(int index, Object value) {
Object[] oldArray = indexedVariables;
//旧数组长度
final int oldCapacity = oldArray.length;
//根据index扩容
int newCapacity = index;
newCapacity |= newCapacity >>> 1;
newCapacity |= newCapacity >>> 2;
newCapacity |= newCapacity >>> 4;
newCapacity |= newCapacity >>> 8;
newCapacity |= newCapacity >>> 16;
newCapacity ++;
//把旧数组拷贝到新数组
Object[] newArray = Arrays.copyOf(oldArray, newCapacity);
//其余位置全部设置为UNSET
Arrays.fill(newArray, oldCapacity, newArray.length, UNSET);
//设置值
newArray[index] = value;
//更新成员变量
indexedVariables = newArray;
}
//移除对象
public Object removeIndexedVariable(int index) {
Object[] lookup = indexedVariables;
if (index < lookup.length) {
Object v = lookup[index];
lookup[index] = UNSET;
return v;
} else {
return UNSET;
}
}
public boolean isIndexedVariableSet(int index) {
Object[] lookup = indexedVariables;
return index < lookup.length && lookup[index] != UNSET;
}
public boolean isCleanerFlagSet(int index) {
return cleanerFlags != null && cleanerFlags.get(index);
}
public void setCleanerFlag(int index) {
if (cleanerFlags == null) {
cleanerFlags = new BitSet();
}
cleanerFlags.set(index);
}
}