【JUC】8.ThreadLocal

心已赠人 2024-04-01 08:34 87阅读 0赞

#### 文章目录 ####

*  1. 什么是ThreadLocal
 *  2. ThreadLocal入门
 *  3. Thread、ThreadLocal与ThreadLocalMap
 *  4. 四大引用
 *   *  4.1 强引用（默认）
     *  4.2 软引用
     *  4.3 弱引用
     *  4.4 虚引用
 *  5. ThreadLocal为什么可以实现“数据隔离”
 *  6. 为什么ThreadLocalMap中的Entry要继承弱引用
 *  8. 如何清除脏Entry
 *   *  注明：\[尚硅谷2022版JUC并发编程（对标阿里P6-P7）\](https://www.bilibili.com/video/BV1ar4y1x727/?p=111&spm\_id\_from=333.1007.top\_right\_bar\_window\_history.content.click&vd\_source=cc24ad51180ec9731f4262085c2e8be9)

## 1. 什么是ThreadLocal ##

ThreadLocal提供线程局部变量。这些变量与正常的**变量不同**，**因为每一个线程在访问ThreadLocal实例的时候(通过其get或set方法)都有自己的、独立初始化的变量副本**。ThreadLocal实例通常是类中的私有静态字段，使用它的目的是希望将状态(例如，用户ID或事务ID)与线程关联起来。

那么ThreadLocal能干嘛呢？

**实现每一个线程都有自己专属的本地变量副本(自己用自己的变量不麻烦别人，不和其他人人共享，人人有份，人各一份)，主要解决了让每个线程绑定自己的值，通过使用get()和set()方法，获取默认值或将其值更改为当前线程所存的副本的值从而避免了线程安全问题，比如我们之前讲解的8锁案例，资源类是使用同一部手机，多个线程抢夺同一部手机便使用，假如人手一份是不是天下太平?**

--------------------

## 2. ThreadLocal入门 ##

**ThreadLocal因为涉及到线程，所以当自定义的ThreadLocal变量不需要的时候，需要将其回收**

详细请参考阿里巴巴Java开发手册

![在这里插入图片描述][1aa8ac0ee193457faca0b27ae337e0d3.png_pic_center]

**ThreadLocal相关API**

<table> 
 <thead> 
  <tr> 
   <th>Modifier and Type</th> 
   <th>Method and Description</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>T</code></td> 
   <td><code>get()</code> 返回当前线程本地变量的当前线程的副本中的值。</td> 
  </tr> 
  <tr> 
   <td><code>protected T</code></td> 
   <td><code>initialValue()</code> 返回此线程局部变量的当前线程的“初始值”。</td> 
  </tr> 
  <tr> 
   <td><code>void</code></td> 
   <td><code>remove()</code> 移除此线程局部变量的当前线程的值。</td> 
  </tr> 
  <tr> 
   <td><code>void</code></td> 
   <td><code>set(T value)</code> 将此线程局部变量的当前线程的副本设置为指定的值。</td> 
  </tr> 
  <tr> 
   <td><code>static &lt;S&gt; ThreadLocal&lt;S&gt;</code></td> 
   <td><code>withInitial(Supplier&lt;? extends S&gt; supplier)</code> 创建一个线程局部变量。</td> 
  </tr> 
 </tbody> 
</table>

class MyData {
        ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);
    
        public void add() {
            threadLocal.set(1 + threadLocal.get());
        }
    }
    
    
    public class ThreadLocalDemo {
        public static void main(String[] args) {
            MyData myData = new MyData();
            ExecutorService threadPool = Executors.newFixedThreadPool(3);
            try {
                for (int i = 0; i < 10; i++) {
                    threadPool.submit(() -> {
                        Integer beforeInt = myData.threadLocal.get();
                        myData.add();
                        Integer afterInt = myData.threadLocal.get();
                        System.out.println(Thread.currentThread() + "\t" + "beforeInt：" + beforeInt + "\tafterInt：" + afterInt);
                    });
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                threadPool.shutdown();
            }
        }
    }

![在这里插入图片描述][30963b39afe3410283316167c4f67865.png_pic_center]

**上面使用完ThreadLocal之后没有及时将局部变量的当前线程的值清空，导致存在脏数据**

修改后

class MyData {
        
        ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);
    
        public void add() {
        
            threadLocal.set(1 + threadLocal.get());
        }
    }
    
    
    public class ThreadLocalDemo {
        
        public static void main(String[] args) {
        
            MyData myData = new MyData();
            ExecutorService threadPool = Executors.newFixedThreadPool(3);
            try {
        
                for (int i = 0; i < 10; i++) {
        
                    threadPool.submit(() -> {
        
                        try {
        
                            Integer beforeInt = myData.threadLocal.get();
                            myData.add();
                            Integer afterInt = myData.threadLocal.get();
                            System.out.println(Thread.currentThread() + "\t" + "beforeInt：" + beforeInt + "\tafterInt：" + afterInt);
                        } finally {
        
                            //清空局部变量的当前线程里面的数据
                            myData.threadLocal.remove();
                        }
                    });
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                threadPool.shutdown();
            }
        }
    }

![在这里插入图片描述][6b783052471d4dc19e3e06ce84d65784.png_pic_center]

--------------------

## 3. Thread、ThreadLocal与ThreadLocalMap ##

在Thread源码中

ThreadLocal.ThreadLocalMap threadLocals = null;
    
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

而在ThreadLocal源码中，ThreadLocalMap是ThreadLocal的内部类

static class ThreadLocalMap {
        
    
        static class Entry extends WeakReference<ThreadLocal<?>> {
        
            /** The value associated with this ThreadLocal. */
            Object value;
    
            Entry(ThreadLocal<?> k, Object v) {
        
                super(k);
                value = v;
            }
        }

ThreadLocalMap实际上就是一个以threadLocal实例为key，任意对象为value的Entry对象

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

![在这里插入图片描述][65f3430c32ef43deb3dce92a4c8f7c65.png_pic_center]

--------------------

## 4. 四大引用 ##

四大引用是指：

*  强引用
 *  软引用
 *  弱引用
 *  虚引用

![在这里插入图片描述][090becd940174a6aa4486cc7e850e6b0.png_pic_center]

--------------------

### 4.1 强引用（默认） ###

当内存不足，JVM开始垃圾回收，对于强引用的对象，就算是出现了OOM也不会时该对象进行回收，死都不收。

**强引用是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾收集器不会碰这种对象。**  
**在Java 中最常见的就是强引用，把一个对象赋给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，它是不可能被垃圾回收机制回收的，**  
即使该对象以后永远都不会被用到，JVM也不会回收。因此强引用是造成Java内存泄漏的主要原因之一。

对于一个普通的对象，如果没有其他的引用关系，只要超过了引用的作用域或者显式地将相应(强)引用赋值为 null  
一般认为就是可以被垃圾收集的了(当然具体回收时机还是要看垃圾收集策略)。

--------------------

### 4.2 软引用 ###

软引用是一种相对强引用弱化了一些的引用，需要用java.lang.ref.SoftReference类来实现，可以让对象豁免一些垃圾收集。

对于只有软引用的对象来说，

*  当系统内存充足时它 不会 被回收，
 *  当系统内存不足时它 会 被回收。

软引用通常用在对内存敏感的程序中，比如高速缓存就有用到软引用，**内存够用的的时候就保留，不够用就回收!**

--------------------

### 4.3 弱引用 ###

弱引用需要用java.lang.ref.WeakReference类来实现，它比软引用的生存期更短，

**对于只有弱引用的对象来说，只要拉圾回收机制一运行，不管JVM的内存空间是否足够，都会回收该对象占用的内存。**

--------------------

### 4.4 虚引用 ###

1.  虚引用必须和引用队列 (ReferenceQueue)联合使用  
    虚引用需要java.lang.ref.PhantomReference类来实现，顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收，它不能单独使用也不能通过它访问对象，虚引用必须和引用队列 (ReferenceQueue)联合使用。被干掉就会装到队列里面。
2.  PhantomReference的aet方法总是返回null  
    虚引用的主要作用是跟踪对象被垃圾回收的状态。仅仅是提供了一种确保对象被 finalize以后，做某些事情的通知机制。 PhantomReference的get方法总是返回null，因此无法访问对应的引用对象。
3.  处理监控通知使用  
    换句话说，设置虚引用关联对象的唯一目的，就是在这个对象被收集器回收的时候收到一个系统通知或者后续添加进一步的处理，用来实现比finalize机制更灵活的回收操作

--------------------

## 5. ThreadLocal为什么可以实现“数据隔离” ##

![在这里插入图片描述][2611c3f1a84f4a1aad301a4a1d9be026.png_pic_center]

ThreadLocal是一个壳子，真正的存储结构是ThreadLocal里有ThreadLocalMap这么个内部类，每个Thread对象维护着一个ThreadLocalMap的引用，ThreadLocalMap是ThreadLocal的内部类，用Entry来进行存储。

1.  调用ThreadLocal的set()方法时，实际上就是往ThreadLocalMap设置值，key是ThreadLocal对象，值Value是传递进来的对象
2.  调用ThreadLocal的get()方法时，实际上就是往ThreadLocalMap获取值，kev是ThreadLocal对象  
    ThreadLocal本身并不存储值(ThreadLocal是一个壳子)，它只是自己作为一个key来让线程从ThreadLocalMap获取value。

**正因为这个原理，所以ThreadLocal能够实现“数据隔离”，获取当前线程的局部变量值，不受其他线程影响~**

--------------------

## 6. 为什么ThreadLocalMap中的Entry要继承弱引用 ##

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VTzDI1Gd-1666167288030)(F:\\笔记记录\\JUC\\【JUC】8.ThreadLocal.assets\\image-20221019145446153.png)\]  
当function01方法执行完毕后，栈帧销毁强引用tl也就没有了。但此时线程的ThreadLocalMap里某个entry的key引用还指向这个对象若这个key引用是强引用，就会导致key指向的ThreadLocal对象及v指向的对象不能被gc回收，造成内存泄漏；

