理解ThreadLocal和底层实现

清疚 2023-07-25 11:26 17阅读 0赞

## 一、定义 ##

1.  从jdk的官方文档中的描述：ThreadLocal类是用来提供放线程内部的局部变量，这样变量在多线程环境下访问（通过set和get访问）时能保证各个线程间的变量相对独立于其他线程内的变量。ThreadLocal实例通常来说都是private static 类型的，用来关联线程和线程上下文。
2.  我们可以得知ThreadLocal的作用是提供线程内的局部变量，不同的线程之间不会相互干扰。这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度。
3.  总结：线程并发，传递数据，线程隔离

## 二、方法 ##

ThreadLocal() ：创建ThreadLocal对象  
public void set(T value)：设置当前线程绑定的局部变量  
public T get()：获取当前线程绑定的局部变量  
public void remove()：移除当前线程绑定的局部变量

## 三、测试 ##

public class TestDemo1 {
        public String content;
    
        public String getContent() {
            return content;
        }
    
        public void setContent(String content) {
            this.content = content;
        }
    
        public static void main(String[] args) {
            TestDemo1 demo1 = new TestDemo1();
            for(int i =0 ;i<5; i++){
                Thread thread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        demo1.setContent(Thread.currentThread().getName()+"的数据");
                        System.out.println("--------------------");
                        System.out.println(Thread.currentThread().getName()+"--->"+demo1.getContent());
                    }
                });
                thread.setName("线程"+i);
                thread.start();
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTUwNzMyNA_size_16_color_FFFFFF_t_70]  
这里可以发现我们每次去运行main方法后的结果都是不一样的，这就是多线程下的线程安全问题。

下面修改代码用ThreadLocal来保存线程的变量：  
public class TestDemo1 \{  
public String content;

ThreadLocal<String> t1 = new ThreadLocal<>();
    
    public String getContent() {
       // return content;
        return t1.get();
    }
    
    public void setContent(String content) {
        //this.content = content;
        t1.set(content);
    }
    
    public static void main(String[] args) {
        TestDemo1 demo1 = new TestDemo1();
        for(int i =0 ;i<5; i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    demo1.setContent(Thread.currentThread().getName()+"的数据");
                    System.out.println("--------------------");
                    System.out.println(Thread.currentThread().getName()+"--->"+demo1.getContent());
                }
            });
            thread.setName("线程"+i);
            thread.start();
        }
    }

\}  
结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTUwNzMyNA_size_16_color_FFFFFF_t_70 1]

## 四、比较ThreadLocal和synchronized ##

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>synchronized</th> 
   <th>ThreadLocal</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>原理</td> 
   <td>同步机制采用了‘以时间换空间’的方式，只提供了一份变量各个线程排队访问</td> 
   <td>采用‘以空间换时间’的方式，为每一个线程都提供一份变量副本，从而实现同时访问而不互相干扰</td> 
  </tr> 
  <tr> 
   <td>侧重点</td> 
   <td>多个线程之间访问资源的同步</td> 
   <td>多线程中让每个线程的数据相互隔离</td> 
  </tr> 
 </tbody> 
</table>

总结：我们可以通过测试发现运用同步关键字也可以实现线程的安全，但是两者处理的角度是不一样的，运用同步关键字synchronized 其实就时给访问资源加上了锁，实现了各个线程之间的串行化，大大降低了并发执行的效率，程序运行时间变长。

## 五、ThreadLocal实现原理 ##

threadLocal.set()方法的源码：  
ThreadLocal.java

public void set(T value) {	
    		//获取当前线程的map
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null)
            //以当前的ThreaLocal的引用作为key
                map.set(this, value);
            else
                createMap(t, value);  //创建map
        }

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

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

Thread.java源码：

ThreadLocal.ThreadLocalMap threadLocals = null;

代码执行流程：

1.  首先获取当前线程，并根据当前线程获取一个map
2.  如果获取的map不为空，则将value值设置到map中（以当前ThreadLocal的引用作为key）
3.  如果map为空，则给该线程创建map,并设置初始值

jdk8的get方法源码 ：

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

代码执行流程：

1.  首先获取当前线程，并根据当前线程获取一个map
2.  如果获取的map不为空，则在map中以ThreadLocal的引用作为key来在对应的map中获取对应的Entry e
3.  如果e不为null,则返回e.value
4.  map为空或者e为空，则通过initalValue函数获取初始值value,然后用ThreadLocal的引用和value作为firstkey和firstvalue创建一个map

代码执行流程：先获取当前线程的ThreadLocalMap变量，如果存在则返回值，不存在则创建并返回初始值。

remove()方法源码：

public void remove() {
             ThreadLocalMap m = getMap(Thread.currentThread());
             if (m != null)
                 m.remove(this);
         }

代码执行流程：  
首先获取当前线程，并根据当前线程获取一个map  
如果获取的map不为空，则移除当前ThreadLocal对象的entry

## 六、ThreadLocalMap ##

1.  基本结构  
    ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，用独立的方式实现了Map的功能，其内部的Entry也是独立实现。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTUwNzMyNA_size_16_color_FFFFFF_t_70 2]
2.  源码：

static class ThreadLocalMap {
    
            /**
             * The entries in this hash map extend WeakReference, using
             * its main ref field as the key (which is always a
             * ThreadLocal object).  Note that null keys (i.e. entry.get()
             * == null) mean that the key is no longer referenced, so the
             * entry can be expunged from table.  Such entries are referred to
             * as "stale entries" in the code that follows.
             */
            static class Entry extends WeakReference<ThreadLocal<?>> {
                /** The value associated with this ThreadLocal. */
                Object value;
    
