从 ThreadLocal 常见操作入手分析源码。

最新推荐文章于 2023-03-07 17:46:51 发布

RamboPan

最新推荐文章于 2023-03-07 17:46:51 发布

阅读量238

点赞数

分类专栏： Java 文章标签： Android Java ThreadLocal

本文链接：https://blog.csdn.net/u014443348/article/details/83929384

版权

Java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

版权声明：本文章原创于 RamboPan ，未经允许，请勿转载。

从 ThreadLocal 常见操作入手分析源码

第一次 2018年11月10日
第二次 2019年03月09日
- 调整代码块
- 变量、类名、方法标记统一
- 优化图片

在开发过程中碰到过 ThreadLocal，于是花了些时间理解了下，做一个笔记算是分享下。
源码基于 Android SDK 26 JDK 1.8

- 从 ThreadLocal 常见操作入手分析源码

打算从 ThreadLocal 中的常见操作进行寻找原理：构造函数 、set() 、get() 、 remove() 进行分析。

首先大概瞄一眼 ThreadLocal 结构。

代码【1】ThreadLocal 结构

首先按照我们常用的使用方式。

	ThreadLocal<T> mThreadLocal = new ThreadLocal();

按照这个构造函数点进去。


	public class ThreadLocal<T> {
	    ……
	    public ThreadLocal() {}
	    
		static class ThreadLocalMap {
		    //【节点类】
		    static class Entry extends WeakReference<ThreadLocal<?>> {
		        Object value;
		
		        Entry(ThreadLocal<?> k, Object v) {
		            super(k);
		            value = v;
		        }
		    }
		
		    //默认初始容量  MUST be a power of two.  
		    private static final int INITIAL_CAPACITY = 16;
		    //存放节点的table table.length MUST always be a power of two.
		    private Entry[] table;
		    //已存放节点的个数
		    private int size = 0;
		    //容量预警阀值
		    private int threshold; // Default to 0
		    ……
		}
	}

除了一些初始化的操作，没有其他可以追寻的逻辑，那就从常见的 set() 入手吧。

代码【2】threadLocal.set()


	public void set(T value) {
	    //新建一个线程并指向了当前线程
	    Thread t = Thread.currentThread();
	    //从当前线程中拿到 ThreadLocalMap
	    ThreadLocalMap map = getMap(t);//代码【3】
	
	    if (map != null)
	        map.set(this, value);//代码【7】
	    else
	        createMap(t, value);//代码【4】
	}

然后我们来看看这 getMap() 、 map.set() 、 createMap() 三个方法。

代码【3】threadLocal.getMap()


	ThreadLocalMap getMap(Thread t) {
	    return t.threadLocals;
	}
	
	//既然是线程里的属性，咱们就找找 Thread 有没有这个东西
	public class Thread implements Runnable {
	    ……
	    /* ThreadLocal values pertaining to this thread.
	    * This map is maintained by the ThreadLocal class. */
	    ThreadLocal.ThreadLocalMap threadLocals = null;
	    ……
	}

果然有这个属性，然后在 Thread 当中查找是否有相关调用初始化。

暂时没有找到，我们就默认为 null 。先看 if (map == null) 的情况，即代码【4】。

代码【4】threadLocal.createMap()


	void createMap(Thread t, T firstValue) {
	    //初始化t线程的ThreadLocalMap。
	    t.threadLocals = new ThreadLocalMap(this, firstValue);
	}

	//第一次创建是拿到了一个键值对，初始化后会直接插入新数据。
	ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
	    //初始化节点数组
	    table = new Entry[INITIAL_CAPACITY]; //代码【5】
	    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);//代码【6】
	    //插入第一个节点，调整节点数组大小，设置预警阀值。
	    table[i] = new Entry(firstKey, firstValue);
	    size = 1;
	    //根据最大长度设置预警值
	    setThreshold(INITIAL_CAPACITY);
	}
	
	//初始化容量 -- 【MUST be a power of two.】
	private static final int INITIAL_CAPACITY = 16;
	//设置阈值为 2/3 容量
	private void setThreshold(int len) {
	    threshold = len * 2 / 3;
	}

观察 ThreadLocalMap 的构造函数，是当需要开始放进数据的时候，才会初始化。

代码【5】ThreadLocal.INITIAL_CAPACITY

INITIAL_CAPACITY 的注释，我标记了下。（见代码【1】）

~~什么叫 power-of-two ，这个要是说成两种的力量？功率？~~