> 换句话来说，也就是线程Thread是人，ThreadLocal是身份证，而ThreadLocalMap代表卡片上的kv信息
> 
> 如果人没了（Threa线程挂掉），那么ThreadLocal（是强引用）也可会没，这时候ThreadLocalMap代表kv信息，也应该随之没，如果它是强引用的话会导致还在

若这个key引用是弱引用就大概率会减少内存泄漏的问题(还有一个key为nul的雷)。

使用弱引用，就可以使ThreadLocal对象在方法执行完毕后顺利被回收且Entry的key引用指向为null

--------------------

## 8. 如何清除脏Entry ##

前面说到gc之后会使得Entry的key引用指向为null，这里会导致内存泄漏

1.  当我们为threadLocal变量赋值，实际上就是当前的Entry(threadLocal实例为key，值为value)往这个threadLocalMap中存放。Entry中的key是弱引用，当threadLocal外部强引用被置为null(tl=nul).那么系统GC的时候，根据可达性分析，这个threadLocal实例就没有任何一条链路能够引用到 它，这个ThreadLocal势必会被回收。**这样一来，ThreadLocalMap中就会出现key为null的 Entry**，**就没有办法访问这些key为null的Entry的value**，如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链:Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收，**造成内存泄漏。**
2.  当然，如果当前thread运行结束，threadLocal，threadLocalMap,Entry没有引用链可达，在垃圾回收的时候都会被系统进行回收。
3.  **但在实际使用中我们有时候会用线程池去维护我们的线程，比如在Executors.newFixedT hreadPool()时创建线程的时候，为了复用线程是不会结束的，所以threadLocal内存泄漏就值得我们小心**

