java之ThreadLocal详解
一、ThreadLocal简介
ThreadLocal是线程的局部变量，是每一个线程所单独持有的，其他线程不能对其进行访问，通常是类中的private static字段。
我们知道有时候一个对象的变量会被多个线程所访问，这时就会有线程安全问题，当然我们可以使用synchorinized 关键字来为此变量加锁，进行同步处理，从而限制只能有一个线程来使用此变量，但是加锁会大大影响程序执行效率，此外我们还可以使用ThreadLocal来解决对某一个变量的访问冲突问题。
当使用ThreadLocal维护变量的时候 为每一个使用该变量的线程提供一个独立的变量副本，即每个线程内部都会有一个该变量，这样同时多个线程访问该变量并不会彼此相互影响，因此他们使用的都是自己从内存中拷贝过来的变量的副本， 这样就不存在线程安全问题，也不会影响程序的执行性能。
但是要注意，虽然ThreadLocal能够解决上面说的问题，但是由于在每个线程中都创建了副本，所以要考虑它对资源的消耗，比如内存的占用会比不使用ThreadLocal要大。
二、ThreadLocal源码分析
（1）ThreadLocal方法
ThreadLocal 的几个方法： ThreadLocal 可以存储任何类型的变量对象， get返回的是一个Object对象，但是我们可以通过泛型来制定存储对象的类型。
public T get() { } // 用来获取ThreadLocal在当前线程中保存的变量副本
public void set(T value) { } //set()用来设置当前线程中变量的副本
public void remove() { } //remove()用来移除当前线程中变量的副本
protected T initialValue() { } //initialValue()是一个protected方法，一般是用来在使用时进行重写的
（2）ThreadLocal实现原理
1.内部结构
Thread 在内部是通过ThreadLocalMap来维护ThreadLocal变量表， 在Thread类中有一个threadLocals 变量，是ThreadLocalMap类型的，它就是为每一个线程来存储自身的ThreadLocal变量的。
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocalMap 是定义在ThreadLocal 类里的内部类，它的作用是存储线程的局部变量。ThreadLocalMap 以ThreadLocal的引用作为键，以局部变量作为值，存储在ThreadLocalMap.Entry （一种存储键值的数据结构）里。这是因为在每一个线程里面，可能存在着多个ThreadLocal变量
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;
}
}
}
2.调用过程
初始时，在Thread里面，threadLocals为空，当通过ThreadLocal变量调用get()方法或者set()方法，就会对Thread类中的threadLocals进行初始化，并且以当前ThreadLocal变量为键值，以ThreadLocal要保存的副本变量为value，存到threadLocals。
然后在当前线程里面，如果要使用副本变量，就可以通过get方法在threadLocals里面查找
注意：
在进行get之前，必须先set，否则会报空指针异常；
如果想在get之前不需要调用set就能正常访问的话，必须重写initialValue()方法。
ThreadLocal的set(T value)方法
public void set(T value) {
// 获得当前线程
Thread t = Thread.currentThread();
// 获得当前线程的 ThreadLocalMap 引用，详细见下
ThreadLocalMap map = getMap(t);
// 如果不为空，则更新局部变量的值
if (map != null)
map.set(this, value);
//如果不是第一次使用，先进行初始化
else
createMap(t, value);
}
内部类ThreadLocalMap的set(ThreadLocal<?> key,Object value)
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
// Hash 寻址，与table数组长度减1（二进制全是1）相与，所以数组长度必须为2的次方，减小hash重复的可能性
int i = key.threadLocalHashCode & (len-1);
//从hash值计算出的下标开始遍历
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
//获得该Entry的键
ThreadLocal<?> k = e.get();
//如果键和传过来的相同，覆盖原值，也说明，一个ThreadLocal变量只能为一个线程保存一个局部变量
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();
}
可以看出ThreadLocalMap 采用线性探测再散列解决Hash冲突的问题。即，如果一次Hash计算出来的数组下标被占用，即hash值重复了，则在该下标的基础上加1测试下一个下标，直到找到空值。比如说，Hash计算出来下标i为6，table[6] 已经有值了，那么就尝试table[7]是否被占用，依次类推，直到找到空值。以上，就是保存线程本地变量的方法。
TheadLocal的get()方法
public T get() {
//获得当前线程
Thread t = Thread.currentThread();
//得到当前线程的一个threadLocals 变量
ThreadLocalMap map = getMap(t);
if (map != null) {
// 如果不为空，以当前ThreadLocal为主键获得对应的Entry
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//如果值为空，则进行初始化
return setInitialValue();
}
ThreadLocal的setInitialValue()方法
private T setInitialValue() {
//获得初始默认值
T value = initialValue();
//得到当前线程
Thread t = Thread.currentThread();
// 获得该线程的ThreadLocalMap引用
ThreadLocalMap map = getMap(t);
//不为空则覆盖
if (map != null)
map.set(this, value);
else
//若是为空，则进行初始化，键为本ThreadLocal变量，值为默认值
createMap(t, value);
}
// 默认初始化返回null值，这也是 下面demo 为什么需要重写该方法的原因。如果没有重写，第一次get()操作获得的线程本地变量为null，需要进行判断并手动调用set()进行初始化
protected T initialValue() {
return null;
}
三、Demo
下面是个ThreadLocal使用的实例，两个任务共享同一个变量，并且两个任务都把该变量设置为了线程私有变量，这样，虽然两个任务都”持有“同一变量，但各自持有该变量的拷贝。因此，当一个线程修改该变量时，不会影响另一线程该变量的值。
package thread.ThreadLocalTest;
import java.util.Random;
import java.util.concurrent.TimeUnit;
/**
* Created by StoneGeek on 2018/8/1.
* 博客地址：http://www.cnblogs.com/sxkgeek
*/
public class ThreadLocalDemo2 implements Runnable {
// 一般会把 ThreadLocal 设置为static 。它只是个为线程设置局部变量的入口，多个线程只需要一个入口
private static ThreadLocal<Student> localStudent = new ThreadLocal() {
// 一般会重写初始化方法，一会分析源码时候会解释为什么
@Override
public Student initialValue() {
return new Student();
}
};
private Student student = null;
@Override
public void run() {
String threadName = Thread.currentThread().getName();
System.out.println("【" + threadName + "】：is running !");
Random ramdom = new Random();
//随机生成一个变量
int age = ramdom.nextInt(100);
System.out.println("【" + threadName + "】：set age to :" + age);
// 获得线程局部变量，改变属性值
Student stu = getStudent();
stu.setAge(age);
System.out.println("【" + threadName + "】：第一次读到的age值为 :" + stu.getAge());
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("【" + threadName + "】：第二次读到的age值为 :" + stu.getAge());
}
public Student getStudent() {
student = localStudent.get();
// 如果不重写初始化方法，则需要判断是否为空，然后手动为ThreadLocal赋值，否则的话会报空指针异常
// if(student == null){
// student = new Student();
// localStudent.set(student);
// }
return student;
}
public static void main(String[] args) {
ThreadLocalDemo2 ll = new ThreadLocalDemo2();
Thread t1 = new Thread(ll, "线程1");
Thread t2 = new Thread(ll, "线程2");
t1.start();
t2.start();
}
}
console打印：
【线程2】：is running !
【线程1】：is running !
【线程1】：set age to :67
【线程2】：set age to :4
【线程1】：第一次读到的age值为 :67
【线程2】：第一次读到的age值为 :4
【线程1】：第二次读到的age值为 :67
【线程2】：第二次读到的age值为 :4
四、应用场景
最常见的ThreadLocal使用场景为
用来解决 数据库连接、Session管理等。
数据库连接
Class A implements Runnable{
private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {
public Connection initialValue() {
return DriverManager.getConnection(DB_URL);
}
};
public static Connection getConnection() {
return connectionHolder.get();
}
}
Session管理
private static final ThreadLocal threadSession = new ThreadLocal();
public static Session getSession() throws InfrastructureException {
Session s = (Session) threadSession.get();
try {
if (s == null) {
s = getSessionFactory().openSession();
threadSession.set(s);
}
} catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
return s;
}
