ThreadLocal

最新推荐文章于 2024-07-23 18:07:41 发布

Liao_Xiang

最新推荐文章于 2024-07-23 18:07:41 发布

阅读量145

点赞数

分类专栏：多线程

本文链接：https://blog.csdn.net/a2231476020/article/details/103567524

版权

多线程专栏收录该内容

16 篇文章 0 订阅

订阅专栏

参考文献：
ThreadLocal-面试必问深度解析
 手撕面试题ThreadLocal！！！

通常情况下，我们创建的变量是可以被任何一个线程访问并修改的。如果想实现每一个线程都有自己的专属本地变量该如何解决呢？ JDK中提供的ThreadLocal类正是为了解决这样的问题。 ThreadLocal类主要解决的就是让每个线程绑定自己的值，可以将ThreadLocal类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。

如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的本地副本，这也是ThreadLocal变量名的由来。他们可以使用 get() 和 set() 方法来获取默认值或将其值更改为当前线程所存的副本的值，从而避免了线程安全问题。

ThreadLocal用在什么地方？

讨论ThreadLocal用在什么地方前，我们先明确下，如果仅仅就一个线程，那么都不用谈ThreadLocal的，ThreadLocal是用在多线程的场景的！！！
ThreadLocal归纳下来就2类用途：

保存线程上下文信息，在任意需要的地方可以获取！！！
线程安全的，避免某些情况需要考虑线程安全必须同步带来的性能损失！！！

保存线程上下文信息，在任意需要的地方可以获取

由于ThreadLocal的特性，同一线程在某地方进行设置，在随后的任意地方都可以获取到。从而可以用来保存线程上下文信息。

常用的比如每个请求怎么把一串后续关联起来，就可以用ThreadLocal进行set，在后续的任意需要记录日志的方法里面进行get获取到请求id，从而把整个请求串起来。

还有比如Spring的事务管理，用ThreadLocal存储Connection，从而各个DAO可以获取同一Connection，可以进行事务回滚，提交等操作。

线程安全的，避免某些情况需要考虑线程安全必须同步带来的性能损失

ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。但是ThreadLocal也有局限性，我们来看看阿里规范：
在这里插入图片描述
每个线程往ThreadLocal中读写数据是线程隔离，互相之间不会影响的，所以ThreadLocal无法解决共享对象的更新问题！

Thread类中有一个ThreadLocalMap类型的成员变量：threadLocals

/* ThreadLocal values pertaining to this thread. 
This map is maintained by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocalMap为ThreadLocal的静态内部类
在这里插入图片描述
ThreadLocalMap

ThreadLocalMap的成员变量

// 初始值，必须是2的n次方
private static final int INITIAL_CAPACITY = 16;

// Entry数组，必要时可以扩容，长度是2的n次方
private Entry[] table;

// table中Entry的个数
private int size = 0;

// 扩容的临界值
private int threshold; // Default to 0

// Entry对象
static class Entry extends WeakReference<ThreadLocal<?>> {
	/** The value associated with this ThreadLocal. */
	Object value;

	Entry(ThreadLocal<?> k, Object v) {
		super(k);
		value = v;
	}
}

Entry继承自WeakReference（弱引用，生命周期只能存活到下次GC前），但只有Key是弱引用类型的，Value并非弱引用。

ThreadLocal#set

public void set(T value) {
	//获取当前线程
	Thread t = Thread.currentThread();
	// 1、获取当前线程上的map
	ThreadLocalMap map = getMap(t);
	//如果map不为null，则设置值
	if (map != null)
		//2、调用ThreadLocalMap#set
		map.set(this, value);
	else 
		// 3、map为null，初始化并设置值
		createMap(t, value);
}





// 1、ThreadLocal#getMap
//根据当前线程获取当前线程上的map
ThreadLocalMap getMap(Thread t) {
	return t.threadLocals;
}
//threadLocals定义在Thread中
ThreadLocal.ThreadLocalMap threadLocals = null;

当调用ThreadLocal对象的set方法的时候，会首先获取当前线程上的threadLocals
而我们创建ThreadLocal对象的时候（调用的空参构造器，并没初始化ThreadLocalMap）
即当前线程里的ThreadLocalMap成员变量threadLocals为null，此时才会创建ThreadLocalMap对象




// 3、ThreadLocal#createMap，参数为当前线程和要存入的值
void createMap(Thread t, T firstValue) {
	//初始化当前线程的map：threadLocals，参数this当前ThreadLocal对象
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

//构造方法
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
	//初始化table
    table = new Entry[INITIAL_CAPACITY];
    //计算索引
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    //设置值
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    //设置阈值
    setThreshold(INITIAL_CAPACITY);
}