~~听着感觉怎么和计算机也不挂钩，咱们去 google(baidu) 下。~~

能找到一个解释类似的解释： power() ：返回数字乘幂的计算结果。

咱们猜测下 power of two，是不是 2 的多少次方？

INITIAL_CAPACITY - 1 —> 16 - 1 = 15。

一个数好像不好说明问题，咱们多试几个 2ⁿ -1 来试试。看看能不能找到什么规律。

3 = 2² - 1 ; 7 = 2³ - 1 ; 15 = 2⁴ - 1; 31 = 2⁵ - 1 ; 63 = 2⁶ - 1

然后都换成 2 进制看看。（只看八位）

3 = 00000011 ; 7 = 00000111 ; 15 = 00001111 ; 31 = 00011111 ; 63 = 00111111

发现 0 和 1 很整齐嘛，仿佛是有某种规律，咱们来看下下一个。ThreadLocal.threadLocalHashCode.

代码【6】threadLocal.threadLocalHashCode


	public class ThreadLocal{
	    ……
	    //原来还是一个方法，那我们继续跳转。
	    private final int threadLocalHashCode = nextHashCode();
	    ……
	    //调用自身的自身的hasconde获取再增加。
	    private static int nextHashCode() {
	        return nextHashCode.getAndAdd(HASH_INCREMENT);
	    }
	    
	    private static AtomicInteger nextHashCode = new AtomicInteger();
		//一个累加的值，我换成二进制也没看出有啥规律
	    private static final int HASH_INCREMENT = 0x61c88647;
	    ……
	}
	
	public class AtomicInteger{
	    ……
	    //将原值，加上delta的值，并返回
	    public final int getAndAdd(int delta) {
	        return U.getAndAddInt(this, VALUE, delta);
	    }
	    ……
	}

不断累加 HASH_INCREMENT 作为自己的 hashCode。从刚刚的结果来看， INITIAL_CAPACITY - 1 得出了一堆 0 1 规律的数字，来观察下。

如果它与一个数进行 & 运算，高位的数据按位与 0 进行 & 计算，都是 0 ；低位数据按位与 1 进行 & 计算，都是原数据。

在这里插入图片描述
是不是这样就忽略高位，保留低位啦。这样就保证了 & 之后的数，是小于等于 len - 1 。刚好也是从 table[0] ~ table[len-1]。

刚分析了 map == null 的情况，来接下来分析下，如果 map != null 的情况。

代码【7】threadLocal.set()

	
	private void set(ThreadLocal<?> key, Object value) {
	    //指向ThreadLocalMap中的节点集合
	    Entry[] tab = table;//代码【8】
	    int len = tab.length;
	    //根据散列按位进行运算出 index。
	    int i = key.threadLocalHashCode & (len-1);
	    //从index往后循环查找。判断是先找到key，还是先碰到一个 table 中一个空的位置。
	    for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {//代码【9】
	        //如果从这个循环里结束，就说明是先找到对应的节点。
	        ThreadLocal<?> k = e.get();
	        //如果发现之前ThreadLocal存储过，则修改旧值后返回。
	        if (k == key) {
	            e.value = value;
	            return;
	        }
	        //如果是ThreadLocal == null，看名字是一些替换旧数据的操作并返回。
	        if (k == null) {
	            replaceStaleEntry(key, value, i);//代码【10】
	            return;
	        }
	    }
	
	    //如果走这，则说明先碰到 table 中空的位置，在index位置放进新数据。
	    tab[i] = new Entry(key, value);
	    int sz = ++size;
	    //看名字又是一些清除的操作,进行预警值的判断之后还有一次rehash()操作。
	    if (!cleanSomeSlots(i, sz) && sz >= threshold)
	        rehash();//代码【13】
	}

好吧，发现这次要分析的更多了（~~手动扎心~~ ），一个一个看。

代码【8】ThreadLocal.ThreadLocalMap.Entry


	//需要说明的就是，键是ThreadLocal类型，并且是弱引用的.
	static class Entry extends WeakReference<ThreadLocal<?>> {
		//Object 类型值
		Object value;
	
	    Entry(ThreadLocal<?> k, Object v) {
	        super(k);
	        value = v;
	    }
	}

