ThreadLocal详解

最新推荐文章于 2024-03-07 05:00:00 发布

〖雪月清〗

最新推荐文章于 2024-03-07 05:00:00 发布

阅读量3.3k

点赞数 8

分类专栏： JUC 文章标签： Java ThreadLocal JUC 面试

本文链接：https://blog.csdn.net/qq_52595134/article/details/128758222

版权

JUC 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

ThreadLocal

1.ThreadLocal简介

ThreadLocal是一个通过线程隔离的方式解决多线程操作共享资源造成数据不一致问题的类。

ThreadLocal 通过在多线程环境下为每一个线程创建单独的变量副本，线程之间的变量副本互不影响，每个线程拥有自己的变量副本因此就不存在多线程间共享的问题，从而保证线程安全。（以空间换时间）

ThreadLocal维护的变量称为线程局部变量，该变量有两个特点：

每个线程内都有自己的线程局部变量，且只能访问自己的，不能访问其他线程的
ThreadLocal维护的变量被 private static修饰，当一个线程销毁时其所有的ThreadLocal变量都会被回收

ThreadLocal适用于每个线程需要自己独立的数据副本且可以在多个方法中使用，即变量在线程之间隔离而在方法或类之间共享的场景。

2.常用方法API

方法	说明
`get()`	返回当前线程的`ThreadLocal`变量副本中的值，如果当前线程没有该变量就调用初始化方法返回初始值
`set(T value)`	将当前线程的`ThreadLocal`变量副本中的值指定为value
`remove()`	移除当前线程的`ThreadLocal`变量

3.实现原理

ThreadLocal实现线程隔离的基本原理

ThreadLocal本身不存放数据，使用线程Thread中的threadLocals属性，（ThreadLocal是Thread中属性 threadLocals的管理者）threadLocals属性对应在ThreadLocal中定义的ThreadLocalMap对象。

在调用 ThreadLocal的set()方法时，会将自身的引用（this）作为key，用户传入的值作为value存入ThreadLocalMap中。这样每个线程的读写操作都是基于线程本身的一个私有的副本，线程之间的数据是相互隔离的 ，相互不影响。

1.get()方法

返回当前线程的ThreadLocal变量副本中的值，如果当前线程没有该变量就初始化为null返回，如果ThreadLocals属性没有被创建，就新创建一个ThreadLocalMap，并且创建一个ThreadLocal变量存入map中

    public T get() {
        // 获取当前线程 t 
        Thread t = Thread.currentThread();
        // 从当前线程t中获取threadlocals属性
        ThreadLocalMap map = getMap(t);
        // 如果不为null (已经初始化)
        if (map != null) {
            // 获取以当前ThreadLocal对象为key的值(如果不存在就创建一个ThreadLocal变量)
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                // 如果value不为null就返回
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //如果当前线程的threadlocals属性没有被创建，就调用setInitialValue()方法创建
        return setInitialValue();
    }

setInitialValue() 初始化方法

   private T setInitialValue() {
       // value赋值为初始化方法值, 默认为null可以进行方法重写
        T value = initialValue();
       // 获取当前线程t
        Thread t = Thread.currentThread();
       // 获取当前线程t的threadlocals属性也就是map集合
        ThreadLocalMap map = getMap(t);
       // map不为null 添加key - value
        if (map != null) {
            map.set(this, value);
        } else {
            // map为null，创建当前线程 t的 map并添加key - value
            createMap(t, value);
        }
        if (this instanceof TerminatingThreadLocal) {
            TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
        }
        return value;
    }

2.set() 方法

将当前线程的ThreadLocal变量副本中的值指定为value

public void set(T value) {
    // 获取当前线程t
    Thread t = Thread.currentThread();
    // 获取当前线程t的 threadLocals属性 即map
    ThreadLocalMap map = getMap(t);
    // map不为null，添加key - value
    if (map != null)
        map.set(this, value);
    // map为null,创建当前线程t的map并添加key - value
    else
        createMap(t, value);
}

3.remove()方法

移除当前线程的ThreadLocal变量

  public void remove() {
     // 获取当前线程的threadlocals属性 即map集合
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null) {
             // map不为null就将 ThreadLocal变量(this)移除
             m.remove(this);
         }
     }

4.ThreadLocalMap

