ThreadLocal是一个线程外部的存储类，能够在指定线程内存储数据，数据存储当前，只有指定线程能够失去存储数据，ThreadLocal提供了线程内存储变量的能力，这些变量不同之处在于每一个线程读取的变量是对应的相互独立的。通过get和set办法就能够失去以后线程对应的值，ThreadLocal不是用来解决共享对象的多线程拜访问题的，通过ThreadLocal的set()办法设置到线程的ThreadLocal.ThreadLocalMap里的是是线程本人要存储的对象，其余线程不须要去拜访，也是拜访不到的。各个线程中的ThreadLocal.ThreadLocalMap以及ThreadLocal.ThreadLocal中的值都是不同的对象。
1、每个线程都有一个本人的ThreadLocal.ThreadLocalMap对象
2、每一个ThreadLocal对象都有一个循环计数器
3、ThreadLocal.get()取值，就是依据以后的线程，获取线程中本人的ThreadLocal.ThreadLocalMap，而后在这个Map中依据第二点中循环计数器获得一个特定value值
set
1、先对ThreadLocal外面的threadLocalHashCode取模获取到一个table中的地位
2、这个地位上如果有数据，获取这个地位上的ThreadLocal
（1）判断一下地位上的ThreadLocal和我自身这个ThreadLocal是不是一个ThreadLocal，是的话数据就笼罩，返回
（2）不是同一个ThreadLocal，再判断一下地位上的ThreadLocal是是不是空的，这个解释一下。Entry是ThreadLocal弱援用，”static class Entry extends WeakReference<ThreadLocal>”，有可能这个ThreadLocal被垃圾回收了，这时候把新设置的value替换到以后地位上，返回
（3）下面都没有返回，给模加1，看看模加1后的table地位上是不是空的，是空的再加1，判断地位上是不是空的…始终到找到一个table上的地位不是空的为止，往这外面塞一个value。换句话说，当table的地位上有数据的时候，ThreadLocal采取的是方法是找最近的一个空的地位设置数据。
3、如果没有数据，实例化一个新的ThreadLocalMap，并赋值给线程的成员变量threadLocals
/**
* Sets the current thread's copy of this thread-local variable 将此线程局部变量的以后线程正本设置为指定值。 大多数子类将不须要重写此办法，而仅依附{@link #initialValue}办法来设置线程局部变量的值。
* to the specified value. Most subclasses will have no need to
* override this method, relying solely on the {@link #initialValue}
* method to set the values of thread-locals.
*
* @param value the value to be stored in the current thread's copy of @param value要存储在此本地线程的以后线程正本中的值。
* this thread-local.
*/
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
/**
* Create the map associated with a ThreadLocal. Overridden in
* InheritableThreadLocal.
*
* @param t the current thread
* @param firstValue value for the initial entry of the map
*/
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
/**
* Set the value associated with key.
*
* @param key the thread local object
* @param value the value to be set
*/
private void set(ThreadLocal<?> key, Object value) {
// We don't use a fast path as with get() because it is at
// least as common to use set() to create new entries as
// it is to replace existing ones, in which case, a fast
// path would fail more often than not.
Entry[] tab = table;
int len = tab.length;
//对ThreadLocal外面的threadLocalHashCode取模获取到一个table中的地位
int i = key.threadLocalHashCode & (len-1);
//这个地位上如果有数据，获取这个地位上的ThreadLocal
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
//判断一下地位上的ThreadLocal和我自身这个ThreadLocal是不是一个ThreadLocal，是的话数据就笼罩，返回
if (k == key) {
e.value = value;
return;
}
//不是同一个ThreadLocal，再判断一下地位上的ThreadLocal是是不是空的，Entry是ThreadLocal弱援用，"static class Entry extends WeakReference<ThreadLocal>"，有可能这个ThreadLocal被垃圾回收了
if (k == null) {
//设置新的value替换到以后地位上，返回
replaceStaleEntry(key, value, i);
return;
}
}
//下面都没有返回，给模加1，看看模加1后的table地位上是不是空的，是空的再加1，判断地位上是不是空的...始终到找到一个table上的地位不是空的为止，往这外面塞一个value。换句话说，当table的地位上有数据的时候，ThreadLocal采取的 //是方法是找最近的一个空的地位设置数据
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}get
1、获取以后线程
2、尝试去以后线程中拿它的ThreadLocal.ThreadLocalMap
3、以后线程中判断是否有ThreadLocal.ThreadLocalMap
（1）有就尝试依据以后ThreadLocal的threadLocalHashCode取模去table中取值，有就返回，没有就给模加1持续找，这和设置的算法是一样的
（2）没有就调用set办法给以后线程ThreadLocal.ThreadLocalMap设置一个初始值
/**
* Returns the value in the current thread's copy of this 返回此线程局部变量的以后线程正本中的值。 如果该变量没有以后线程的值，则首先将其初始化为调用{@link #initialValue}办法返回的值。
* thread-local variable. If the variable has no value for the
* current thread, it is first initialized to the value returned
* by an invocation of the {@link #initialValue} method.
*
* @return the current thread's value of this thread-local
*/
public T get() {
//获取以后线程
Thread t = Thread.currentThread();
//尝试去以后线程中拿它的ThreadLocal.ThreadLocalMap
ThreadLocalMap map = getMap(t);
//判断以后线程中判断是否有ThreadLocal.ThreadLocalMap
if (map != null) {
//有就尝试依据以后ThreadLocal的threadLocalHashCode取模去table中取值，有就返回，没有就给模加1持续找
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//没有就调用set办法给以后线程ThreadLocal.ThreadLocalMap设置一个初始值
return setInitialValue();
}
/**
* Get the entry associated with key. This method
* itself handles only the fast path: a direct hit of existing
* key. It otherwise relays to getEntryAfterMiss. This is
* designed to maximize performance for direct hits, in part
* by making this method readily inlinable.
*
* @param key the thread local object
* @return the entry associated with key, or null if no such
*/
private Entry getEntry(ThreadLocal<?> key) {
//依据以后ThreadLocal的threadLocalHashCode取模去table中取值
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
//有就返回，没有就给模加1持续找
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}remove
/**
* Removes the current thread's value for this thread-local 删除此线程局部变量的以后线程值。 如果此线程局部变量随后被以后线程{@linkplain #get read}调用，则其值将通过调用其{@link #initialValue}办法来从新初始化，除非
* variable. If this thread-local variable is subsequently 以后值是{@linkplain #set set} 在此期间穿线。 这可能会导致在以后线程中屡次调用{@code initialValue}办法。
* {@linkplain #get read} by the current thread, its value will be
* reinitialized by invoking its {@link #initialValue} method,
* unless its value is {@linkplain #set set} by the current thread
* in the interim. This may result in multiple invocations of the
* {@code initialValue} method in the current thread.
*
* @since 1.5
*/
public void remove() {
//获得以后线程的ThreadLocal.ThreadLocalMap，如果有ThreadLocal.ThreadLocalMap，找到对应的Entry，移除掉
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}ThreadLocalMap
实例化ThreadLocalMap时创立了一个长度为16的Entry数组。通过hashCode与length位运算确定出一个索引值i，这个i就是被存储在table数组中的地位，每个线程Thread都持有一个Entry型的数组table，而所有的读取过程都是通过操作这个数组table实现的。
/**
* Construct a new map initially containing (firstKey, firstValue). 结构一个最后蕴含（firstKey，firstValue）的Map。 ThreadLocalMaps是提早结构的，因而只有在至多有一个条目要搁置时才创立一个。
* ThreadLocalMaps are constructed lazily, so we only create
* one when we have at least one entry to put in it.
*/
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//长度为16的Entry数组
table = new Entry[INITIAL_CAPACITY];
//被存储在table数组中的地位
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
//设置长度
setThreshold(INITIAL_CAPACITY);
}
/**
* Set the resize threshold to maintain at worst a 2/3 load factor. 从新设置长度
*/
private void setThreshold(int len) {
threshold = len * 2 / 3;
}论断
- ThreadLocal不须要key，因为线程外面本人的ThreadLocal.ThreadLocalMap不是通过链表法实现的，而是通过开地址法实现的
- 每次set的时候往线程外面的ThreadLocal.ThreadLocalMap中的table数组某一个地位塞一个值，这个地位由ThreadLocal中的threadLocaltHashCode取模失去，如果地位上有数据了，就往后找一个没有数据的地位
- 每次get的时候也一样，依据ThreadLocal中的threadLocalHashCode取模，获得线程中的ThreadLocal.ThreadLocalMap中的table的一个地位，看一下有没有数据，没有就往下一个地位找
- 既然ThreadLocal没有key，那么一个ThreadLocal只能塞一种特定数据。如果想要往线程外面的ThreadLocal.ThreadLocalMap里的table不同地位塞数据 ，比方说想塞三种String、一个Integer、两个Double、一个Date，请定义多个ThreadLocal，ThreadLocal反对泛型”public class ThreadLocal<T>”
发表回复