来看个小例子，比如咱们先这么操作下，建两个 ThreadLocal。


	//新建两个ThreadLocal，并存放不同的类。
	ThreadLocal<String> t1 = new ThreaLocal();
	ThreadLocal<Integer> t2 = new ThreaLocal();
	
	//thread1 
	t1.set("One");
	t2.set(1);
	
	//thread2
	t1.set("Two");
	t2.set(2);
	
	//然后两个 Thread Entry[] tables 应该就差不多是这种.
	//thread1
	Entry[] table = [<t1,"One">,<t2,1>];
	//thread2
	Entry[] table = [<t1,"Two">,<t2,2>];
	
	//测试下，贴部分代码 安卓下测试的。
	protected void onCreate(Bundle savedInstanceState) {
	    super.onCreate(savedInstanceState);
	    setContentView(R.layout.activity_main);
	
	    //主线程设置一次
	    t1.set("One");
	    t2.set(1);
	    new Thread(new Runnable() {
	        @Override
	        public void run() {
	            //新开线程再设置一次
	            t1.set("Two");
	            t2.set(2);
	            //新线程取一次结果
	            Log.w(TAG, " new Thread t1.get() : " + t1.get() + " ; t2.get() : " + t2.get());
	        }
	    }).start();
	    //主线程再取一次结果
	    Log.w(TAG, "main Thread t1.get() : " + t1.get() + " ; t2.get() : " + t2.get());
	}

来运行看看结果。

	xxx.MainActivity:main Thread t1.get() : One ; t2.get() : 1
	xxx.MainActivity:new Thread t1.get() : Two ; t2.get() : 2

取值的时候就会先拿到对应线程的 ThreaLocalMap ,再通过对比 table 中每个节点中 key 的值，获得对应的值。

代码【9】ThreadLocal.nextIndex()


	private static int nextIndex(int i, int len) {
	    return ((i + 1 < len) ? i + 1 : 0);
	}

这个方法简单，小于长度时加 1 向后移动，不过那如果等于长度之后，就返回 0 .是不是可以理解为，向后一直循环，满了之后又从 0 开始，是一个循环的数组？

table[0] ~ table[len-1] —> table[0] 【 从 0 到末尾，又重新指向 0】

代码【10】threadLocal.replaceStaleEntry()


	private void replaceStaleEntry(ThreadLocal<?> key, Object value,int staleSlot) {
	    Entry[] tab = table;
	    int len = tab.length;
	    Entry e;
	
	    //先存放原计划 index
	    int slotToExpunge = staleSlot;
	    //向前循环寻找，是否存在节点的键为 null ，如果存在则向左一直查找并存储最靠左的 index，
	    //直到节点指向了一个 null 的位置，这个和之前的nextIndex()差不多。这个是向前循环
	    for (int i = prevIndex(staleSlot, len);(e = tab[i]) != null;i = prevIndex(i, len))
	        if (e.get() == null)
	            slotToExpunge = i;
	
	    //从原计划 index 向后查找
	    for (int i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = nextIndex(i, len)) {
	        ThreadLocal<?> k = e.get();
	        if (k == key) {
	            //如果判断是相同的key，则先替换旧值，将之前在原计划index的数据，移到key相等的位置
	            //再把替换过的节点插入到原计划index 以保证之前的hash顺序一致。如上的注释
	            e.value = value;
	            tab[i] = tab[staleSlot];
	            tab[staleSlot] = e;
	
	            //如果上一步向左扫描都没有节点键为null的情况，因为 staleSlot 目前没有改变
	            //反推如果 slotToExpunge == staleSlot 成立，
	            //则说明上一步向左扫描没有找到节点的键为null情况（碰到null节点前）
	            if (slotToExpunge == staleSlot)
	                slotToExpunge = i;
	            //将i的值作为清除的index传入，就是两种情况，左边有节点键为null的index，或者此处交换之后的index
	            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
	            return;
	        }
	        //如果没有找到，slotToExpunge 则等于从staleSlot右边算，第一个碰到节点键为null的index
	        if (k == null && slotToExpunge == staleSlot)
	            slotToExpunge = i;
	    }
	
	    //如果没有找到该ThreadLocal，则在原计划位置插入新Enrty
	    tab[staleSlot].value = null;
	    tab[staleSlot] = new Entry(key, value);
	
	    //如果两个数据不相等则说明右边存在键为null的Enrty，然后从那个index开始清除
	    if (slotToExpunge != staleSlot)
	    	//代码【11】expungeStaleEntry //代码【12】cleanSomeSlots
	        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
	}

好吧，长方法又来了 ……
在这里插入图片描述
不过 … 纵使困顿难行，亦当砥砺奋进嘛。