ThreadLocalMap内部维护了一个Entry数组table来存储key - value，且 ThreadLocalMap没有实现Map接口，因此Entry数组并非链表形式，而是每个数组下标位置存储一个Entry

继承WeakReference类，表明ThreadLocal对象为弱引用

static class ThreadLocalMap {

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

        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
   
    private Entry[] table;
    /*
    .......
    */
    
}

ThreadLocalMap中的set()方法

向ThreadLocalMap中添加key - value

      private void set(ThreadLocal<?> key, Object value) {

            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            Entry[] tab = table;
            int len = tab.length;
          // 计算哈希值 与 数组下标 -1 得到key对应数组中的位置
            int i = key.threadLocalHashCode & (len-1);
         
            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不存在，那么直接将当前key- value存入数组
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
           
            tab[i] = new Entry(key, value);
            int sz = ++size;
          // 重哈希策略，采用 冲突位置的下一个空的位置存储 并且清理完无用条目(ThreadLocal被回收的      // 条目)、且数组中的数据大小 ≥ 阈值的时候对当前的Table进行重新哈希
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

getEntry()方法

根据key获取ThreadLocalMap中的Entry

        private Entry getEntry(ThreadLocal<?> key) {
            // 计算key对应的数组下标
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            // 如果数组下标i位置的Entry 不为null 且键等于当前key 返回Entry
            if (e != null && e.get() == key)
                return e;
            else
                // 否则 查找后续位置
                return getEntryAfterMiss(key, i, e);
        }

4.内存泄漏

ThreadLocal会造成内存泄漏

由于ThreadLocal对象是弱引用，如果没有外部的强引用指向，会导致ThreadLocal对象被回收，Entry中的key变为空，此时如果value没有外部引用指向，value就永远访问不到了，（按理应该被GC回收，但是由于Entry对象table数组还在强引用value）此时会发生内存泄漏，value成为永远无法访问但又永远无法回收的对象（除非线程被销毁，但是由于出于系统性能的考虑线程不宜频繁的创建和销毁，经常使用线程池，这样线程的生命周期变大，内存泄漏的影响就会变大）

造成内存泄漏的原因总结：

ThreadLocals对象中的Entry对象不再使用后，如果没有及时清除Entry对象，而程序自身也无法通过垃圾回收机制自动清除，就可能导致内存泄漏

避免内存泄漏

每次使用完ThreadLocal都调用remove()方法清除数据

将ThreadLocal变量定义为static final 避免频繁的创建ThreadLocal对象（比如可以单独创建一个until类使用ThreadLocal）

ThreadLocal内部的优化

调用set()方法时，会采样清理、全量清理，扩容时还会继续检查
调用get()方法时，没有直接命中、向后环形查找时会进行清理
调用remove()时，除了清理当前Entry，还会向后继续清理

5.Java中的四种引用

引用关系的强弱关系： 强引用 > 软引用 > 弱引用 > 虚引用

强引用
如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象
软引用
在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。（软引用可用来实现内存敏感的高速缓存,比如网页缓存、图片缓存等。使用软引用能防止内存泄露，增强程序的健壮性）
弱引用
具有弱引用的对象拥有的生命周期更短暂。当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。
虚引用
虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。

注意点：
虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。（其它引用是被JVM回收后才被加入ReferenceQueue中的。由于这个机制，所以虚引用大多被用于引用销毁前的处理工作。可以使用在对象销毁前的一些操作，比如说资源释放等。)

参考文章：
1.https://pdai.tech/md/java/thread/java-thread-x-threadlocal.html
2.https://blog.csdn.net/u010445301/article/details/111322569
3.https://blog.csdn.net/weixin_51626435/article/details/123681994

〖雪月清〗

关注

8
点赞
踩
15

收藏

觉得还不错? 一键收藏
打赏
0
评论
ThreadLocal详解

ThreadLocal是一个通过线程隔离的方式解决多线程操作共享资源造成数据不一致问题的类。ThreadLocal通过在多线程环境下为每一个线程创建单独的变量副本，线程之间的变量副本互不影响，每个线程拥有自己的变量副本因此就不存在多线程间共享的问题，从而保证线程安全。本文详解ThreadLocal的底层实现原理及内存泄漏问题。
复制链接

扫一扫