什么是ThreadLocal
Java doc的解释
ThreadLocal提供了线程局部可用的变量. 这些变量在每个线程中都维护有自己的独立副本. ThreadLocal类型的变量一般是一个类的静态变量来存储与线程相关的变量 (比如用户ID, 事务ID).
每个活的线程都持有thread-local变量的精确引用. 当线程terminated后, 该变量变得可以被GC(在没有其他引用后).
ThreadLocal可以做什么?
常见用途.
存储一些本身不是线程安全的类
比如SimpleDateFormat不是线程安全的, 我们可以用ThreadLocal来存储
import java.text.SimpleDateFormat;
import java.util.Date;
public class ThreadLocalDemo {
static ThreadLocal<SimpleDateFormat> _formatter = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
public static String formate(Date date) {
return _formatter.get().format(date);
}
public static void main(String[] args) {
System.out.println(formate(new Date()));
}
记录一些上下文相关的信息
比如前面写的userid, transactionid
我们用ThreadLocal来实现打印日志中包含正确的Component信息.
import java.util.Date;
public class ThreadLocalLooggerDemo {
public static void main(String[] args) throws InterruptedException {
Thread task = new Thread(new Runnable() {
@Override
public void run() {
Log.setTaskId("Consumer");
Log.info("I started");
try {
Thread.sleep(1000);
}
catch (InterruptedException e) {
}
Log.info("I finished");
}
});
task.start();
task.join();
}
static class Log {
static ThreadLocal<String> taskId = ThreadLocal.withInitial(() -> "N/A");
public static void setTaskId(String taskIdStr) {
taskId.set(taskIdStr);
}
public static String getTaskId() {
return taskId.get();
}
public static void info(String message) {
System.out.println(String.format("[%s][%s]%s", new Date(), taskId.get(), message));
}
}
}
示例输出
[Wed Jul 10 13:59:10 CST 2019][Consumer]I started
[Wed Jul 10 13:59:11 CST 2019][Consumer]I finished
实现细节
set 方法
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
map.set(this, value);
} else {
createMap(t, value);
}
- 每个Thread有一个自己的变量map:
ThreadLocal.ThreadLocalMap threadLocals = null
- 该map是一个ThreadLocal内部定义的map. map里面的每个Entry都是
WeakReference<ThreadLocal>
. - 使用WeakReference是因为 我们不能一直持有一个Thread或者ThreadLocal的引用这会导致它没法被GC, 这就有了内存泄漏. 而WeakReference没有这个问题. 这就是后面如果Entry的key为NULL时, 它的值也被擦除了. (它的值就是这里的SimpleDateFormat)
int i = key.threadLocalHashCode & (len-1); // 根据key (threadlocal对象)找到tab[]的index
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) { // 循环遍历 tab, nextIndex 就是从i开始自增 并取模len
ThreadLocal<?> k = e.get();
if (k == key) { // 如果是同一个对象 指针比较
e.value = value; // 更新值返回
return;
}
if (k == null) { // 当前位置没人用 就放在当前位置
replaceStaleEntry(key, value, i); // 该方法还会做一些动作 就是
return;
}
}
get方法
Thread t = Thread.currentThread(); // 一直使用当前Thread的threadlocalmap
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(); // 没有返回初始值 如果有设置的话
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e; // 直接根据hash值找
else
// 没找到 或者不匹配
return getEntryAfterMiss(key, i, e);
}
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
// 又是一个循环检查
while (e != null) {
ThreadLocal<?> k = e.get();
if (k == key)
return e;
if (k == null)
expungeStaleEntry(i); // 擦除掉当前entry key为null的值, key和value都为NULL
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
// 擦除key为NULL的方法
private int expungeStaleEntry(int staleSlot) { // 当前key为null的slot
Entry[] tab = table;
int len = tab.length;
// expunge entry at staleSlot // 擦除当前slot
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// Rehash until we encounter null
Entry e;
int i;
// for 循环
for (i = nextIndex(staleSlot, len); // 向下检查下一个slot
(e = tab[i]) != null; // Entry有东西
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) { // 擦除key 为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;
}