ThreadLocal源码对于弱引用的应用

什么是ThreadLocal

threadlocal是一个线程内部的存储类，可以在指定线程内存储数据，数据存储以后，只有指定线程可以得到存储数据。

用法如下：

/**
 * ThreadLocal测试
 */
public class ThreadLocalTest {
    static ThreadLocal<Men> t1 = new ThreadLocal<>();

    public static void main(String[] args) {
        new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程1：" + t1.get());
        }).start();
        new Thread(() -> {
            t1.set(new Men());
            System.out.println("线程2：" + t1.get());
        }).start();
    }

    static class Men {
    }
}

很明显线程1是访问不到线程2所set的对象的

ThreadLocal源码

ThreadLocal的set方法源码：

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocal.ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

可以看到ThreadLocal的set方法是把ThreadLocal对象作为key插入到当前线程的ThreadLocalMap中

我们再看map.set方法源码：

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;
        int i = key.threadLocalHashCode & (len-1);

        for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) {
                        e.value = value;
                        return;
                }

                if (k == null) {
                        replaceStaleEntry(key, value, i);
                        return;
                }
        }

        tab[i] = new Entry(key, value);
        int sz = ++size;
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
}

在第81行我们可以看到实际储存的是一个Entry对象

再看一下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弱引用对象！将key用弱引用来指向！

为什么要用弱引用呢?

这是因为当ThreadLocal对象没有其他引用指向时，线程的ThreadLocalMap对象中的一个key是强引用指向的ThreadLocal对象，而线程的存活时间是很长的，因此ThreadLocal对象将一直回收不了
就导致了内存泄漏。
但是当使用了弱引用时，并且这个ThreadLocal对象没有其他引用指向，一旦发生垃圾回收，就会将这个对象回收掉，防止了内存泄漏。
关于弱引用可参考：https://blog.csdn.net/weixin_45702700/article/details/114189817