ThreadLocal
ThreadLocal，顾名思义就是线程本地对象，理解起来就是线程局部变量，这个类可以将对象绑定到线程，使之成为线程私有对象。这种解决并发安全问题的方式就是不共享，使用私有变量来保证线程安全。
线程局部变量(ThreadLocal)其实的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是Java中一种较为特殊的线程绑定机制，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。
概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。
《Java核心技术》中关于ThreadLocal的示例：
public static final ThreadLocal<SimpleDateFormat> dateFormat=
ThreadLocal.withInitial(()->new SimpleDateFormat("yyyy-mm-dd"));
这段代码使得每个访问此共享变量的线程，持有一个私有的对象。
因为这个SimpleDateFormat不是线程安全的类，在并发情况下其内部的状态可能会出现安全问题，且在并发使用过程中，并不需要修改这个对象的状态，所以为了线程安全，使其“局部化”简单又安全。
// 访问数据
SimpleDateFormat format = dateFormat.get();
在一个给定的线程中首次调用get方法时，会调用initialValue方法，在此之后，get方法会返回属于当前线程的那个实例。
在Java 7中提供了一个类似ThreadLocal类的辅助类：ThreadLocalRandom类，ThreadLocalRandom.current()会返回一个特定于当前线程的Random类实例。
API
基本方法
-
public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier)使用函数式接口创建ThreadLocal对象，接口内实现初始化动作 -
public T get()获取Local值 -
public void set(T value)设置Local值 -
public void remove()删除Local值
直观的示例
public class ThreadLocalpractice {
// 线程私有变量,和当前线程绑定，所以各个线程对其的改变不会被其他线程读取到到
private final ThreadLocal<Integer> local = ThreadLocal.withInitial(() -> 1);
public void add(int a) {
local.set(local.get() + a);
}
public Integer get() {
return local.get();
}
public static void main(String[] args) {
ThreadLocalpractice tlp = new ThreadLocalpractice();
for (int i = 0; i < 100; i++) {
new Thread(() -> {
tlp.add(1);
System.out.println(Thread.currentThread().getName() + " get is " + tlp.get());
}).start();
}
while (true) {
}
}
}
结果是每个打印都是2，说明各自的add都是独立的。
实现原理
ThreadLocal内部的变量是如何绑定到Thread对象上的？
- 查看set和get的源码：
public T get() {
// 获取当前线程
Thread t = Thread.currentThread();
// 以当前线程对象为参数，调用getMap()方法-->查看getMap
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();
}
从get方法可以看出，首先会获取当前线程，如何以当前线程对象为参数getMap():
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
发现getMap是获取Thread对象的一个属性，查看Thread源码关于此属性：
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
可见首次get，map是null,继续查看get方法，如果map为null会直接return setInitialValue（）：
private T setInitialValue() {
// 初始化Local的value
T value = initialValue();
Thread t = Thread.currentThread();
// 获取Thread的threadLocals属性，首次为null，触发羡慕的createMap方法
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
// 在此方法中为Thread对象的threadlocals属性赋值，到此为止，map对象已经和Thread绑定成功了。
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
首次set也会创建map，即执行初始化工作：
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
- 总结
- 在创建ThreadLocal对象时，对象的值为null；
- 可以通过继承ThreadLocal并重写initialValue方法来设置初始值或者使用静态方法
withInitial来设置初始值。 - 当线程首次调用TL的get或set方法时，会为当前线程对象创建一个ThreadLocalMap对象，并将ThreadLocal对象作为Map的key,ThreadLocal的value作为map的value，然后将这个map传给Thread对象的threadLocals属性，达到将ThreadLocal绑定到Thread的目的。
- 在之后的get、set或remove操作中，实际上只是在操作线程的threadlocals，这个属性不会在线程间共享，自然就相当于局部变量了。
ThreadLocalMap
从上面数据绑定的原理中可以知道，线程的ThreadLocal值是存在一个叫ThreadLocalMap的数据结构中的，既然是Map，一定是一个支持键值对的数据结构。那么是否使用的就是HashMap呢？
- ThreadLocalMap部分源码
/**
* ThreadLocalMap is a customized hash map suitable only for
* maintaining thread local values. No operations are exported
* outside of the ThreadLocal class. The class is package private to
* allow declaration of fields in class Thread. To help deal with
* very large and long-lived usages, the hash table entries use
* WeakReferences for keys. However, since reference queues are not
* used, stale entries are guaranteed to be removed only when
* the table starts running out of space.
*/
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;
}
}
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);
}
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;
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;
}
// 支持null键
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
// ...
}
浏览源码可以发现，是一个ThreadLocal专用的HashMap，底层和hashmap相似。
参考资料
[1] Java并发编程实战
[2] Java核心技术
