ThreadLocal与ThreadLocalMap源代码剖析

ThreadLocal类

此类关键用以不一样进程储存自身的进程当地自变量。文中先根据一个实例简易详细介绍此类的操作方法，随后从ThreadLocal类的复位、存储结构、删改数据信息和hash值测算等好多个层面，剖析相匹配源代码。选用的版本号为jdk1.8。

ThreadLocal-操作方法

ThreadLocal目标能够 在好几个进程中被应用，根据set()方式设定进程当地自变量，根据get()方式获得设定的进程当地自变量。大家先根据一个实例简易掌握下操作方法：

public static void main(String[] args){
    ThreadLocal<String> threadLocal = new ThreadLocal<>();
    // 进程1
    new Thread(()->{
        // 查询是不是有初值
        System.out.println("进程1的初值:" threadLocal.get());
        // 设定进程1的值
        threadLocal.set("V1");
        // 輸出
        System.out.println("进程1的值:" threadLocal.get());
        // 等候一段时间，等进程2设定值后再查询进程1的值
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("进程1的值:" threadLocal.get());
    }).start();
    // 进程2
    new Thread(()->{
        // 等候进程1设定初值
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 查询进程2的初值
        System.out.println("进程2的值:" threadLocal.get());
        // 设定进程2的值
        threadLocal.set("V2");
        // 查询进程2的值
        System.out.println("进程2的值:" threadLocal.get());
    }).start();
}

因为threadlocal设定的值是在每一个进程上都有一个团本的，进程中间不容易相互之间危害。程序执行的結果以下所显示：

进程1的初值:null
进程1的值:V1
进程2的值:null
进程2的值:V2
进程1的值:V1

ThreadLocal-复位

ThreadLocal类只有一个无参的构造函数，以下所显示：

/**
 * Creates a thread local variable.
 * @see #withInitial(java.util.function.Supplier)
 */
public ThreadLocal() {
}

但实际上还有一个带主要参数的构造函数，不过是它的派生类。ThreadLocal中界定了一个内部类SuppliedThreadLocal，为承继自ThreadLocal类的派生类。能够 根据此类开展给出初值的复位，其界定以下：

static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {

        private final Supplier<? extends T> supplier;

        SuppliedThreadLocal(Supplier<? extends T> supplier) {
            this.supplier = Objects.requireNonNull(supplier);
        }

        @Override
        protected T initialValue() {
            return supplier.get();
        }
    }

根据TheadLocal threadLocal = Thread.withInitial(supplier);那样的句子能够 开展给出初值的复位。在某一进程第一次启用get()方式时，会实行initialValue()方式设定进程自变量为传到supplier中的值。

public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
        return new SuppliedThreadLocal<>(supplier);
    }

ThreadLocal-存储结构

在jdk1.8版本号中，应用的是TheadLocalMap这一个器皿储存进程当地自变量。

该器皿的设计方案观念和HashMap有很多相同之处。例如：內部界定了Entry连接点储存键值对（应用ThreadLocal目标做为键）；应用一个二维数组储存entry连接点；设置一个阀值，超出阀值时开展扩充；根据键的hash值与数组长度开展&实际操作明确字符数据库索引等。但也是有许多不同点，实际我们在事后详细介绍ThreadLocalMap类时再深入分析。

static class 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;
            }
        }
    // 储存原素的二维数组    
    private Entry[] table;
    // 器皿内原素总数
    private int size = 0;
    // 阀值
    private int threshold; // Default to 0
    // 改动和加上原素
    private void set(ThreadLocal<?> key, Object value){
        ...
    }
    // 清除原素
    private void remove(ThreadLocal<?> key) {
        ...
    }
    ...
}

ThreadLocal-删改数据信息

ThreadLocal类给予了get(),set()和remove()方式来实际操作当今进程的threadlocal自变量团本。最底层则是根据ThreadLocalMap器皿来完成数据信息实际操作。

但是要留意的是：ThreadLocal中并沒有ThreadLocalMap的成员函数，ThreadLocalMap目标是Thread类中的一个组员，因此 必须根据根据当今进程的Thread目标去获得该器皿。

每一个进程Thread目标都是会有一个map器皿，该器皿会伴随着进程的结束而收购 。

设定进程当地自变量的方式。