可以通过remove方法，其底层会寻找Entry，即key=null的Entry，然后进行删除

不仅remove方法，在set和getEntry方法中可以看出，在threadLocal的生命周期里，针对threadLocal存在的内存泄漏的问题，都会通过expungeStaleEntry，cleanSomeSlots，replaceStaleEntry这三个方法清理掉key为null的脏entry

因此我们在使用*ThreadLocal*的时候

*  首先要记得初始化，ThreadLocal threadLocal = ThreadLocal.withInitial(() -> 0);
 *  建议把ThreadLocal修饰static
 *  用完记得手动remove

--------------------

> ### 注明：[尚硅谷2022版JUC并发编程（对标阿里P6-P7）][2022_JUC_P6-P7] ###

[1aa8ac0ee193457faca0b27ae337e0d3.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/ff4734c262474f8493d2b0e76a7a95af.png
[30963b39afe3410283316167c4f67865.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3092600f90aa41efa3e9245459c1cf6d.png
[6b783052471d4dc19e3e06ce84d65784.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3be323929548457996999029bb967df7.png
[65f3430c32ef43deb3dce92a4c8f7c65.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/f3d5adfffdb94537a3d9e1cdd44a96ff.png
[090becd940174a6aa4486cc7e850e6b0.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/02fade71f8bf489cb029e9ea15cf3094.png
[2611c3f1a84f4a1aad301a4a1d9be026.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/08bafaea3a95410c88be852450034d7e.png
[2022_JUC_P6-P7]: https://www.bilibili.com/video/BV1ar4y1x727/?p=111&spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=cc24ad51180ec9731f4262085c2e8be9