ThreadLocal

超、凢脫俗 2022-05-19 04:47 180阅读 0赞

# 以下大部分内容出自[https://www.jianshu.com/p/3f3620f9011d][https_www.jianshu.com_p_3f3620f9011d]和[https://www.iteye.com/topic/103804][https_www.iteye.com_topic_103804] #

**首先，ThreadLocal 不是用来解决共享对象的多线程访问问题的，一般情况下，通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象，其他线程是不需要访问的，也访问不到的。**各个线程中访问的是不同的对象。

Thread->ThreadLocalMap->Entry\[\]

ThreadLocalMap作为容器，放在线程里，ThreadLocalMap有个Entry\[\]数组，Entry由ThreadLocal对象和值构成。

ThreadLocal的get方法，就是先拿到当前线程里的threadLocalMap对象，再从Entry数组里，找到对应的ThreadLocal对象，返回里面的值。

# 如何使用ThreadLocal #

在介绍ThreadLocal原理之前，首先简单介绍一下它的使用方法。

public class Main{
        private ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
        
        public void start() {
            for (int i=0; i<10; i++) {
                new Thread(new Runnable(){
                    @override
                    public void run(){
                        threadLocal.set(i);
                        threadLocal.get();
                        threadLocal.remove();
                    }
                }).start();
            }
        }
    }

*  首先我们需要创建一个线程共享的ThreadLocal对象，该对象用于存储Integer类型的值；
 *  然后在每条线程中可以通过如下方法操作ThreadLocal：
    
     *  `set(obj)`：向当前线程中存储数据
     *  `get()`：获取当前线程中的数据
     *  `remove()`：删除当前线程中的数据

ThreadLocal的使用方法非常简单，关键在于它背后的实现原理。回到上面的问题：ThreadLocal究竟是如何避免同步锁，从而保证读写的高效？

# ThreadLocal实现原理 #

ThreadLocal的内部结构如下图所示：

![70][]

`ThreadLocal`并不维护`ThreadLocalMap`，并不是一个存储数据的容器，它只是相当于一个工具包，提供了操作该容器的方法，如get、set、remove等。而`ThreadLocal`内部类`ThreadLocalMap`才是存储数据的容器，并且该容器由`Thread`维护。

每一个`Thread`对象均含有一个`ThreadLocalMap`类型的成员变量`threadLocals`，它存储本线程中所有ThreadLocal对象及其对应的值。

`ThreadLocalMap`由一个个`Entry`对象构成，`Entry`的代码如下：

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

`Entry`继承自`WeakReference<ThreadLocal<?>>`，一个`Entry`由`ThreadLocal`对象和`Object`构成。由此可见，`Entry`的key是ThreadLocal对象，并且是一个弱引用，在gc的时候，就会被回收掉。

那么，ThreadLocal是如何工作的呢？下面来看set和get方法。

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }
    
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

当执行set方法时，ThreadLocal首先会获取当前线程对象，然后获取当前线程的ThreadLocalMap对象。再以当前ThreadLocal对象为key，将值存储进ThreadLocalMap对象中。

get方法执行过程类似。ThreadLocal首先会获取当前线程对象，然后获取当前线程的ThreadLocalMap对象。再以当前ThreadLocal对象为key，获取对应的value。

由于每一条线程均含有各自**私有的**ThreadLocalMap容器，这些容器相互独立互不影响，因此不会存在线程安全性问题，从而也无需使用同步机制来保证多条线程访问容器的互斥性。

# 为何要使用弱引用？ #

对弱引用不了解的同学可以参考笔者的另一篇文章：[http://blog.csdn.net/u010425776/article/details/50760053][http_blog.csdn.net_u010425776_article_details_50760053]。

Java设计之初的一大宗旨就是——弱化指针。  
Java设计者希望通过合理的设计简化编程，让程序员无需处理复杂的指针操作。然而指针是客观存在的，在目前的Java开发中也不可避免涉及到“指针操作”。如：

Object a = new Object();

上述代码创建了一个强引用a，只要强引用存在，垃圾收集器是不会回收该对象的。如果该对象非常庞大，那么为了节约内存空间，在该对象使用完成后，我们需要手动拆除该强引用，如下面代码所示：

a = null;

此时，指向该对象的强引用消除了，垃圾收集器便可以回收该对象。但在这个过程中，仍然需要程序员处理指针。为了弱化指针这一概念，弱引用便出现了，如下代码创建了一个Person类型的弱引用：

WeakReference<Person> wr = new WeakReference<Person>(new Person());

此时程序员不用再关注指针，只要没有强引用指向Person对象，垃圾收集器每次运行都会自动将该对象释放。

那么，ThreadLocalMap中的key使用弱引用的原因也是如此。当一条线程中的ThreadLocal对象使用完毕，没有强引用指向它的时候，垃圾收集器就会自动回收这个Key，从而达到节约内存的目的。

那么，问题又来了——这会导致内存泄漏问题！

# ThreadLocal的内存泄漏问题 #

在ThreadLocalMap中，只有key是弱引用，value仍然是一个强引用。当某一条线程中的ThreadLocal使用完毕，没有强引用指向它的时候I，这个key指向的对象就会被垃圾收集器回收，从而这个key就变成了null；然而，此时value和value指向的对象之间仍然是强引用关系，只要这种关系不解除，value指向的对象永远不会被垃圾收集器回收，从而导致内存泄漏！

不过不用担心，ThreadLocal提供了这个问题的解决方案。

每次操作set、get、remove操作时，ThreadLocal都会将key为null的Entry删除，从而避免内存泄漏。

那么问题又来了，如果一个线程运行周期较长，而且将一个大对象放入LocalThreadMap后便不再调用set、get、remove方法，此时该仍然可能会导致内存泄漏。

这个问题确实存在，没办法通过ThreadLocal解决，而是需要程序员在完成ThreadLocal的使用后要养成手动调用remove的习惯，从而避免内存泄漏。

试想如果不用ThreadLocal怎么来实现呢？可能就要在action中创建session，然后把session一个个传到service和dao中，这可够麻烦的。或者可以自己定义一个静态的map，将当前thread作为key，创建的session作为值，put到map中，应该也行，这也是一般人的想法，但事实上，ThreadLocal的实现刚好相反，它是在每个线程中有一个map，而将ThreadLocal实例作为key，这样每个map中的项数很少，而且当线程销毁时相应的东西也一起销毁了，不知道除了这些还有什么其他的好处。

# ThreadLocal的使用场景 #

Web系统Session的存储就是ThreadLocal一个典型的应用场景。

Web容器采用线程隔离的多线程模型，也就是每一个请求都会对应一条线程，线程之间相互隔离，没有共享数据。这样能够简化编程模型，程序员可以用单线程的思维开发这种多线程应用。

当请求到来时，可以将当前Session信息存储在ThreadLocal中，在请求处理过程中可以随时使用Session信息，每个请求之间的Session信息互不影响。当请求处理完成后通过remove方法将当前Session信息清除即可。

[https_www.jianshu.com_p_3f3620f9011d]: https://www.jianshu.com/p/3f3620f9011d
[https_www.iteye.com_topic_103804]: https://www.iteye.com/topic/103804
[70]: /images/20220519/93466e9b3cbc4a6991d78b5e3e392b34.png
[http_blog.csdn.net_u010425776_article_details_50760053]: https://link.jianshu.com?t=http%3A%2F%2Fblog.csdn.net%2Fu010425776%2Farticle%2Fdetails%2F50760053