ThreadLocal（深入源码分析）

最新推荐文章于 2024-06-12 23:05:18 发布

questions？

最新推荐文章于 2024-06-12 23:05:18 发布

阅读量117

点赞数 1

分类专栏： # java并发编程文章标签： java 多线程内存泄漏

本文链接：https://blog.csdn.net/weixin_45593271/article/details/119052431

版权

java并发编程专栏收录该内容

16 篇文章 0 订阅

订阅专栏

文章目录

案例
使用场景
强，软，弱，虚引用（看源码会用到）
内部结构
设计的好处
主要方法
源码（一定要把内部结构看懂再看）
内存泄漏

ThreadLocal作用是让 每一个线程都独有一份空间来存储自己需要的变量，这份变量 对其它线程不可见！
因为之前 线程都是共享进程的资源嘛，如果要 线程独有自己的资源就需要ThreadLocal，并且这个变量生命周期和线程生命周期一样。

案例

public class MyDemo {

    private static ThreadLocal<String> tl = new ThreadLocal<>();
    //一个类型可以理解为，如果要存储多个变量，则需要定义多个这个

    private String content;

    private String getContent() {
        return tl.get();
    }

    private void setContent(String content) {
        tl.set(content);
    }

    public static void main(String[] args) {
        MyDemo demo = new MyDemo();
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    demo.setContent(Thread.currentThread().getName() + "的数据");
                    System.out.println("-----------------------");
                    System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());
                }
            });
            thread.setName("线程" + i);
            thread.start();
        }
    }
}

在这里插入图片描述

使用场景

每个线程需要一个独享的对象，例如JDBC的Connection，如果不隔离，多个线程共用一个连接，可能会导致B线程提交了A线程不应该提交的事务，或回滚了本来应该提交的事务。（加锁也可，但是非常影响性能）。还有Mybatis的分页场景，Spring的事务管理。
当前用户信息需要被线程内所有方法共享，即减少变量作为参数传递的复杂度

强，软，弱，虚引用（看源码会用到）

强引用
Object obj = new Object();中的obj就是强引用，通过关键字new创建的普通对象都是强引用
只要强引用指向一个对象，就能表明对象还存在，垃圾收集器就不会碰这种对象
对于一个普通的对象，如果没有其他的引用关系，或者显示的将强引用赋值为null，就可以被垃圾回收收集了
软引用（SoftReference）
软引用生命周期比强引用短一些
当JVM认为内存不足时，会去试图回收软引用指向对象
如果JVM认为内存空闲，会暂时保留软引用（可用于缓存场景）
弱引用（WeakReference）
弱引用的生命周期比软引用更短，在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了具有弱引用的对象，无论当前内存空间是否不足，都会回收它的内存
ThreadLocalMap里面的Entry就是弱引用

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

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

幻象引用（虚引用）（PhantomReference）
幻象引用用是最弱的一种引用关系，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，它随时可能会被回收，它只有一个构造函数和一个 get() 方法，而且它的 get() 方法仅仅是返回一个null，也就是说将永远无法通过虚引用来获取对象，虚引用必须要和 ReferenceQueue 引用队列一起使用（专门用来管理堆外内存）

弱引用案例

public class ReferenceExample {
    static Object object=new Object();
    public static void main(String[] args) {
//        Object strongRef=object; //强引用
     //   SoftReference<Object> softReference=new SoftReference<>(object);//软引用
        WeakReference<Object> objectWeakReference=new WeakReference<>(object);//弱引用
        object=null;
        System.gc();
        System.out.println(objectWeakReference.get());
       // System.out.println(softReference.get());
    }
}

输出结果为空

内部结构

在这里插入图片描述

每个Thread维护一个ThreadLocalMap，这个Map的key是ThreadLocal实例本身（公共变量，即上面的tl），value才是真正要存储的值Object。

每个Thread线程内部都有一个Map (ThreadLocalMap)
Map里面存储ThreadLocal对象（key）和线程的变量副本（value）
Thread内部的Map是由ThreadLocal维护的，由ThreadLocal负责向map获取和设置线程的变量值。
对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。

设计的好处

这个设计与早期的设计刚好相反，早期设计每个ThreadLocal都创建一个Map，然后用线程作为Map的key，要存储的局部变量作为Map的value。

现在的设计有如下两个优势：

这样设计之后每个Map存储的Entry数量就会变少。因为之前的存储数量由Thread的数量决定，现在是由ThreadLocal的数量决定。在实际运用当中，往往ThreadLocal的数量要少于Thread的数量。（键越少，冲突越少）
当Thread销毁之后，对应的ThreadLocalMap也会随之销毁，能减少内存的使用。（直接销毁整个Map，如果是原来的设计，线程结束后，如果是采用线性探测，还不敢删除Map里面对应的键值）

主要方法

由上图可知

set()
在当前线程的ThreadLocalMap内，设置一个值存储到里面中，这个值的表现形式是entry对象（key，value形式）key是ThreadLocal实例本身（公共变量，即上面的tl），值是value。有点绕画图理解比较好
相当于在当前线程范围内建立了副本。
get()
从当前线程的ThreadLocalMap内取出当前ThreadLocal类型的值.
remove()
从当前线程的ThreadLocalMap内移除当前ThreadLocal类型的值.
withInitial
java8中的初始化方法

源码（一定要把内部结构看懂再看）

set方法

