作为从JDK1.2就引入的特性，ThreadLocal这个名字大家可能见得比较少，从字面看，直译为“线程本地”，一看就是和多线程相关的关键字，但具体是什么作用，使用场景是如何呢，这边简单介绍一下。
首先，我们看一下源码里面的注释
This class provides thread-local variables. These variables differ from
their normal counterparts in that each thread that accesses one (via its
{@code get} or {@code set} method) has its own, independently initialized
copy of the variable. {@code ThreadLocal} instances are typically private
static fields in classes that wish to associate state with a thread (e.g.,
a user ID or Transaction ID).
用我仅有的英语词汇翻译下就是：
这个类提供thread-local变量（简直废话）。这些变量不同于寻常变量，它们为每个线程独立分配一个变量的拷贝。ThreadLocal实例一般定义为private static的（下面会详细解释），用于将一个线程和一个状态关联，例如一个用户id（user ID）或者事务id（Transaction ID）（此处为ThreadLocal的使用场景）
翻译的比较鸡肋，主要的含义就是说，通过它，解决之前线程之间共享变量的问题，暂时可先这么理解吧。
使用简介
类似关键字synchronized，ThreadLocal也是用于线程之间共享变量问题的处理，不同的是，synchronized会锁住变量，当一个线程使用的时候，其他线程只能等待；而ThreadLocal是给每个线程分配一个拷贝，这样每个线程就独享自己的拷贝，不存在冲突问题。synchronized是时间换空间，ThreadLocal是空间换时间。
看下使用方法吧
public class ThreadLocalTest {
private static ThreadLocal<Integer> threadlocal = new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return 0;
}
};
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
new ThreadA(i).start();
}
}
public static class ThreadA extends Thread {
private int index;
public ThreadA(int index) {
super();
this.index = index;
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("Thread " + index + " print " + threadlocal.get());
threadlocal.set(threadlocal.get() + 1);
}
}
}
}
输出如下
Thread 0 print 0
Thread 2 print 0
Thread 2 print 1
Thread 2 print 2
Thread 2 print 3
Thread 2 print 4
Thread 1 print 0
Thread 1 print 1
Thread 1 print 2
Thread 1 print 3
Thread 1 print 4
Thread 0 print 1
Thread 0 print 2
Thread 0 print 3
Thread 0 print 4
当然上面只是一个简单的实例，在正常使用场景中，我们里面的泛型可以使一些更复杂的类型，例如SimpleDateFormatter等
原理剖析
关注ThreadLocal暴露出来的几个方法
protected T initialValue() {
return null;
}
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 set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
来来来，下面一起看下上述几个方法的作用
protected T initialValue()
这是一个子类可继承修改的方法，作用如其名所示，就是初始化值使用
public T get()
返回当前线程对应的“thread-local”值，即获取当前线程“存储”在对应的ThreadLocal中的数据。
我们稍微看一下这个方法，逻辑比较简单
- 获取当前线程
- 从当前线程中获取
ThreadLocalMap类型的属性，通过查看getMap方法
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
我们发现，这个ThreadLocalMap其实就是Thread中的一个属性，也就是说实际线程要获取的值还是存储在Thread中。
从ThreadLocalMap.Entry e = map.getEntry(this)中，我们可以看到，在线程中的ThreadLocalMap中，其key为ThreadLocal本身，value为需要获取的对象
- 若
ThreadLocalMap.Entry有值，则返回对应的值，否则返回初始对象，即在initialValue中设置的值。
看明白了public T get()，那么public void set(T value)和public void remove()就很好理解了。
内存问题
我们查看ThreadLocalMap这部分的源码可发现
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
我们发现，这边的Entry的key为一个弱引用，即当所有指向该key的强引用均消失的时候，即使有弱引用指向该对象，GC触发的时候依然会回收这个对象。
image
我们看上面一张图，此时若弱引用指向的
ThreadLocal被回收了，则对应Entry中的value值则永远不可能被使用到，而GC也不会回收该对象，若该线程运行时间较长，则存在内存泄露的风险。
真的如此吗？我们翻阅下ThreadLocalMap的源码，发现有如下代码
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// expunge entry at staleSlot
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// Rehash until we encounter null
Entry e;
int i;
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
tab[i] = null;
// Unlike Knuth 6.4 Algorithm R, we must scan until
// null because multiple entries could have been stale.
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
看下关键代码段
if (k == null) {
e.value = null;
tab[i] = null;
size--;
}
上述代码，会在key为null的时候，回收对应的value，即在这里做了一些回收的动作，而这个expungeStaleEntry方法，当我们调用ThreadLocal的get,set,remove方法的时候会触发，但是不会自动触发，指导线程自动结束，所以，最好的实践场景就是，每次所用完之后显示调用remove方法来显示释放。
使用场景
经过上面的描述，大家可以看到，ThreadLocal用在多线程的场景，将一些平时非线程安全的对象（例如SimpleDateFormat），分装一个线程安全的方法来使用，同时，其与synchronized的区别在于，ThreadLocal维护多分拷贝，以空间来换取时间上的提升。
有人说，如果你为每个线程维护一个自己的变量拷贝，那还不如每个线程自己来维护这个变量。是的，说的没错，我们也可以自己在线程中自己来声明、使用变量。但是，ThreadLocal相比较与本地变量，有如下的优势
- 减少变量的传递。
当我们的变量需要当成一个参数来传递给内部的方法的时候，使用ThreadLocal，可以直接使用，不用传递参数。 - 减少重复代码的编写
若我们在多个线程中都要使用类似的变量，使用ThreadLocal的时候，可以进行一处声明，多处使用，减少重复代码。
一个经典的使用场景就是web请求的处理，在web容器中，当来了一个请求的时候，容器会使用单独的线程处理每个请求的时候，这个时候我们可以使用ThreadLocal来记录线程中的一些状态，在线程执行过程中，可直接通过get方法就可以直接获取。
以上为自己的一些理解，若有不正确的地方，请大家指正！
网友评论