// 2、ThreadLocal.ThreadLocalMap#set
private void set(ThreadLocal<?> key, Object value) {
	//获取当前的Entry数组
	Entry[] tab = table;
	//当前数组的长度
	int len = tab.length;
	//根据key通过hash后& (len-1)找到当前key在数组中的位置
	int i = key.threadLocalHashCode & (len-1);
	//从i位置开始遍历tab数组
	for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
		ThreadLocal<?> k = e.get();
		// 如果key相等，覆盖value
		if (k == key) {
			e.value = value;
			return;
		}
		//如果key为null,用新key、value覆盖，同时清理历史key=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.ThreadLocalMap#rehash
private void rehash() {
	expungeStaleEntries();// 清理一次陈旧数据
	// 清理完陈旧数据，如果>= 3/4阀值,就执行扩容，避免迟滞
	if (size >= threshold - threshold / 4)
		resize();
}
  
//ThreadLocal.ThreadLocalMap#expungeStaleEntries
//删除陈旧的数据
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)//entry不为空且entry的key为null
			expungeStaleEntry(j);//删除指定数组下标的陈旧entry
	}
}

//ThreadLocal.ThreadLocalMap#expungeStaleEntry
private int expungeStaleEntry(int staleSlot) {
	Entry[] tab = table;
	int len = tab.length;
	tab[staleSlot].value = null;//删除value
	tab[staleSlot] = null;//删除entry
	size--;//map的size自减

	// 遍历指定删除节点，所有后续节点
	Entry e;
	int i;
	for (i = nextIndex(staleSlot, len);(e = tab[i]) != null; i = nextIndex(i, len)) {
		ThreadLocal<?> k = e.get();
		if (k == null) {//key为null,执行删除操作
			e.value = null;
			tab[i] = null;
			size--;
		} else {//key不为null,重新计算下标
			int h = k.threadLocalHashCode & (len - 1);
			if (h != i) {//如果不在同一个位置
				tab[i] = null;//把老位置的entry置null(删除)
				// 从h开始往后遍历，一直到找到空为止，插入
				while (tab[h] != null)
				h = nextIndex(h, len);
				tab[h] = e;
			}
		}
	}
	return i;
}

//ThreadLocal.ThreadLocalMap#resize
//把table扩容2倍，并把老数据重新哈希散列进新table
private void resize() {
	Entry[] oldTab = table;
	int oldLen = oldTab.length;
	int newLen = oldLen * 2;
	Entry[] newTab = new Entry[newLen];
	int count = 0;
	// 遍历Entry[]数组
	for (int j = 0; j < oldLen; ++j) {
		Entry e = oldTab[j];
		if (e != null) {
			ThreadLocal<?> k = e.get();
			if (k == null) {// 如果key=null
				e.value = null; // 把value也置null,有助于GC回收对象
			} else {// 如果key！=null
				int h = k.threadLocalHashCode & (newLen - 1);// 计算hash值 
				while (newTab[h] != null)// 如果这个位置已使用
					h = nextIndex(h, newLen);// 线性往后查询，直到找到一个没有使用的位置,h递增
				newTab[h] = e;//在第一个空节点上塞入Entry e
				count++;// 计数++
			}
		}
	}
	setThreshold(newLen);// 设置新的阈值（实际set方法用了2/3的newLen作为阈值）
	size = count;// 设置ThreadLocalMap的元素个数
	table = newTab;// 把新table赋值给ThreadLocalMap的Entry[] table
}

ThreadLocal#get

public T get() {
    //同set方法类似获取对应线程中的ThreadLocalMap实例
    Thread t = Thread.currentThread();
    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();
}

//java.lang.ThreadLocal#setInitialValue
private T setInitialValue() {
    //获取初始化值，默认为null(如果没有子类进行覆盖)
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    //不为空不用再初始化，直接调用set操作设值
    if (map != null)
    	//ThreadLocal.ThreadLocalMap#set
        map.set(this, value);
    else
        //第一次初始化
        createMap(t, value);
    return value;
}

private ThreadLocal.ThreadLocalMap.Entry getEntry(ThreadLocal<?> key) {
    //根据key计算索引，获取entry
    int i = key.threadLocalHashCode & (table.length - 1);
    ThreadLocal.ThreadLocalMap.Entry e = table[i];
    if (e != null && e.get() == key)
        return e;
    else
        return getEntryAfterMiss(key, i, e);
}

