ThreadLocal 的作用和实现原理
ThreadLocal 类用来提供线程内部的局部变量，并且这些变量依靠线程独立存在.
可以在多个线程中互不干扰的进行存储数据和修改数据，通过set,get 和remove方法，
每个线程都是独立的操作.
里面的原理是：在不同的线程中访问同一个对象，获取到的值是不一样的，因为内部会
从各种的线程中取出一个数组。 通过对应的下标，查找对应的Value值
下面看个简单的列子:
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_login);
final ThreadLocal<String> threadLocal = new ThreadLocal<String>();
threadLocal.set("123");
Log.e("Charles2", "ss1==" + threadLocal.get());
new Thread(new Runnable() {
@Override
public void run() {
String s = threadLocal.get();
Log.e("Charles2", "ss2=" + s);
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
threadLocal.set("234");
String s = threadLocal.get();
Log.e("Charles2", "ss3==" + s);
}
}).start();
}
打印的结果如下 :
07-18 15:58:14.312 21113-21113/? E/Charles2: ss1==123
07-18 15:58:14.326 21113-21140/? E/Charles2: ss2=null
07-18 15:58:14.327 21113-21141/? E/Charles2: ss3==234
大家都知道这三行打印都在不同的线程，线程1是在主线程，线程2 和 线程3 分别在不各
自线程中，但是由于线程2没有给它设置值所以取出来的是null.其它2个线程的内部变量
都是有值.
二、实现原理
ThreadLocal的set()分析
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
如上面的代码看，得到map对象之后，用的this作为key，this在这里代表的是当前线程的ThreadLocal对象。 另外就是第二句根据getMap获取一个ThreadLocalMap，其中getMap中传入了参数t(当前线程对象)，这样就能够获取每个线程的ThreadLocal了。 继续跟进到ThreadLocalMap中查看set方法：
(2)1.ThreadLocalMap
ThreadLocalMap是ThreadLocal的一个内部类，在分析其set方法之前，查看一下其类结构和成员变量。
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}
/**
* The initial capacity -- MUST be a power of two.
*/
private static final int INITIAL_CAPACITY = 16;
/**
* The table, resized as necessary.
* table.length MUST always be a power of two.
*/
private Entry[] table;
/**
* The number of entries in the table.
*/
private int size = 0;
/**
* The next size value at which to resize.
*/
private int threshold; // Default to 0
然后看下ThreadLocal的构造方法
ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
构造函数的第一个参数就是本ThreadLocal实例(this)，第二个参数就是要保存的线程本地变量。构造函数首先创建一个长度为16的Entry数组，然后计算出firstKey对应的哈希值，然后存储到table中，并设置size和threshold。
注意一个细节，计算hash的时候里面采用了hashCode & (size - 1)的算法，这相当于取模运算hashCode % size的一个更高效的实现（和HashMap中的思路相同）。正是因为这种算法，我们要求size必须是2的指数，因为这可以使得hash发生冲突的次数减小。
ThreadLocalMap#set
ThreadLocal中put函数最终调用了ThreadLocalMap中的set函数，跟进去看一看：
···
private void set(ThreadLocal key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
e != null;
// 冲突了
e = tab[i = nextIndex(i, len)]) {
ThreadLocal k = e.get();
if (k == key) {
e.value = value;
return;
}
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
···
在上述代码中如果Entry在存放过程中冲突了，调用nextIndex来处理，如下所示。是否还记得hashmap中对待冲突的处理？这里好像是另一种套路：只要i的数值小于len，就加1取值，官方术语称为：线性探测法。
/**
* Increment i modulo len.
*/
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
以上步骤ok了之后，再次关注一下源码中的cleanSomeSlots，该函数主要的作用就是清理无用的entry，具体细节就不扣了：
private boolean cleanSomeSlots(int i, int n) {
boolean removed = false;
Entry[] tab = table;
int len = tab.length;
do {
i = nextIndex(i, len);
Entry e = tab[i];
if (e != null && e.get() == null) {
n = len;
removed = true;
i = expungeStaleEntry(i);
}
} while ( (n >>>= 1) != 0);
return removed;
}
下面来看ThreadLocal#get
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
return setInitialValue();
}
如果map不会空，就根据当前线程去查存储的变量。
如果map为null，就返回setInitialValue()这个方法，跟进这个方法看一下：
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
最后返回的是value，而value来自initialValue(),进入这个源码中查看：
protected T initialValue() {
return null;
}
原来如此，如果不设置ThreadLocal的数值，默认就是null，来自于此。
