1. 是什么
不是线程同步机制，是一种线程数据隔离机制。
多线程共享变量通信的情况下，我们需要保证线程安全。一种方法是使用锁，另一种就是数据隔离机制。
ThreadLocal用的是后一种，即每个线程操作的是自己独有的数据，因此互相之间不会影响
2. 如何使用
public class ThreadLocalTest { public static void main(String[] args) throws InterruptedException { ThreadLocal<String> threadLocal = new ThreadLocal<>(); threadLocal.set("main"); System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get());//main:main Thread thread1 = new Thread(()->{ threadLocal.set("thread1"); System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get());//Thread-0:thread1 }); Thread thread2 = new Thread(()->{ threadLocal.set("thread2"); System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get());//Thread-1:thread2 }); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get());//main:main threadLocal.remove(); System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get());//main:null } } 3. 原理分析
3.1. uml
Thread有一个ThreadLocalMap属性，
ThreadLocalMap有一个Entry数组属性
Entry有key和value属性，其中key为ThreadLocal，value为Object。并且Entry继承了WeakReference
3.2. 构造方法
//记录hash值 private static AtomicInteger nextHashCode = new AtomicInteger(); public ThreadLocal() { } 3.3. set方法
public void set(T value) { Thread t = Thread.currentThread(); //获取当前线程对应的ThreadLocalMap属性 ThreadLocalMap map = getMap(t); if (map != null) //将（ThreadLocal，value）构造成Entry放入ThreadLocalMap map.set(this, value); else //创建新的map关联当前线程，并且并放入（ThreadLocal，value） createMap(t, value); } - 4行：先获取Thread对应的ThreadLocalMap
- 5-7行：有的话调用ThreadLocalMap set方法插入ThreadLocal:value
- 8-10行：没有则创建ThreadLocalMap并放入ThreadLocal:value
下面具体分析：
3.3.1. 先获取Thread对应的ThreadLocalMap
Thread t = Thread.currentThread(); //获取当前线程对应的ThreadLocalMap属性 ThreadLocalMap map = getMap(t); - getMap
ThreadLocalMap getMap(Thread t) { //获取当前Thread对应的ThreadLocalMap对象 return t.threadLocals; } 3.3.2. 有的话调用ThreadLocalMap set方法插入ThreadLocal:value
- 调用ThreadLocalMap set
private void set(ThreadLocal<?> key, Object value) { Entry[] tab = table; int len = tab.length; //计算当前元素在数组中的位置 int i = key.threadLocalHashCode & (len-1); //如果key不在数组中，那么一直找到空位置 for (Entry e = tab[i]; e != null; //开放寻址法 e = tab[i = nextIndex(i, len)]) { ThreadLocal<?> k = e.get(); //key相等，替换值 if (k == key) { e.value = value; return; } //key为空，那么构造entry放入 if (k == null) { replaceStaleEntry(key, value, i); return; } } //走到这里说明退出循环，找到了空位置 tab[i] = new Entry(key, value); int sz = ++size; //是否需要扩容 if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); } 3.3.2.1. 发生Hash冲突则使用开放寻址法
- nextIndex
private static int nextIndex(int i, int len) { //线性探测i+1的位置 return ((i + 1 < len) ? i + 1 : 0); } 3.3.3. 没有则创建ThreadLocalMap并放入ThreadLocal:value
else //创建新的map关联当前线程，并且并放入（ThreadLocal，value） createMap(t, value); - createMap
void createMap(Thread t, T firstValue) { //当前ThreadLocal对象作为key，value作为value构造entry并构造map //thread的ThreadLocalMap属性是这里设置的 t.threadLocals = new ThreadLocalMap(this, firstValue); } 3.3.3.1. ThreadLocalMap构造方法
static class ThreadLocalMap { //由于Entry继承了WeakRefence static class Entry extends WeakReference<ThreadLocal<?>> { Object value; Entry(ThreadLocal<?> k, Object v) { //key是个弱引用（即一旦发生垃圾回收就会回收这个引用指向的对象）。 //当key被回收后，也即ThreadLocal被回收了，但是Entry中value的引用还在无法回收，可能会造成内存泄漏 super(k); value = v; } } //初始容量为16，必须为2的次方 private static final int INITIAL_CAPACITY = 16; //使用数组+线性探测法 private Entry[] table; //实际使用的长度 private int size = 0; //实际使用的长度达到这个长度时需要扩容 private int threshold; ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) { table = new Entry[INITIAL_CAPACITY]; //计算下标并且存入entry int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); table[i] = new Entry(firstKey, firstValue); size = 1; setThreshold(INITIAL_CAPACITY);//设置threshold为16*2/3=10 } private void setThreshold(int len) { threshold = len * 2 / 3; } 3.4. get方法
public T get() { Thread t = Thread.currentThread(); //获取当前线程对应的ThreadLocalMap ThreadLocalMap map = getMap(t); if (map != null) { //以当前ThreadLocal对象作为key从ThreadLocalMap中获取entry ThreadLocalMap.Entry e = map.getEntry(this); //从entry中获取value并返回 if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } //初始化map return setInitialValue(); } - 4行：先获取Thread对应的ThreadLocalMap
- 5-14行：Map不为空，那么从Map中获取key为当前ThreadLocal对象的Entry
- 15-16行：Map为空，则向创建后初始化默认值Null
3.4.1. 先获取Thread对应的ThreadLocalMap
Thread t = Thread.currentThread(); //获取当前线程对应的ThreadLocalMap属性 ThreadLocalMap map = getMap(t); - getMap
ThreadLocalMap getMap(Thread t) { //获取当前Thread对应的ThreadLocalMap对象 return t.threadLocals; } 3.4.2. Map不为空，那么从Map中获取key为当前ThreadLocal对象的Entry
private Entry getEntry(ThreadLocal<?> key) { //计算下标 int i = key.threadLocalHashCode & (table.length - 1); Entry e = table[i]; //很幸运第一个位置就是要找的元素 if (e != null && e.get() == key) return e; else //很不幸，需要用线性探测法 return getEntryAfterMiss(key, i, e); } 3.4.2.1. 使用开放寻址法继续寻找下一个位置
- getEntryAfterMiss
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) { Entry[] tab = table; int len = tab.length; //一直线性探测到为null（不存在） while (e != null) { ThreadLocal<?> k = e.get(); //key是否相等 if (k == key) return e; //ThreadLocal被回收了，那么回收value对象 if (k == null) expungeStaleEntry(i); else//继续下一个 i = nextIndex(i, len); e = tab[i]; } return null; } 3.4.3. Map为空，则向创建后初始化默认值Null
- setInitialValue
private T setInitialValue() { T value = initialValue();//return null; //下面这段代码同set方法 Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else createMap(t, value); return value; } 3.5. remove方法
public void remove() { //获取当前线程对应的map ThreadLocalMap m = getMap(Thread.currentThread()); if (m != null) m.remove(this); } - 3行：先获取Thread对应的ThreadLocalMap
- 4-5行：通过ThreadLocalMap remove key为当前ThreadLocal的Entry
3.5.1. 先获取Thread对应的ThreadLocalMap
//获取当前线程对应的map ThreadLocalMap m = getMap(Thread.currentThread()); - getMap
ThreadLocalMap getMap(Thread t) { //获取当前Thread对应的ThreadLocalMap对象 return t.threadLocals; } 3.5.2. 通过ThreadLocalMap remove key为当前ThreadLocal的Entry
private void remove(ThreadLocal<?> key) { Entry[] tab = table; int len = tab.length; int i = key.threadLocalHashCode & (len-1); //从map中找到对应的key并把entry删除 for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { if (e.get() == key) { e.clear();//清空key引用 expungeStaleEntry(i);//回收value对象 return; } } }
4. 总结
- 每个Thread都有ThreadLocalMap属性。可以想象成一个HashMap，这个Map中Entry 的key为ThreadLocal，value为要存储的值
- 由于key为ThreadLocal自己，因此一个ThreadLocal只能存储一个Object对象，如果需要存储多个Object对象那么就需要多个ThreadLocal
- 由于Entry继承了WeakRefence，key是个弱引用（即一旦发生垃圾回收就会回收这个引用指向的对象）。当key被回收后，也即ThreadLocal被回收了，但是Entry中value的引用还在无法回收，可能会造成内存泄漏。因此我们需要用static引用ThreadLocal变量且手动remove
