ThreadLocal原理解析-六虎

ThreadLocal信任咱们日常开发中都常常使用。下面咱们看几个常见的问题，看看咱们是否对它足够了解。

问题

ThreadLocal存储在jvm的安全教育平台登录哪个区域
为线程和进程的区别是什么安全生产法什么jvm垃圾回收机制用Entry数组而jvm垃圾收回机制不是En测试你适合学心理学吗try对测线程池的七个参数验工程师象
ThreadLocal里的目标一定是线程安全的吗
为什么Entry k线程池的七个参数ey设计成弱引证
会导致内存走漏么数组指针
Thread、Thread线程的几种状况Local、ThreadLocalMap、数组Entry在内存中的联系安全期计算器是什么样的

假如以上问题，你都知道，能够忽略本文。

内存联系整理

首先咱们new 一个ThreadLocal目标

public class ThreadLocalTest {
    public static void main(String[] args) {
        ThreadLocal<String> threadLocal = new ThreadLocal<>();
    }
}

此刻内存联系如图

往ThreadLocal里面set一个值,一起检查相关源码

public class ThreadLocalTest {
    public static void main(String[] args) {
        ThreadLocal<String> threadLocal = new ThreadLocal<>();
        threadLocal.set("1"); //从这儿进入看源码
    }
}
=======以下为ThreadLocal源码===========================
public void set(T value) {
    //1.获取当时运转的线程（demo里面为main线程）
    Thread t = Thread.currentThread();
    //获取t.threadLocals字段（ThreadLocalMap目标）
    ThreadLocalMap map = getMap(t);
    //此刻map为null，走else逻辑
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}
voidcreateMap(Threadt,TfirstValue){
    //2.创立ThreadLocalMap目标，赋值给t.threadLocals。key为当时threadLocal，value为"1"。
    t.threadLocals=newThreadLocalMap(this,firstValue);
}
//ThreadLocalMap的构造函数
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    //3.新建Entry数组
    table = new Entry[INITIAL_CAPACITY];
    //计算数组下标
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    //4.新建Entry目标，放入数组对应位置
    table[i] = new Entry(firstKey, firstValue);
    //数组里面元素个数
    size = 1;
    //设置扩容阈值
    setThreshold(INITIAL_CAPACITY);
}
//Entry类界说
static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;
    Entry(ThreadLocal<?> k, Object v) {
        //5.key为弱引证
        super(k);
        value = v;
    }
}

依据测试工程师上面源码中，符号的1测验你数组去重方法的自卑程度~5点，咱们内存图变成了下面测试的样子。

一句话总结便是：Thread维护了Thre线程池的七个参数adLocalMap，ThreadLocalMap里维护了Entry数组，而Entry里存的是以ThreadLocal（弱引证）为key，传入的值为value的键值对。

说完了set办法，咱们看看调用get办法怎么获取对应的线程池面试题值。

