深入理解ThreadLocal

1、ThreadLocal是什么

当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程对应的副本

2、ThreadLocal类提供的4个方法

• public void set(T value)

        设置当前线程的线程局部变量的值

/**
* Sets the current thread's copy of this thread-local variable
* 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
*        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);
}

• public T get()

　　　返回当前线程所对应的线程的局部变量

/**
* Returns the value in the current thread's copy of this
* 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();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}

• public void remove()

　　　将当前线程的局部变量的值删除    

public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}

• protected T initialValue()

        返回该线程局部变量的初始值,该方法是一个protected方法，显然是为了让子类覆盖而设计的，ThreadLocal中的缺省实现直接返回一个null

protected T initialValue() {
return null;
}

3、每个线程的变量副本存储在哪里

ThreadLocal有一个静态内部类ThreadLocalMap，该内部类保存了当前线程所对应的变量的副本（需要注意的是，变量是保存在线程中的，而不是保存在ThreadLocal变量中）

Thread类表示的当前线程中，有一个变量引用名是threadLocals，这个引用是在ThreadLocal类中createMap函数内初始化的

/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;

我们所使用的ThreadLocal变量的实际数据，通过get函数实际取值的时候，就是通过取出Thread类中threadLocals引用的map，然后从这个map中根据当前threadLocal作为参数，取出数据

4、变量副本是怎么从共享的那个变量复制出来的，ThreadLocal的初始值什么时候设置的？

准确的说，应该是，变量副本【每个线程中保存的那个map中的变量】是怎么声明和初始化的

从set函数可以看出，当前线程的ThreadLocalMap是在第一次调用set的时候创建map并设置相应的值的

5、一个线程声明了n（n>=2）个这样的局部变量threadLocal，那么在Thread类中的threadLocals是怎么存储的？

在ThreadLocal的set函数中可以看到，其中的map.set(this, value)把当前的ThreadLocal传入到map中作为键，也就是说，在不同线程的threadLocals变量中，都会有一个以你所声明的那个线程局部变量threadLocal作为键的key-value。假设你声明了n个这样的线程局部变量，那么在线程的ThreadLocalMap中就会有n个分别以你的线程局部变量作为key的键值对

6、应用场景

当很多线程需要多次使用同一个对象，并且需要该对象具有相同初始化值的时候最适合使用ThreadLocal

7、典型应用

ThreadLocal在Hibernate中的应用

private static final ThreadLocal threadSession = new ThreadLocal();

public static Session getSession() throws InfrastructureException {
//首先判断当前线程中有没有放进去session
Session s = (Session) threadSession.get();
try {
//如果还没有，通过sessionFactory.openSession()来创建一个session，再将session放到线程中
//实际上是放到当前线程的ThreadLocalMap中，对于这个session的唯一引用就是当前线程中的那个ThreadLocalMap
if (s == null) {
s = getSessionFactory().openSession();
threadSession.set(s);
}
} catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
return s;
}

试想如果不用ThreadLocal怎么来实现呢？可能就要在action中创建session，然后把session一个个传到service和dao中

或者自己定义一个静态的map，将当前thread作为key，创建的session作为值，put到map中

 8、代码示例

8.1 例1

public class ThreadLocalTest {

//创建一个Integer型的线程本地变量
public static final ThreadLocal<Integer> local = new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return 0;
}
};

public static void main(String[] args) {
Thread[] threads = new Thread[5];
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
//获取当前线程的本地变量，然后累加5次
int num = local.get();
for (int j = 0; j < 5; j++) {
num++;
}
//重新设置累加后的本地变量
local.set(num);
System.out.println(Thread.currentThread().getName() + ":" + local.get());
}
}, "Thread-" + i).start();
}
}

}

 运行后结果：

Thread-0:5
Thread-3:5
Thread-2:5
Thread-1:5
Thread-4:5

可以看到，每个线程累加后的结果都是5，各个线程处理自己的本地变量值，县城之间互不影响。

8.2 例2

public class ThreadLocalTest {

private static Index num = new Index();

//创建一个Integer型的线程本地变量
public static final ThreadLocal<Index> local = new ThreadLocal<Index>() {
@Override
protected Index initialValue() {
return num;
}
};

public static void main(String[] args) {
Thread[] threads = new Thread[5];
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
//获取当前线程的本地变量，然后累加5次
Index index = local.get();
for (int j = 0; j < 5; j++) {
index.increase();
}
//重新设置累加后的本地变量
local.set(index);
System.out.println(Thread.currentThread().getName() + ":" + local.get().num);
}
}, "Thread-" + i).start();
}
}

static class Index {
int num;
public void increase() {
num++;
}
}

}

执行结果（每次运行结果都不一样）：

Thread-0:5
Thread-1:20
Thread-3:25
Thread-4:15
Thread-2:10

原因：

ThreadLocal可以给一个初始值，而每个线程获得的是这个初始值的副本，而不是要创建对象引用的副本

public static final ThreadLocal<Index> local = new ThreadLocal<Index>() {
@Override
protected Index initialValue() {
return new Index(); //注意这里
}
};

改为以上方法后，正确输出结果：

Thread-0:5
Thread-2:5
Thread-4:5
Thread-3:5
Thread-1:5