public void set(T value) {
    // 获得当今进程相匹配的Thread目标，其是map键值对中的健
    Thread t = Thread.currentThread();
    // 获得当今进程目标的器皿map
    ThreadLocalMap map = getMap(t);
    // 假如器皿不以null,则立即设定原素。不然用进程目标t和value去复位器皿目标
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

// 根据当今进程的进程目标获得器皿
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

// 建立map器皿，实质是复位Thread目标的成员函数threadLocals
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

获得进程当地自变量的方式。

public T get() {
    // 获得当今进程目标
    Thread t = Thread.currentThread();
    // 获得当今进程目标的器皿map
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        // 假如器皿不以null且器皿内有当今threadlocal目标相匹配的值，则回到该值
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 假如器皿为null或是器皿内沒有当今threadlocal目标关联的值，则先设定初值并回到该初值
    return setInitialValue();
}

// 设定初值。关键分成二步:1.载入和获得初值;2.在器皿中设定该初值。
// 第二步实际上和set(value)方式完成一模一样。
private T setInitialValue() {

    // 载入并获得初值,默认设置是null。如果是带参复位的派生类SuppliedThreadLocal，会有一个键入初值。
    // 自然还可以承继ThreadLocal类调用该方式设定初值
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    // 假如器皿不以null,则立即设定原素。不然用进程目标t和value去复位器皿目标
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

清除进程当地自变量的方式

public void remove() {
    // 假如器皿不以null就启用器皿的清除方式，清除和该threadlocal关联的自变量
     ThreadLocalMap m = getMap(Thread.currentThread());
     if (m != null)
         m.remove(this);
 }

ThreadLocal-hash值测算

ThreadLocal的hash值用以ThreadLocalMap器皿测算数组下标。类中界定threadLocalHashCode表明其hash值。类中界定了静态方法和静态数据分子自变量测算hash值，换句话说全部的threadLocal目标同用一个提高器。

// 当今ThreadLocal目标的hash值
private final int threadLocalHashCode = nextHashCode();

// 用于测算hash值的分子自变量，全部的threadlocal目标同用一个提高器
private static AtomicInteger nextHashCode = new AtomicInteger();

// 法术数据，使hash散列匀称
private static final int HASH_INCREMENT = c061c88647;

// 测算hash值的静态方法
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

大家应用一样的方式界定一个检测类，界定好几个不一样检测类目标，看一下hash值的转化成状况。以下所显示，能够 见到hash值都不一样，是同用的一个提高器。

public class Test{

    private static final int HASH_INCREMENT = c061c88647;
    public static AtomicInteger nextHashCode = new AtomicInteger();
    public final int nextHashCode = nextHashCode();
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }
    public static void main(String[] args){
        for (int i = 0; i < 5; i  ) {
            Test test = new Test();
            System.out.println(test.nextHashCode);
        }
    }
    // 輸出的hash值
    0
    1640531527
    -1013904242
    626627285
    -2027808484
}

ThreadLocalMap类

ThreadLocalMap类是ThreadLocal的内部类。其做为一个器皿，为ThreadLocal给予实际操作进程当地自变量的作用。每一个Thread目标上都会有一个ThreadLocalMap目标案例(成员函数threadLocals，初值为null)。由于map是Thread目标的非公共性组员，不容易被高并发启用，因此 无需考虑到高并发风险性。

后文将从数据储存设计方案、复位、删改数据信息等层面剖析相匹配源代码。

ThreadLocalMap-数据储存设计方案

该map和hashmap相近，应用一个Entry二维数组来储存连接点原素，界定size自变量表明当今器皿中原素的总数,界定threshold自变量用以测算扩充的阀值。

// Entry二维数组
private Entry[] table;

// 器皿内原素数量
private int size = 0;

// 扩充测算用阀值
private int threshold;

不一样的是Entry连接点为WeakReference类的派生类，应用引入字段名做为键，将弱引用字段名（一般是ThreadLocal目标）合值关联在一起。应用弱引用是为了更好地促使threadLocal目标能够 被收购 ，(假如将key做为entry的一个成员函数，那进程消毁前，threadLocal目标不容易被收购 掉，即便 该threadLocal目标不会再应用）。

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

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

ThreadLocalMap-复位

给予了带原始键和初值的map构造函数，还有一个根据现有map的构造函数(用以ThreadLocal的派生类InheritableThreadLocal复位map器皿，目地是将父进程的map传到子进程，会在建立子进程的全过程中全自动实行）。以下所显示：

// 根据原始键值的构造方法
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    // 根据键入键值搭建连接点
    table = new Entry[INITIAL_CAPACITY];
    // 依据键的hash值测算所属数组下标
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    // 选用懒加载的方法，只建立一个必需的连接点
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    // 设定阀值为原始长短的2/3，原始长短默认设置为12，那麼阀值为8
    setThreshold(INITIAL_CAPACITY);
}

// 根据现有map的构造方法
private ThreadLocalMap(ThreadLocalMap parentMap) {
    // 获得传到map的连接点二维数组
    Entry[] parentTable = parentMap.table;
    int len = parentTable.length;
    setThreshold(len);
    // 结构同样长短的二维数组
    table = new Entry[len];
    // 深拷贝传到二维数组中每个连接点到当今器皿二维数组
    // 留意这儿由于选用对外开放详细地址处理hash矛盾，复制后的原素在二维数组中的部位与原二维数组不一定同样
    for (int j = 0; j < len; j  ) {
        // 获得二维数组每个部位上的连接点
        Entry e = parentTable[j];
        if (e != null) {
            @SuppressWarnings("unchecked")
            ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
            if (key != null) {
                //保证 key为InheritableThreadLocal种类，不然抛出去UnsupportedOperationException
                Object value = key.childValue(e.value);
                Entry c = new Entry(key, value);
                // 依据hash值和数组长度，测算字符
                int h = key.threadLocalHashCode & (len - 1);
                // 这儿选用对外开放详细地址的方式处理hash矛盾
                // 当发生争执时，就顺延到二维数组下一位，直至该部位沒有原素 
                while (table[h] != null)
                    h = nextIndex(h, len);
                table[h] = c;
                size  ;
            }
        }
    }
}

ThreadLocalMap-清除原素

这儿将清除原素的方式放到前边，是由于其他一部分会经常应用落伍连接点的清除方式。先了解这一部分內容有利于事后了解别的一部分。

依据key清除器皿原素的方式：

 private void remove(ThreadLocal<?> key) {
    // 测算数据库索引字符
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);
    // 从字符i处逐渐向后找寻是不是有key相匹配连接点，直至碰到Null连接点
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        // 假如碰到key相匹配连接点，实行清除实际操作
        if (e.get() == key) {
            // 清除连接点的键（弱引用）
            e.clear();
            // 清除该落伍连接点
            expungeStaleEntry(i);
            return;
        }
    }
}