public T get() {
    //获取当时线程
    Thread t = Thread.currentThread();
    //经过线程目标获取ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        //获取key为threadLocal对应的Entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}
private Entry getEntry(ThreadLocal<?> key) {
    //获取数组下标
    int i = key.threadLocalHashCode & (table.length - 1);
    //取得数组对应元素
    Entry e = table[i];
    if (e != null && e.get() == key)
        //返回key为threadLocal对应的Entry
        return e;
    else
        return getEntryAfterMiss(key, i, e);
}

get办法获取值大概图示数组排序

全部看上去很美好。可是弱引证只需发生GC，引证链就会断掉。所以内存变为如下图。

这个时分咱们是不是会有线程是什么意思个疑问，调用g安全期计算器et办法的时分，是否能正确取得对应的值。咱们写一个小De数组词mo来测验一下。

public class WeakRefTest {
    public static void main(String[] args) throws InterruptedException {
        //Foo(1)目标只有弱引证
        WeakReference<Foo> wr1 = new WeakReference<>(new Foo(1));
        //Foo(2)目标有弱引证和强引证（这种状况和ThreadLocal相似）
        Foo foo = new Foo(2);
        WeakReference<Foo> wr2 = new WeakReference<>(foo);
        System.out.println("gc前wr1 "+wr1.get());
        System.out.println("gc前wr2 "+wr2.get());
        System.gc();
        Thread.sleep(100);
        System.out.println("gc后wr1 "+wr1.get());
        System.out.println("gc后wr2 "+wr2.get());
    }
    static class Foo{
        public int a;
        Foo(int a){
            this.a = a;
        }
        @Override
        public String toString() {
            return "Foo{" +
                    "a=" + a +
                    '}';
        }
    }
}
运转成果
gc前wr1 Foo{a=1}
gc前wr2 Foo{a=2}
gc后wr1 null
gc后wr2 Foo{a=2}

依据上面Demo运转状况数组词，咱们画一下内存数组c语言图。 GC前

wr1，w测试抑郁症r2都能正常拜访。

GC后

wr1为null，wr2能正常拜访。

定论：引证的断开不会影响咱们引证的寻址功用安全模式jvm垃圾收回机制。引证的断开只会导致引证链断开导致目标被GC收回，可是！此刻若有一个强引证引证着，那么弱引证就能够在无引证链的状况下持续拜访该目标。（这儿扩展一下。若目标的地址强制改动，弱引证将无法持续盯梢）

经过上面的Demo安全生产法咱们回安全教育手抄报数组排序头看看ThreadLocal的内存图，能得知就算引证链断裂，get()办法也能取得值。

为什么ThreadLocalMap中的key要设置成弱引证

public class ThreadLocalTest {
    public static void main(String[] args) {
        ThreadLocal<String> threadLocal = new ThreadLocal<>();
        threadLocal.set("1");
        threadLocal = null;
    }
}

上面的代码块咱们期望经过设置threadLocal=null，然后让threadL数组和链表的区别ocal被收回。测验工程师假设此刻不用弱引证，内存如下图

假如使测验手机是否被监控用弱引证，ThreadLocal对数组去重办法象就能被正确的收回。这便是使用弱引证jvm内存的原因。

Entry的key内存走漏

咱们将threadLocal成功收回后，内数组存图画出来

如上图，数组去重方法由于咱们将Thr安全eadLocal目标的成功收回，咱们的key变为null了。可是安全工程师咱们的value依旧存在，因而这一组数据的valu线程池面试题e由于key为null的原因也无法拜访导致内存走漏。

ThreadLocal针对内存走漏的优化

//set办法优化
private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);
    //遇到hash抵触的时分，沿着数组向后遍历
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
        if (k == key) {
            e.value = value;
            return;
        }
        //发现为null的key，直接替换之前的值
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    tab[i] = new Entry(key, value);
    int sz = ++size;
    //cleanSomeSlots办法，看看有没有为null的key需要整理
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}
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;
            //发现key为null,删去对应的entry
            i = expungeStaleEntry(i);
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}
//get办法优化
public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        //获取entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}
private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    if (e != null && e.get() == key)
        return e;
    else
        //处理key为null的状况
        return getEntryAfterMiss(key, i, e);
}
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;
    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        if (k == null)
            //发现key为null,删去对应的entry
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}
//remove办法
public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}
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) {
            //key设置为null
            e.clear();
            //删去对应的entry
            expungeStaleEntry(i);
            return;
        }
    }
}

remove是咱们自动触发，整理Entry的线程池的七个参数方式。能够加快咱们走漏的内存收回。因而，假如当栈中的引证数组公式变为null时，咱们能够再次调用r测试用例emove()办法，将ThreadLocalMap中数组词的Entry进行整理。（更具时效性）

线线程池程退出时优化

private void exit() {
    if (group != null) {
        group.threadTerminated(this);
        group = null;
    }
    /* Aggressively null out all reference fields: see bug 4006245 */
    target = null;
    /* Speed the release of some of these resources */
    //threadLocalMap的引证断了，加快收回
    threadLocals = null;
    inheritableThreadLocals = null;
    inheritedAccessControlContext = null;
    blocker = null;
    uncaughtExceptionHandler = null;
}

最终咱们回头看文章最初提出的问题（只有2，3没有在文中直接回答，其他都已经有了答案）

为什么用E安全期计算器ntry数jvm原理组而不是数组排序Entry目标

由于你业务代码能new好多个ThreadLocal目标。可是一个安全生产法线程里，ThreadLocalMap是同一个，而不是多个，不管你n线程和进程的区别是什么ew安全教育手抄报几回ThreadLocal，ThreadLocalMap数组c语言在一个线程里就一个，由于ThreadLocalMap的引证是在Thr线程ead里的，所以它里面的Entry数组存放的是jvm性能调优一个线程里你new出来的多个ThreadLocal目标。

ThreadLocal里的目标一定是线程安全的吗

未必，假如在每个线程中T安全教育手抄报hreadLocal.set()进去的东西本来便是多线程共享的同一个目标，比方static目标，那么多个线程的ThreadLoc测验线程池抑郁程度的问卷al.get()获取的仍是这个共享目标自身，仍是有并发拜访线程不安全问题。

ThreadLocal原理解析

问题

相关文章

深入理解Spring的@Async注解：实现异步方法调用

一文搞定 Spring Security 异常处理机制！

Spring事务的7大传播特性是如何实现的

写好业务代码的经典案例

作者信息