                Entry(ThreadLocal<?> k, Object v) {
                    super(k);
                    value = v;
                }
            }
    
            /**
             * The initial capacity -- MUST be a power of two.
             */
            private static final int INITIAL_CAPACITY = 16;
    
            /**
             * The table, resized as necessary.
             * table.length MUST always be a power of two.
             */
            private Entry[] table;
    
            /**
             * The number of entries in the table.
             */
            private int size = 0;
    
            /**
             * The next size value at which to resize.
             */
            private int threshold; // Default to 0

这里可以看到ThreadLocalMap是ThreadLocal的一个静态内部类。根HashMap类似，成员变量：INITIAL\_CAPACITY代表map的初始容量（必须是2的整次幂），table是一个Entry类型的数组用于存储数据，size代表表中的存储数目，threshold代表需要扩容时size的阈值。

1.  存储结构Entry

/**
    Entry继承WeakReference，并且用ThreadLocal作为key,
    如果key为null（entry.get()==null）,意味着key不在被引用,
    因此table也可以从table中删除
    **/
    static class Entry extends WeakReference<ThreadLocal<?>> {
                /** The value associated with this ThreadLocal. */
                Object value;
    
                Entry(ThreadLocal<?> k, Object v) {
                    super(k);
                    value = v;
                }
            }

总结：

1.  在ThreadLocalMap 中，也是用Entry来保存key-value结构数据的，不过Entry中的key只能是ThreadLocal对象，这点在构造方法中已经限定死了。
2.  另外Entry继承WeakReference弱引用，也就是key(ThreadLocal)是弱引用，其目的是将ThreadLocal的生命周期与线程的生命周期解绑。

## 七、Entry的key的强弱引用及内存泄漏 ##

强引用（Strong Reference）：就是我们最常见的普通对象引用，只要还有强引用指向一个对象，就表明对象还活着，垃圾回收器就不会回收这种对象（即使堆空间不够用了发生了内存溢出）  
软引用(softReference)：在堆空间不够用的时候即使有引用指向对象，该对象也会被回收。  
弱引用（weekReference）：垃圾回收器一旦发现只持有弱引用的对象，不管当前内存空间足够与否都会被回收（一看到就回收）  
虚引用：(涉及知识比较多暂时不说)

通过源码分析可以知道key的引用是一个弱引用，这里假设如果是强引用会出现怎么样的情况。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTUwNzMyNA_size_16_color_FFFFFF_t_70 3]  
1.在业务代码中使用完了ThreadLocalRef,如果ThreadLocalRef这个引用被回收了，还有一个Entry中的key强引用指向了ThreadLocal这个对象，如果不调用remove方法并且当前线程没有结束，那么该强引用一直存在，ThreadLocal对象永远不会被回收**导致ThreadLocal对象的内存泄漏**。  
2.如果不调用remove方法并且当前线程没有结束,强引用链CurrentThreadRef->CurrentThread->ThreadLocalMap->Entry就会一直存在，整个Entry就不会被回收，**导致entry内存泄漏。**

源码中的key是弱引用的情况：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTUwNzMyNA_size_16_color_FFFFFF_t_70 4]

1.  同样在业务代码中使用完了ThreadLocalRef,如果ThreadLocalRef这个引用被回收了
2.  这时候指向ThreaLocal持有的引用只有key的一个弱引用，没有任何强引用指向ThreadLocal实例，ThreadLocal对象就可以顺利被GC回收，这时候key的弱引用就指向了null即key==null
3.  但是这时候如果没有手动remove删除Entry且线程没有结束，仍然存在强引用链CurrentThreadRef->CurrentThread->ThreadLocalMap->Entry->value,value不会被回收，也不会被访问到**导致value内存泄漏**

总结以上：  
4. 即使Entry.key使用弱引用也会出现value的内存泄漏，只不过不会出现ThreadLocal对象的内存泄漏  
5. 内存泄漏的真实原因：  
1.没有手动remove()删除Entry；  
2.当前线程仍在运行 ；(ThreadMap是Thread的一个属性被当前线程所引用，所以他的生命周期根Thread一样长，那么在使用完ThreadLocal之后如果线程也随之结束，ThreadLocalMap自然也会被被GC回收，从而在根源上避免了内存泄漏)  
**综上：ThreadLocal内存泄漏的根源：由于ThreadLocalMap的生命周期根Thread一样长，如果没有手动删除对应key就会导致内存泄漏。**  
3. 使用弱引用的原因：  
使用完ThreadLocal，但是Thread仍然运行的情况下，就算忘记了调用remove()方法，弱引用可以比强引用多一层保障：弱引用的ThreadLocal会被回收，对应的value在下一次ThreadLocalMap调用set,get,remove中的人一方法的时候会被清除，从而避免内存泄漏。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTUwNzMyNA_size_16_color_FFFFFF_t_70]: /images/20230528/4da5f0235eab4d99a9b9b3fd1b6057c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTUwNzMyNA_size_16_color_FFFFFF_t_70 1]: /images/20230528/122c2ab7e1fa4af5a222317f3f05cab1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTUwNzMyNA_size_16_color_FFFFFF_t_70 2]: /images/20230528/5a0b5937f39f4d8eaa26955f4af8d95a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTUwNzMyNA_size_16_color_FFFFFF_t_70 3]: /images/20230528/e1e572c16a9e4d0baad115548219336a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTUwNzMyNA_size_16_color_FFFFFF_t_70 4]: /images/20230528/1a726ae9cb2c4991b96d9407972e723b.png