清除落伍连接点的实行方式:
清除落伍连接点除开将该连接点置为null以外，还需要对该连接点以后的连接点开展挪动，看一下能否向前找适合的空格符迁移。

这类方式有点儿相近jvm垃圾分类回收优化算法的标识-梳理方式。全是将废弃物消除以后，将剩下原素开展梳理，越来越更紧密。这儿的梳理是必须申请强制执行的，目地是为了更好地确保对外开放详细地址法一定能在持续的非null连接点块中寻找现有连接点。(设想，假如把落伍连接点清除而不梳理，该连接点为null，将前后左右连接点分离了。而假如后边有某一连接点hash测算的字符在前面的连接点块，在搜索连接点时根据对外开放详细地址会找不着该连接点)。平面图以下：

private int expungeStaleEntry(int staleSlot) {
    // 获得entyy二维数组和长短
    Entry[] tab = table;
    int len = tab.length;

    // 消除staltSlot连接点的值的引入，消除连接点的引入
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    // 器皿原素数量-1
    size--;

    // 消除staleSlot连接点后的梳理工作中
    // 将staleSlot数据库索引后的连接点测算字符向前插空挪动
    Entry e;
    int i;
    // 解析xml持续的非null连接点，直至碰到null连接点
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        // case1:假如解析xml到的连接点是落伍连接点，将该连接点消除，器皿原素总数-1
        if (k == null) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            // case2：假如解析xml到的连接点并不是落伍连接点，再次测算字符
            int h = k.threadLocalHashCode & (len - 1);
            // 时下标并不是所在位置时，从hash值测算的字符h处，对外开放详细地址往后面延期插空
            if (h != i) {
                // 先将该连接点置为null
                tab[i] = null;

                // 寻找为null的连接点，插进连接点
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

清除全部落伍连接点的方式：非常简单，全局性解析xml，清除全部落伍连接点。

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);
    }
}