/**
 * 通过直接计算出来的key找不到对于的value的时候适用这个方法.
 */
private ThreadLocal.ThreadLocalMap.Entry getEntryAfterMiss(ThreadLocal<?> key, int i, ThreadLocal.ThreadLocalMap.Entry e) {
    ThreadLocal.ThreadLocalMap.Entry[] tab = table;
    int len = tab.length;

    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        if (k == null)
            //清除无效的entry
            expungeStaleEntry(i);
        else
            //基于线性探测法向后扫描
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

ThreadLocal#remove

public void remove() {
	ThreadLocalMap m = getMap(Thread.currentThread());
	if (m != null)
		m.remove(this);
}

private void remove(ThreadLocal<?> key) {
    ThreadLocal.ThreadLocalMap.Entry[] tab = table;
    int len = tab.length;
    //计算索引
    int i = key.threadLocalHashCode & (len-1);
    //进行线性探测，查找正确的key
    for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        if (e.get() == key) {
            //调用weakrefrence的clear()清除引用
            e.clear();
            //连续段清除
            expungeStaleEntry(i);
            return;
        }
    }
}

简单测试

public class ThreadLocalTest2 {
    private static ThreadLocal<Integer> threadLocal1 = new ThreadLocal<>();
    private static ThreadLocal<String> threadLocal2 = new ThreadLocal<>();

    public static void main(String[] args) {
        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    /**
                     * set是set进当前线程的ThreadLocalMap，key是ThreadLocal对象
                     * 所以一个ThreadLocal对象连续调用set()方法时，会覆盖已经保存的值
                     * 如果一个线程要保存多个本地线程变量，则应该使用多个ThreadLocal对象
                     */
                    threadLocal1.set(i);
                    threadLocal2.set(i+"_@");
                    System.out.println(Thread.currentThread().getName() + "：数字——" + threadLocal1.get());
                    System.out.println(Thread.currentThread().getName() + "：字符——" + threadLocal2.get());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } finally {
                threadLocal1.remove();
                threadLocal2.remove();
            }
        }, "线程1").start();

        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + "：" + threadLocal1.get());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } finally {
                threadLocal1.remove();
            }
        }, "线程2").start();
    }
}
线程1：数字——0
线程1：字符——0_@
线程2：null
线程2：null
线程1：数字——1
线程1：字符——1_@
线程2：null
线程1：数字——2
线程1：字符——2_@
线程2：null
线程1：数字——3
线程1：字符——3_@
线程2：null
线程1：数字——4
线程1：字符——4_@
线程1：数字——5
线程1：字符——5_@
线程2：null
线程2：null
线程1：数字——6
线程1：字符——6_@
线程2：null
线程1：数字——7
线程1：字符——7_@
线程2：null
线程1：数字——8
线程1：字符——8_@
线程2：null
线程1：数字——9
线程1：字符——9_@

弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，该对象仅仅被弱引用关联，那么就会被回收。

当仅仅只有ThreadLocalMap中的Entry的key指向ThreadLocal的时候，ThreadLocal会被进行回收，ThreadLocal被垃圾回收后，在ThreadLocalMap里对应的Entry的键值会变成null，但是Entry是强引用，那么Entry里面存储的Object，并没有办法进行回收，所以ThreadLocalMap 做了一些额外的回收工作。
在这里插入图片描述
由于线程的生命周期很长，如果我们往ThreadLocal里面set了很大很大的Object对象，虽然set、get等等方法在特定的条件会调用进行额外的清理，但是ThreadLocal被垃圾回收后，在ThreadLocalMap里对应的Entry的键值会变成null，但是后续在也没有操作set、get等方法了，应该在我们不使用的时候，主动调用remove方法进行清理。

这里把ThreadLocal定义为static还有一个好处就是，由于ThreadLocal有强引用在，那么在ThreadLocalMap里对应的Entry的键会永远存在，那么执行remove的时候就可以正确进行定位到并且删除

Liao_Xiang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ThreadLocal

通常情况下，我们创建的变量是可以被任何一个线程访问并修改的。如果想实现每一个线程都有自己的专属本地变量该如何解决呢？ JDK中提供的ThreadLocal类正是为了解决这样的问题。 ThreadLocal类主要解决的就是让每个线程绑定自己的值，可以将ThreadLocal类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。如果你创建了一个ThreadLocal变量，那么访问这个变量的...
复制链接

扫一扫

专栏目录