先存放最先计划替换的 index ，先向左查询，判断是否有键为 null 的节点，有的话，就替换一次 slotToExpunge 的值，一直查找存储最左边的，直到碰到 null 的位置。
向右查找，是否存在 key 相同的节点。
如果向右能找到，则替换节点 value ，并且与 staleSlot 位置进行交换，保证之前的散列顺序，然后从 slotToExpunge 开始清理。
如果不能找到，判断上一步是否在左边查找到键为 null 的节点，如果没有向左移动过，则从 staleSlot + 1 处开始清理。

如果没有找到节点，则在最开始位置进行插入数据，并判断是否需要清理
如果向左和向右查找的时候，都是正常的话，那么 staleSlot == staleToExpunge ，则不需要清理。
否则就从 slotToExpunge 开始清理。

好吧，文字描述了，估计还是有点抽象，还是来几张图好说明一下。先分析第一个循环，向左循环查找。
在这里插入图片描述
接下来分析后面的循环，向右循环查找。

关于 staleToExpunge ，只要它向左移动过之后，清理肯定是从左开始的，并且因为中间是连续的，所以与 staleSlot 的位置就没有关系了。

把这个拿下之后，就大概能明白清理的思路了，剩下就是分析清理的方法了 expungeStaleEntry() ， cleanSomeSlots() 。

代码【11】threadLocal.expungeStaleEntry()


	private int expungeStaleEntry(int staleSlot) {
	    Entry[] tab = table;
	    int len = tab.length;
	
	    //【注意】这里是先置空value，再置空key。
	    tab[staleSlot].value = null;
	    tab[staleSlot] = null;
	    size--;
	
	    Entry e;
	    int i;
	    //从要清除的 index 开始向后扫描
	    for (i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = nextIndex(i, len)) {
	        ThreadLocal<?> k = e.get();
	        //如果碰到节点键为null，会释放掉值，并置空table[i].调整table大小
	        if (k == null) {
	            e.value = null;
	            tab[i] = null;
	            size--;
	        } else {
	            int h = k.threadLocalHashCode & (len - 1);
	            //如果碰到键不为null，则会重新算出新index，如果不在原来的位置，置空原位置，就线性向后一直探测到null节点并放入
	            if (h != i) {
	                tab[i] = null;
	                //向后探测直到存在null的位置放入数据
	                while (tab[h] != null)
	                    h = nextIndex(h, len);
	                tab[h] = e;
	            }
	        }
	    }
	    return i;
	}

此处返回的 i，已经是 for 循环不成立的时候，就是碰到空节点的时候。

代码【12】threadLocal.cleanSomeSlots()

	
	private boolean cleanSomeSlots(int i, int n) {
	    boolean removed = false;
	    Entry[] tab = table;
	    int len = tab.length;
	    do {
	        i = nextIndex(i, len);
	        Entry e = tab[i];
	        if (e != null && e.get() == null) {
	            n = len;
	            removed = true;
	            i = expungeStaleEntry(i);
	        }
	    } while ( (n >>>= 1) != 0);
	    return removed;
	}

cleanSomeSlots() ，调用时传入的第一个参数为 expungeStaleEntry() 返回的空键节点 index，那么 cleanSomeSlots() 则从 index 下一个开始查找。

如果查找到的节点不为 null ，但是键为 null ，则从该处开始清理数据。
清理一次，则 n 向右移一位，table 大小缩小一半（ 1 变 0 肯定是不算哈）。

其实此处没太想通退出循环的条件是连续 logN 次没找到键为 null 的节点。

有个小细节：nextIndex 与 preIndex 为什么从 ±1 开始计算，而不是从传入的值计算，从方法的调用来看。
传入的一般是节点为 null 的 index ,如果直接从 index 开始进行循环查找，则直接就中断了。

代码【13】threadLocal.rehash()

