##### 引入 https://blog.csdn.net/wanghao112956/article/details/102678591 https://cloud.tencent.com/developer/article/1627478 https://zhuanlan.zhihu.com/p/40515974 https://www.jianshu.com/p/dde92ec37bd1 先看一下ThreadLocal的类上面的介绍 ```java /** * 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). */ ``` 也就是说，ThreadLocal类用来提供线程内部的局部变量，这种变量在多线程环境下访问时能够保证每个线程的局部变量是相互隔离，互不干扰的。ThreadLocal对象一般都是private static修饰的，用于关联线程Thread和线程上下文。这么看来，和再web阶段的域对象是不是很像。通过本系列文章，你将会了解到下面这些问题的答案。 - ThreadLocal老旧版本的实现方式。 - ThreadLocal内存泄漏的原因及解决方案。 - 为什么ThreadLocal自定义一个Map，而不使用JDK的HashMap。 - ThreadLocalMap底层数组长度为什么必须是2的n次幂。 - ThreadLocalMap的哈希算法。 - ThreadLocalMap发生哈希冲突的解决方案。 - ThreadLocalMap的扩容机制。 - ThreadLocalMap的清理机制。 - ThreadLocal和Synchronized的区别。 ##### ThreadLocal在框架中的应用 // TODO 放在后面把 ThrealLocal在那些开源框架中得到广泛的应用，此处举一个例子。我们知道在MySQL事务中开启事务和执行SQL的Connection对象必须是同一个，但是我们执行SQL的代码在持久层，而我们处理业务，提交回滚代码是在业务层的。这样的话有两个解决方案， - 一个是传递Connection参数到持久层。这种不好，耦合性太高。 - 另一个就是使用ThreadLocal对象来存储Connection对象。看一下Spring框架中处理这个问题的解决方案。 1.DataSourceTransactionManager类的doBegin方法获得连接，设置事务的隔离级别，并开启事务 ```java @Override protected void doBegin(Object transaction, TransactionDefinition definition) { DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction; Connection con = null; try { // 获得Connection连接... 省略部分代码... if (con.getAutoCommit()) { txObject.setMustRestoreAutoCommit(true); if (logger.isDebugEnabled()) { logger.debug("Switching JDBC Connection [" + con + "] to manual commit"); } con.setAutoCommit(false); // 开启手动提交 } // 省略部分代码... // 使用bindResource方法将Connection对象，放到ThreadLocal里 if (txObject.isNewConnectionHolder()) { TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder()); } } catch (Throwable ex) { // 省略部分代码... } } ``` 2.TransactionSynchronizationManager的bindResource方法下面的resources对象，就是ThreadLocal对象。 ```java public static void bindResource(Object key, Object value) throws IllegalStateException { Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key); Assert.notNull(value, "Value must not be null"); Map map = resources.get(); // set ThreadLocal Map if none found if (map == null) { map = new HashMap<>(); resources.set(map); } Object oldValue = map.put(actualKey, value); // 省略部分代码... } ``` 上面的resources对象，就是ThreadLocal对象。 ```java private static final ThreadLocal> resources = new NamedThreadLocal<>("Transactional resources"); ``` ##### ThreadLocal的内存结构 ThreadLocal现在的内存结构是底层封装了一个自定义的Map。键对象是ThreadLocal对象，而不是当前的Thread线程对象。value则是我们要存的值。 **现在的ThreadLocal的图** 有很多人说ThreadLocal的底层Map的Key是当前Thread线程对象，不知道是从哪里看到的。我在网上看到有人说最开始确实是这样的，为了验证这点，我翻阅了JDK1.2.1，（具体从那个版本改的我也不知道）key对象确实是当前的Thread线程对象，而且用的Map是WeakHashMap。 **老版本的ThreadLocal的图** 看下JDK1.2.1的ThreadLocal的源码：可以看到`map.put(ourThread, ourEntry);`确实是将Thread对象作为key。 ```java /** * 设置值 */ public void set(Object value) { Entry ourEntry = ourEntry(false); ourEntry.value = value; } private Entry ourEntry(boolean initUponCreate) { // 获取当前线程对象作为key Thread ourThread = Thread.currentThread(); Entry ourEntry = (Entry)(map.get(ourThread)); if (ourEntry == null) { ourEntry = newEntry(initUponCreate ? initialValue() : null); map.put(ourThread, ourEntry); } return ourEntry; } ``` JDK1.2.1的ThreadLocal的内部Map是使用的WeakHashMap，而不是现在的ThreadLocalMap，也就是说所有的线程的绑定的变量都在一个Map里，不方便维护。 ```java /** * Maps each Thread that has a value for this ThreadLocal to an Entry * containing its value. The initial size is 53 because that is twice * the maximum concurrency that one might reasonably expect. */ Map map = Collections.synchronizedMap(new WeakHashMap(53)); ``` **比较：** 现在的ThreadLocal的设计相对远古版本的好处有： - 每个线程都有一个自己的ThreadLocalMap，方便维护。 - 关于set，get，remove等方法都有清理过期Entry的策略，防止内存溢出。 ##### 首先说下ThreadLocal类的成员变量 ```java /** * ThreadLocal的key的哈希值，是通过自己写的nextHashCode方法获取的 */ private final int threadLocalHashCode = nextHashCode(); /** * 原子变量，线程安全 */ private static AtomicInteger nextHashCode = new AtomicInteger(); /** * 黄金分割数(斐波那契数)。hash增量为这个数字，带来的好处就是hash分布非常均匀。 */ private static final int HASH_INCREMENT = 0x61c88647; ``` OK，分析下ThreadLocal的成员变量 threadLocalHashCode变量是通过nextHashCode()获得的，看一下它的代码： ```java private static int nextHashCode() { return nextHashCode.getAndAdd(HASH_INCREMENT); } ``` 可以看到ThreadLocal的哈希值就是从HASH_INCREMENT开始，HASH_INCREMENT作为增量的值。HASH_INCREMENT 是为了让哈希码能均匀的分布在2的N次方的数组里为什么 HASH_INCREMENT值是0x61c88647呢？ ##### 黄金分割数设一个数列，它的最前面两个数是*1、1*，后面的每个数都是它前面的两个数之和。例如：*1，1，2，3，5，8，13，21，34，55，89，144*·····这个数列为“斐波那契数列”，这些数被称为“斐波那契数”。经计算发现相邻两个斐波那契数的比值是随序号的增加而**逐渐逼近黄金分割比**，黄金分割比是$(\sqrt5-1) \over 2$，约等于0.618。由于斐波那契数都是整数，两个整数相除之商是有理数，而黄金分割是无理数，所以只是不断逼近黄金分割。求出32位有符号和无符号的整数的黄金分割比： ```java long unsignedNum = (long) ((1L << 32) * (Math.sqrt(5) - 1) / 2); System.out.println("32位无符号整数的黄金分割数: " + unsignedNum); int signedNum = (int) unsignedNum; System.out.println("32位有符号整数的黄金分割数: " + signedNum); ``` 控制台： ``` 32位无符号整数的黄金分割数: 2654435769 32位有符号整数的黄金分割数: -1640531527 ``` ThreadLocald的HASH_INCREMENT就是1640531527，16进制为0x61c88647，为了让哈希码能均匀的分布在2的N次方的数组里。 ```java public class Demo06 { private static final int HASH_INCREMENT = 0x61c88647; public static void main(String[] args) { hash(4); hash(8); hash(16); } private static void hash(int capacity) { int keyPosition; // i * HASH_INCREMENT用来模拟hash值 for (int i = 1; i <= capacity; i++) { keyPosition = (i * HASH_INCREMENT) & (capacity - 1); System.out.print(keyPosition + " "); } System.out.println(); } } ``` 控制台 ``` 3 2 1 0 7 6 5 4 3 2 1 0 7 14 5 12 3 10 1 8 15 6 13 4 11 2 9 0 ``` 可以看到这样计算的结果均匀的放到散列表中，假如散列表长度为4，那么它是按照`3 2 1 0 3 2 1 0 ...`这个顺序的。 ##### ThreadLocal的成员方法 ###### get获取方法大致的流程就是获取当前线程绑定的ThreadLocalMap对象 - 假如当前线程已经存在ThreadLocalMap对象，就去Map里获取数据。 - 假如当前线程还没有绑定ThreadLocalMap对象，初始化一个ThreadLocalMap对象。 ```java public T get() { // 获得当前线程对象 Thread t = Thread.currentThread(); // 获得当前线程对象的属性ThreadLocalMap对象 ThreadLocalMap map = getMap(t); if (map != null) { // 以ThreadLocal对象为Key，去数组中找对应的Entry节点 ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) { @SuppressWarnings("unchecked") // 直接返回对应位置的value值 T result = (T)e.value; return result; } } // ThreadLocalMap为空 // 或者当前线程的ThreadLocal对应的key没有数据，也就是没有set过 // 直接返回默认值null，也可以重写initialValue方法指定默认值 return setInitialValue(); } ``` 看下ThreadLocal的get方法里引用其他的方法，此处只解释下ThreadLocal的成员方法，有些ThreadLocalMap的方法后面再说。 getMap方法：该方法直接返回指定线程的成员属性的ThreadLocalMap对象 ```java ThreadLocalMap getMap(Thread t) { return t.threadLocals; } ``` setInitialValue方法：获取初始值，将初始值放到ThreadLocalMap的指定位置，假如ThreadLocalMap为null，则新创建一个ThreadLocalMap对象。 ```java /** * 获得initialValue()方法设置的初始值 * 以当前ThreadLocal对象为key，初始值为value放到ThreadLocalMap中 */ private T setInitialValue() { T value = initialValue(); Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else createMap(t, value); // 初始化ThreadLocalMap return value; } ``` initialValue方法：设置默认值的方法，子类可以重写该方法重新赋值默认值。后面写个重写的例子。 ```java /** * 默认初始值为null，子类可以重写初始值 */ protected T initialValue() { return null; } ``` createMap方法：通过有参构造创建ThreadLocalMap对象 ```java /** * 通过有参构造创建ThreadLocalMap对象 */ void createMap(Thread t, T firstValue) { t.threadLocals = new ThreadLocalMap(this, firstValue); } ``` ###### set设置方法这个方法和setInitialValue方法基本一样，拿当前Thread线程对象的ThreadLocal为key，插入到ThreadLocalMap中。 ```java public void set(T value) { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else createMap(t, value); } ``` ###### remove方法移除方法。假如移除之后没有set设置新值，再次调用get方法的时候，还是会走initialValue方法获取默认值。 ```java public void remove() { ThreadLocalMap m = getMap(Thread.currentThread()); if (m != null) m.remove(this); } ``` ##### 内部类SuppliedThreadLocal 上面有个initialValue()方法可以设置默认值，看一个例子： eg. ```java private static ThreadLocal threadLocal1 = new ThreadLocal<>(); private static ThreadLocal threadLocal2 = new ThreadLocal() { @Override protected String initialValue() { return "我是一个新的默认值"; } }; public static void main(String[] args) { String defautStr1 = threadLocal1.get(); String defautStr2 = threadLocal2.get(); System.out.println("未重写initialValue()方法的默认值：" + defautStr1); // null System.out.println("已重写initialValue()方法的默认值：" + defautStr2); // 我是一个新的默认值 } ``` 控制台： ``` 未重写initialValue()方法的默认值：null 已重写initialValue()方法的默认值：我是一个新的默认值 ``` 在未调用set方法设置值时，可以看到在未重写initialValue()方法的时候get()方法返回的是null，而重写了该方法后返回的是我们重写时重新设置的默认值。使用匿名方式创建ThreadLocal对象重写方法看起来比较臃肿，不美观。JDK为我们提供了美化代码的方法，内部类SuppliedThreadLocal的作用就在此处。首先，我们也先看用Lambda表示替换后的代码： eg. ```java private static ThreadLocal threadLocal = ThreadLocal.withInitial(() -> "我是一个新的默认值"); public static void main(String[] args) { String defautStr = threadLocal.get(); System.out.println("重写initialValue()方法的默认值：" + defautStr); // 我是一个新的默认值 } ``` 先看下创建内部类SuppliedThreadLocal的方法：调用withInitial方法传入一个生产接口，通过调用SuppliedThreadLocal的构造方法即可创建一个带默认值的ThreadLocal对象。 ```java public static ThreadLocal withInitial(Supplier supplier) { return new SuppliedThreadLocal<>(supplier); } ``` SuppliedThreadLocal的源码： ```java static final class SuppliedThreadLocal extends ThreadLocal { private final Supplier supplier; SuppliedThreadLocal(Supplier supplier) { this.supplier = Objects.requireNonNull(supplier); } /** * 调用生产接口supplier对象生产的值作为ThreadLocal的初始值 */ @Override protected T initialValue() { return supplier.get(); } } ``` ##### 内部类ThreadLocalMap 这个类是整个ThreadLocal的核心类，十分重要。 ###### Entry节点对象这个对象是ThreadLocalMap底层数组存放元素的类型。 Entry类继承自WeakReference，使ThreadLocalMap的key，也就是ThreadLocal对象有一个软引用指向它。 ```java /** * The entries in this hash map extend WeakReference, using * its main ref field as the key (which is always a * ThreadLocal object). Note that null keys (i.e. entry.get() * == null) mean that the key is no longer referenced, so the * entry can be expunged from table. Such entries are referred to * as "stale entries" in the code that follows. */ static class Entry extends WeakReference> { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal k, Object v) { super(k); value = v; } } ``` ###### 为什么要用软引用？ TODO ###### 成员变量 ```java /** * 初始容量，ThreadLocalMap的容量必须是2的n次幂 */ private static final int INITIAL_CAPACITY = 16; /** * Entry对象数组，长度必须是2的n次幂 */ private Entry[] table; /** * Entry对象数组中存在的元素 */ private int size = 0; /** * 下次调整大小的阈值，默认是0 */ private int threshold; // Default to 0 ``` ###### 构造函数 ```java /** * Construct a new map initially containing (firstKey, firstValue). * ThreadLocalMaps是懒加载的，只有当有一个元素entry添加的时候才会创建 */ ThreadLocalMap(ThreadLocal firstKey, Object firstValue) { table = new Entry[INITIAL_CAPACITY]; // 初始化一个Entry数组 // 因为INITIAL_CAPACITY必须是2的n次幂，所以-1后与操作，其实等价于取模操作 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); // 将key，value放到table的指定位置 table[i] = new Entry(firstKey, firstValue); size = 1; // ThreadLocalMaps的包含的元素个数设置为1 setThreshold(INITIAL_CAPACITY); // 设置加载因子 } ``` 私有构造函数 ```java /** * Construct a new map including all Inheritable ThreadLocals * from given parent map. Called only by createInheritedMap. * * @param parentMap the map associated with parent thread. */ private ThreadLocalMap(ThreadLocalMap parentMap) { Entry[] parentTable = parentMap.table; int len = parentTable.length; setThreshold(len); table = new Entry[len]; for (int j = 0; j < len; j++) { Entry e = parentTable[j]; if (e != null) { @SuppressWarnings("unchecked") ThreadLocal

ThreadLocal源码分析威力增强版plus.

Dylan Kwok

ThreadLocal源码分析威力增强版plus