public void set(T value) {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        // 判断map是否存在
        if (map != null)
            // 存在则调用map.set设置此实体entry，传递this，就是传递key即这种类型的ThreadLocal
            map.set(this, value);
        else
            // 1）当前线程Thread 不存在ThreadLocalMap对象
            // 2）则调用createMap进行ThreadLocalMap对象的初始化
            // 3）并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
            createMap(t, value);
    }

     /**
     * 获取当前线程Thread对应维护的ThreadLocalMap 
     * 
     * @param  t the current thread 当前线程
     * @return the map 对应维护的ThreadLocalMap 
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;//这个threadLocals就是当前线程的ThreadLocalMap 
    }


/**
     *创建当前线程Thread对应维护的ThreadLocalMap 
     *
     * @param t 当前线程
     * @param firstValue 存放到map中第一个entry的值
     */
	void createMap(Thread t, T firstValue) {
  //这里的this是调用此方法的threadLocal，创建好以后赋值给线程的ThreadLocalMap的引用指针即threadLocals 
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }


/**
createMap调用构造方法，真正创建，并且赋值
*/
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];//默认长度为16的数组
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);//计算当前数组下标
            table[i] = new Entry(firstKey, firstValue);//把key/value存储到i的位置
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }


/**
真正干事的set，即ThreadLocalMap的set，这里的set有第一次set和更改第一次set的两种情况
*/
    private void set(ThreadLocal<?> key, Object value) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);//通过key计算数组下标


//e!=null说明是当前位置已经有人了，哈希冲突了或者就是想要的位置但是有原来的值
//采用线性探索，解决哈希冲突问题
            for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) 
            {
                ThreadLocal<?> k = e.get();
                // 就是想要的位置但已经存在了值， 就直接替换。
                if (k == key) {
                    e.value = value;
                    return;
                }
               
//此位置的key为空，说明ThreadLocal成员变量回收掉了，那么用新元素替换陈旧的元素
//这样相当于进行了垃圾清理动作，防止内存泄漏
                if (k == null) {
                    replaceStaleEntry(key, value, i);//这个代码，见下面
                    return;
                }
            }
            //如果当前位置没有，就是第一次设置，直接干就完了
            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

get方法

/**
     * 返回当前线程中保存ThreadLocal的值
     * 如果当前线程没有此ThreadLocal变量，
     * 则它会通过调用{@link #initialValue} 方法进行初始化值
     *
     * @return 返回当前线程对应此ThreadLocal的值
     */
    public T get() {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        // 如果此map存在
        if (map != null) {
            // 以当前的ThreadLocal 为 key，调用getEntry获取对应的存储实体e
            ThreadLocalMap.Entry e = map.getEntry(this);
            // 对e进行判空 
            if (e != null) {
                @SuppressWarnings("unchecked")
                // 获取存储实体 e 对应的 value值
                // 即为我们想要的当前线程对应此ThreadLocal的值
                T result = (T)e.value;
                return result;
            }
        }
        /*
        	初始化 : 有两种情况有执行当前代码
        	第一种情况: map不存在，表示此线程没有维护的ThreadLocalMap对象
        	第二种情况: map存在, 但是没有与当前ThreadLocal关联的entry
         */
         
        //如果之前没有使用set，则可能通过withInitial这个方法这条线来进行初始化的
        //可通过匿名内部类的方法完成初始化，也可继承ThreadLocal重写initialValue
        //如果这个也不是，直接创建好Map再返回空
        return setInitialValue();
    }

    /**
     * 初始化
     *
     * @return the initial value 初始化后的值
     */
    private T setInitialValue() {
        // 调用initialValue获取初始化的值
        // 此方法可以被子类重写, 如果不重写默认返回null
        T value = initialValue();
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        // 判断map是否存在
        if (map != null)
            // 存在则调用map.set设置此实体entry
            map.set(this, value);
        else
            // 1）当前线程Thread 不存在ThreadLocalMap对象
            // 2）则调用createMap进行ThreadLocalMap对象的初始化
            // 3）并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
            createMap(t, value);
        // 返回设置的值value
        return value;
    }

remove方法

/**
     * 删除当前线程中保存的ThreadLocal对应的实体entry
     */
     public void remove() {
        // 获取当前线程对象中维护的ThreadLocalMap对象
         ThreadLocalMap m = getMap(Thread.currentThread());
        // 如果此map存在
         if (m != null)
            // 存在则调用map.remove
            // 以当前ThreadLocal为key删除对应的实体entry
             m.remove(this);
     }


//真正干活的remove方法
 private void remove(ThreadLocal<?> key) {
            Entry[] tab = table;
            int len = tab.length;
            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;
                }
            }
        }

内存泄漏

不考虑线程退出的情况下，如果不想用某个ThreadLocal对象了，正常应该是将它的引用置为空，但如果ThreadLocalMap里面的entry是强引用，就回收不了，因为始终有entry也作为强引用指向该ThreadLocal对象。所以entry应该使用弱引用。
但使用弱引用仍然可能出现内存泄漏，因为entry指向的ThreadLocal对象被回收了，value不能访问了，但数据还在！所以我们使用时应该养成好习惯，不再使用的时候调用remove()这样value也会移除掉，避免内存溢出。
此外还有一种危险是，如果线程是线程池的，在线程执行完代码的时候并没有结束，只是归还给线程池，这个时候ThreadLocalMap 和里面的元素是不会回收掉的。所以记住线程池里面的线程执行完后，一定要清理掉threadlocals（即ThreadLocalMap ）！

questions？

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ThreadLocal（深入源码分析）

文章目录案例使用场景强，软，弱，虚引用（看源码会用到）内部结构设计的好处主要方法源码（一定要把内部结构看懂再看）set方法get方法remove方法内存泄漏ThreadLocal作用是让每一个线程都独有一份空间来存储自己需要的变量，这份变量对其它线程不可见！因为之前线程都是共享进程的资源嘛，如果要线程独有自己的资源就需要ThreadLocal，并且这个变量生命周期和线程生命周期一样。案例public class MyDemo { private static ThreadLocal<
复制链接

扫一扫