此处为代码【7】中最后一处。


	private void rehash() {
	//清理所有老旧的数据（即键为null的节点。）
	    expungeStaleEntries();
	
	    //如果清理之后，仍大于预警值的3/4，则两倍扩容
	    if (size >= threshold - threshold / 4)
	        resize();
	}
	
	//循环查找清理
	private void expungeStaleEntries() {
	    Entry[] tab = table;
	    int len = tab.length;
	    for (int j = 0; j < len; j++) {
	        Entry e = tab[j];
	        if (e != null && e.get() == null)
	            expungeStaleEntry(j);
	    }
	}
	
	//双倍扩容
	private void resize() {
	    Entry[] oldTab = table;
	    int oldLen = oldTab.length;
	    int newLen = oldLen * 2;
	    Entry[] newTab = new Entry[newLen];
	    int count = 0;
	
	    for (int j = 0; j < oldLen; ++j) {
	        Entry e = oldTab[j];
	        if (e != null) {
	            ThreadLocal<?> k = e.get();
	            if (k == null) {
	                e.value = null; // Help the GC【帮助垃圾回收】
	            } else {
	                int h = k.threadLocalHashCode & (newLen - 1);
	                //向后线性探测null位置插入节点
	                while (newTab[h] != null)
	                    h = nextIndex(h, newLen);
	                newTab[h] = e;
	                count++;
	            }
	        }
	    }
	    //设置预警值
	    setThreshold(newLen);
	    size = count;
	    table = newTab;
	}

set 方法就差不多分析完了，真的是有点长，不过基本把前面的思路理清之后，后面的几个方法也没啥难度了。

说完 set 肯定是有 get 的。

代码【14】threadLocal.get()


	public T get() {
	    Thread t = Thread.currentThread();
	    ThreadLocalMap map = getMap(t);
	    if (map != null) {
	        //和set类似，如果ThreadLocalMap != null && ThreadLocalMap.get() != null 
	        //会根据键进行对应的查找，并向上转型为T返回。
	        ThreadLocalMap.Entry e = map.getEntry(this);
	        if (e != null) {
	            @SuppressWarnings("unchecked")
	            T result = (T)e.value;
	            return result;
	        }
	    }
	    //如果ThreadLocalMap == null 或者 ThreadLocalMap.get() == null.
	    //则进行返回初始化值
	    return setInitialValue();
	}
	
	//接下来看看初始化值是怎么回事
	private T setInitialValue() {
	    //默认返回null
	    T value = initialValue();
	    Thread t = Thread.currentThread();
	    //从线程t中查找是否ThreadLocalMap == null ？
	    ThreadLocalMap map = getMap(t);
	    if (map != null)
	        map.set(this, value);
	    else
	        createMap(t, value);
	    return value;
	}
	
	//说明第一次初始化时，都是 null，无论后面 map 是否为 null
	protected T initialValue() {
	    return null;
	}

createMap() 在代码【4】中已经分析过了。

map.set(this, value) 在代码【7】中已经分析过了。

接下来看 remove() 。

代码【15】threadLocal.remove()

	
	public void remove() {
	    //获取当前线程的ThreadLocalMao,如果存在则根据当前的ThreadLocal查找值
	    ThreadLocalMap m = getMap(Thread.currentThread());
	    if (m != null)
	        m.remove(this);
	}
	
	private void remove(ThreadLocal<?> key) {
	    Entry[] tab = table;
	    int len = tab.length;
	    //根据hash值算出index
	    int i = key.threadLocalHashCode & (len-1);
	    for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
	        if (e.get() == key) {
	            //找到节点后，清除该节点，并从从该位置向后清理
	            e.clear();
	            expungeStaleEntry(i);
	            return;
	        }
	    }
	}

到这基本就算分析完了，主要的是 replaceStaleEntry() 方法，如果把这个理解透的话，基本就差不多明白了。

留一个问题：前面一直在说节点键为 null 的情况，有没有反应过来什么情况下节点的键为 null ，如果没有反应过来的话。

可以去看下 ThreadLocalMap.Entry 看了构造函数之后应该就能明白了。

总结：

在每个线程中都存在一个 ThreadLocalMap ，它有一个节点数组 Entry<ThreadLocal,value>[]，每个 ThreadLocal 就是对应的键， T 就是对应的 value 类型。

ThreadLocal 会在插入新数据时会清理老旧的数据。如果不及时清理，一是影响了后续数据的插入，二是影响了 value 的回收。

其他容器类也存在长度为 2 的指数情况，通过 hash值 与 len - 1 来获取数据存放的 index 。

ThreadLocal 只是类似在每个线程都存放一个自己能使用的变量，如果你需要多个线程读写同一个数据，那么还是需要用锁机制或者 CAS 操作来保证数据的同步与正确性。

能力有限，可能存在一些问题或者不足之处，烦请指出，感谢。

要是觉得可以的话，麻烦点个赞表示支持。?

RamboPan

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
从 ThreadLocal 常见操作入手分析源码。

这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入欢迎使用Ma...
复制链接

扫一扫

专栏目录