试着去扫描仪一些落伍连接点并消除连接点，如果有连接点被消除会回到true。这儿只实行了logn次扫描仪分辨，是为了更好地在没有扫描仪和全局性扫描仪中间寻找一种均衡，是上边的方式的一个均衡。

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;
            // 从该持续块后第一个null连接点逐渐
            i = expungeStaleEntry(i);
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

ThreadLocalMap-获得原素

获得器皿原素的方式：

// 依据key迅速搜索entry连接点
private Entry getEntry(ThreadLocal<?> key) {
    // 根据threadLocal目标(key)的hash值测算数组下标
    int i = key.threadLocalHashCode & (table.length - 1);
    // 取相匹配字符原素
    Entry e = table[i];
    if (e != null && e.get() == key)
        return e;
    else
        // 搜索不上有二种状况：
        // 1.相匹配字符桶位为空
        // 2相匹配字符桶位原素并不是key关系的entry(对外开放详细地址处理hash矛盾造成的)
        return getEntryAfterMiss(key, i, e);
}

// 第一次搜索不成功后再度搜索entry连接点
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    // 获得entry二维数组及长短
    Entry[] tab = table;
    int len = tab.length;
    // 假如e为null，表明相匹配字符桶位为空，找不着key相匹配的entry
    // 假如e不以null,则用处理hash矛盾时的方式(延期二维数组下一位)一直找下来，直至寻找或e为null
    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        // 在找寻的全过程中假如连接点的key,即ThreadLocal早已被收购 (被弱引用的目标很有可能会被收购 )
        // 则清除落伍的连接点,清除落伍连接点的方式剖析见清除原素一部分
        if (k == null)
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    // 沒有寻找，回到null
    return null;
}

ThreadLocalMap-提升和改动原素

提升和改动器皿原素的方式:
这儿在依据hash值测算出字符后，因为是对外开放详细地址处理hash矛盾，会次序向后解析xml直至碰到null或碰到key相匹配的连接点。

这儿会发生三种状况:

case1:遍历经找到key相匹配连接点,这时候立即修改节点的值就可以；

case2:解析xml中碰到了有落伍的连接点(key被收购 的连接点)；

case3:解析xml沒有碰到落伍的连接点，都没有寻找key相匹配连接点，表明这时应当插进新连接点（用键入键值结构新连接点）。由于是提升新元素，因此 能够 容积会超出阀值。在删掉连接点后容积假如超出阀值，则要开展扩充实际操作。

private void set(ThreadLocal<?> key, Object value) {
    // 获得二维数组，测算key相匹配的数组下标
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);

    // 从字符i逐渐，次序遍历数组(沿着hash矛盾对外开放详细地址的途径),直至连接点为null
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        // 获得解析xml到的连接点的key
        ThreadLocal<?> k = e.get();
        // case1:击中key，表明已存有key相匹配连接点，改动value值就可以
        if (k == key) {
            e.value = value;
            return;
        }
        // case2:假如解析xml到的连接点的key为null，表明该threadLocal目标早已被收购 
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    // case3:解析xml连接点直至null也没有寻找相匹配key，表明map中沒有key相匹配entry
    // 则在该部位用键入键合值新创建一个entry连接点
    tab[i] = new Entry(key, value);
    int sz =   size;
    // 分辨是不是清除落伍连接点后，在分辨是不是必须扩充
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

case2:提升和改动全过程中碰到早已落伍的连接点的解决。这儿的主要参数staleSlot表明key测算的字符逐渐往后面碰到的第一个落伍连接点，无论map中有没有key相匹配的连接点，该部位以后一定会存进key的连接点。这儿界定了一个自变量slotToExpunge，其含意是上下持续非null的entry块中第一个落伍连接点（纪录该部位是为了更好地事后消除落伍连接点能够 从slotToExpunge处逐渐）。提示以下：

这步实际操作有二种状况:

casse2.1:从落伍连接点staleSlot往后面搜索碰到key相匹配连接点，则将staleSlot处连接点与key相匹配连接点互换。随后消除梳理持续块。

casse2.2:没碰到key相匹配连接点，表明map中不会有key相匹配连接点，则新创建一个连接点填写staleSlot处。随后消除梳理持续块。

