Java 笔记之 ThreadLocal

JI,XIAOYONG原创...大约 4 分钟

ThreadLocal是Thread中用来保存线程私有变量的数据结构。

一个ThreadLocal只能保存一个值，有set/get/remove方法。

在Thread有一个threadLocals（ThreadLocal.ThreadLocalMap）变量，该变量是一个定制的 Hash Map，用来保存线程私有的数据（类型为ThreadLocal<?> Key, Object Value）。

特点

一个Thread可以有多个ThreadLocal变量
不同Thread可以通过一个ThreadLocal变量分别保存不同的变量而互不影响。
如果不同的Thread使用的ThreadLocal变量保存的是同一个引用类型的对象（假设为obj），无论这些Thread使用的是同一个ThreadLocal对象还是完全不同的ThreadLocal对象，只要obj指向的对象改变，其余线程中的ThreadLocal对象也会访问到obj的最新值。

使用与解析

当我们新建一个ThreadLocal并为之赋值时

// 方式 1.
ThreadLocal threadLocal = new ThreadLocal();
threadLocal.set("value");
//方式 2.
ThreadLocal threadLocal2 = new ThreadLocal(){
            @Override
            protected Object initialValue() {
                return "initial value";
            }
        };

这个时候就会调用set()方法（方式 1）或者setInitialValue()方法（方式 2）。

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);//注意这里获取到是线程本身的 threadLocals 对象
        if (map != null)
            map.set(this, value);//ThreadLocal 对象只是在 Thread 所属的 threadLocals 中充当一个 key，
            //所以即使在其他线程执行 threadLocal.set(value);
            //也只是更新该线程本身的 threadLocal 对应的 value，而不会影响其他线程分毫！！！（好精巧的设计）
        else
            createMap(t, value);
    }

    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

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

    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

可以看到这两个方法到最后都相当于调用了Thread对象的threadLocals的set(ThreadLocal<?> key, Object value)方法，这个方法最终以ThreadLocal对象为 KEY，将数据保存到了Thread对象自己的threadLocals中。

private Entry[] table;

private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    //其他逻辑...
    tab[i] = new Entry(key, value);
}

所以即使是同一个ThreadLocal对象，在不同的线程中进行set/get/remove都只是更新了本线程中ThreadLocal对象对应的值。

        //MainThread
        final ThreadLocal threadLocal = new ThreadLocal();
        threadLocal.set("THREAD-Main-"+Thread.currentThread().getName());
        System.out.println("THREAD-Main-BEFORE:"+threadLocal.get());//THREAD-Main-BEFORE：THREAD-Main-main

        new Thread(new Runnable() {
            public void run() {
                threadLocal.set("THREAD-1-"+Thread.currentThread().getName());
                System.out.println("THREAD-1:"+threadLocal.get());//THREAD-1：THREAD-1-Thread-0
            }
        }).start();


        new Thread(new Runnable() {
            public void run() {
                System.out.println("THREAD-2:"+threadLocal.get());//THREAD-2：null
                //本线程中 threadLocal 没有赋值，所以为 null
            }
        }).start();

        //MainThread
        System.out.println("THREAD-Main-AFTER:"+threadLocal.get());//THREAD-Main-AFTER：THREAD-Main-main
        //其他线程对 threadLocal 对象的操作不会影响本线程
        //但是如果 threadLocal 保存的是一个引用类型的对象，并且这个对象在其他线程被更改，那么本线程获取到的也会是变更后的值
    }

内存泄漏

在ThreadLocal.ThreadLocalMap中，最终用来保存ThreadLocal以及对应值的是一个Entry数组：

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

            Entry(ThreadLocal<?> k, Object v) {
                super(k);//对 ThreadLocal 对象的弱引用
                value = v;
            }
        }

从上面的代码可以看到，Entry对ThreadLocal是弱引用，按照“强软弱虚”引用的等级来划分，每次 GC 的时候，如果这个ThreadLocal对象没有被引用，就会被回收掉，这时如果该Thread还在运行，那么threadLocals中保存的ThreadLocal<?> k已经被回收了，但是Object v对象仍然保存在threadLocals中但是没有办法再访问到，造成内存泄漏。

解决方法参考：

使用ThreadLocal时会发生内存泄漏的前提条件：
①ThreadLocal引用被设置为null，且后面没有set，get,remove操作。
② 线程一直运行，不停止。（线程池）
③ 触发了垃圾回收。（Minor GC 或 Full GC）
我们看到ThreadLocal出现内存泄漏条件还是很苛刻的，所以我们只要破坏其中一个条件就可以避免内存泄漏，单但为了更好的避免这种情况的发生我们使用ThreadLocal时遵守以下两个小原则：
①ThreadLocal申明为private static final。 Private与final 尽可能不让他人修改变更引用， Static 表示为类属性，只有在程序结束才会被回收。
②ThreadLocal使用后务必调用remove方法。最简单有效的方法是使用后将其移除。
版权声明：本文为 CSDN 博主「pony-zi」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/zzg1229059735/article/details/82715741

总结

现在我们知道了，所谓的通过ThreadLocal实现线程本地变量与其他线程隔离，是在创建ThreadLocal的时候，保存的就是属于当前线程的独立的变量，并且之后的修改也不会（无法）修改到其他线程中对应的值，但如果ThreadLocal本身保存的都是同一个对象，则这个对象在所有的线程中还是共享的。