private void replaceStaleEntry(ThreadLocal<?> key, Object value,int staleSlot) {
    // 获得entry二维数组和长短
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    // 向前挪动找寻第一个落伍连接点(直至碰到null)，假如没找到得话表明第一个落伍连接点为staleslot处连接点
    // slotToExpunge表明持续块中第一个落伍连接点
    int slotToExpunge = staleSlot;
    for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;

    // 从键入字符staleSlot向后寻找第一个发生的key相匹配的连接点或落伍的连接点(key被收购 的连接点)
    for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        // case2.1:假如寻找key相匹配的连接点，则用staleSlot处连接点和该连接点互换，以维持hash表的次序(hash矛盾时次序向后找寻)
        // 互换后的staleSlot连接点以及以前的落伍连接点会被消除
        if (k == key) {
            // 互换staleSlot处连接点和key相匹配连接点
            e.value = value;

            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;
            // 升级slotToExpunge的值，使其维持持续块中第一个落伍连接点的特点，便捷事后清除落伍连接点。
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            // 从slotToExpunge逐渐消除梳理持续块
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

       // 假如碰到落伍连接点，升级slotToExpunge的值
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // case2.2:沒有寻找key相匹配连接点，提升新连接点并填写staleSlot处
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);
    // 这儿假如slotToExpunge=staleSlot，表明持续块中只有一个落伍连接点，且早已被新创建连接点填写，就不用再梳理。
    // 假如除开原staleSlot处,也有其他落伍连接点，从slotToExpunge逐渐消除梳理持续块
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

case3:提升原素后很有可能超出阀值造成的扩充解决

private void rehash() {
    // 消除全部落伍连接点
    expungeStaleEntries();

    // 在消除全部落伍连接点后，假如总数超出3/4的阀值，则开展扩充解决
    // setThreshold()方式人民团体，threshold值一直为数组长度的2/3,因此 这儿是超出数组长度一半就开展扩充
    if (size >= threshold - threshold / 4)
        resize();
}

/**
 * 二倍扩充
 */
private void resize() {
    // 获得旧二维数组和长短
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    // 新数组长度为原先的二倍
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    int count = 0;
    // 解析xml原二维数组原素
    for (int j = 0; j < oldLen;   j) {
        Entry e = oldTab[j];
        // 假如为非null连接点
        if (e != null) {
            ThreadLocal<?> k = e.get();
            // 如果是落伍连接点，则将value置为null,能够 促使value的实体线尽早被收购 
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                // 如果是一切正常连接点，测算字符，再次填写新二维数组(对外开放详细地址处理hash矛盾)
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                // 新二维数组原素数量 1
                count  ;
            }
        }
    }
    // 再次设定阀值
    setThreshold(newLen);
    size = count;
    // 将自变量table偏向新二维数组
    table = newTab;
}

ThreadLocalMap-内存泄露难题及其对设计方案的一些思索

先来聊一聊内存泄漏这一定义。我的理解是有一块存储空间，假如不会再被应用但又不可以被垃圾分类回收器收购 掉，那麼就等同于这方面运行内存少了这方面室内空间，即发生了内存泄露难题。假如内存泄露的室内空间一直在累积，那麼最后会造成可以用室内空间一直降低，最后很有可能造成程序流程没法运作。

ThreadLocalMap中也是有可能会发生该难题的，map中entry连接点的key为弱引用，假如key沒有其他强引入，是会被废弃物回收器收购 的。收购 以后，map中该连接点的value就不容易再被应用，但value又被entry连接点强引入，不容易被收购 。这就等同于value这方面存储空间发生了泄漏。因此 能见到在源代码中许多方式都开展了消除落伍连接点的实际操作，为的便是尽量减少内存泄漏。

在看源代码时，一直在思索为何entry连接点的键要选用弱引用的方法。何不相反思索，假如entry连接点将threadLocal目标做为一个成员函数，而不是选用弱引用的方法，那麼entry连接点一直对key和value维持着强引入关联，即便 threadlocal目标在其他地区都不会再应用,该目标也不会被收购 。这便会造成entry连接点始终不容易被收购 (只需进程不结束)，并且也不可以积极去分辨是不是断开map中threadlocal目标的引入（不清楚是不是也有其他地区引入到）。

由于map是Thread目标的一个成员函数，进程不结束，map是不容易被收购 的，假如发生了内存泄露的难题，很有可能会一直累积下来，最后造成程序流程产生出现异常。而key选用弱引用加上积极的分辨落伍连接点(分辨是不是落伍非常简单，看key是不是为null就可以)并开展消除解决能够 最大限度的降低内存泄露的产生。