ThreadLocal原理和内存泄露分析

概述

. ThreadLocal 这个类提供线程局部变量。这些变量与普通变量的不同之处在于，每个访问变量的线程get或set方法都有自己独立初始化的变量副本。实例通常是类中的私有静态字段，它们希望将状态与线程(例如，用户ID或事务ID)关联起来。大白话每个线程维护自己的私有变量

import java.util.concurrent.TimeUnit;

/**
* 线程t1,t2分别设置了threadLocal值之后多次获取
* 运行结果t1,t2分别获取的是自己线程设置的值
* threadLocal维护的是当前操作线程的值
 * @author 
 * @date 2021-03-28
 */
public class ThreadLocalTest {

    static ThreadLocal threadLocal = new ThreadLocal();
    public static void main(String[] args) throws InterruptedException {
      Thread t1=  new Thread(() -> {
           threadLocal.set("t1");
           for (int i = 0; i < 10; i++) {
                    //让线程sleep下 方便看出多线程运行效果
               try {
                   TimeUnit.MILLISECONDS.sleep(5);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("t1 get "+ threadLocal.get());
           }
        });
        Thread t2 = new Thread(() -> {
            threadLocal.set("t2");
            for (int i = 0; i < 10; i++) {
                try {
                    TimeUnit.MILLISECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2 get "+ threadLocal.get());
            }
        });
        t1.start();
        t2.start();
        Thread.currentThread().join();
    }
}

. 运行结果

t2 get t2
t1 get t1
t2 get t2
t1 get t1
t2 get t2
t1 get t1
t2 get t2
t1 get t1
t2 get t2
t1 get t1
t1 get t1
t2 get t2
t1 get t1
t2 get t2
t1 get t1
t2 get t2
t1 get t1
t2 get t2
t1 get t1
t2 get t2

原理

. ThreadLocal可以看做是一个容器，容器里面存放着属于当前线程的变量。ThreadLocal类提供了四个对外开放的接口方法，这也是用户操作ThreadLocal类的基本方法：
. void set(Object value)设置当前线程的线程局部变量的值(Obejct类型)。
. public Object get()该方法返回当前线程所对应的线程局部变量。
. public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。
. protected Object initialValue()返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次，ThreadLocal中的缺省实现直接返回一个null。可以通过上述的几个方法实现ThreadLocal中变量的访问，数据设置，初始化以及删除局部变量，那ThreadLocal内部是如何为每一个线程维护变量副本的呢？
其实在ThreadLocal类中有一个静态内部类ThreadLocalMap(其类似于Map)，用键值对的形式存储每一个线程的变量副本，ThreadLocalMap中元素的key为当前ThreadLocal对象，而value对应线程的变量副本，每个线程可能存在多个ThreadLocal。

内存泄露问题

. threadLocal内存布局

image.png

如何避免内存泄露

. Foo 类构造时关联了当前对象到ThreadLocal 中

public class Foo {
    private  final ThreadLocal tl = new ThreadLocal();

    public Foo() {
        tl.set(this);
        System.out.println("ClassLoader: " + this.getClass().getClassLoader());
    }

    @Override protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("foo finalize");
    }

    public void removeMC(){
        tl.remove();
    }
}

. 自定义类加载器LocalClassLoader，重写finalize方法

public class LocalClassLoader extends ClassLoader {
    @Override protected Class findClass(String name) throws ClassNotFoundException {
        Class cls = findLoadedClass(name);
        if (cls != null) {
            return cls;
        }
        return super.loadClass(name);
    }

    @Override
    protected void finalize() {
        System.out.println("*** LocalClassLoader finalized!");
    }
}

public class Main {

    /**
     * 类加载器和主方法在同一个线程内
     * foo对象未被回收
     *localClassLoader对象未被回收
     * @throws InterruptedException
     */
    @Test
    public void test1() throws InterruptedException {
        LocalClassLoader localClassLoader = new LocalClassLoader();
        Class fooClass = null;
        try {
            fooClass = (Class)localClassLoader.findClass("com.tank.jvm.threadlocal.Foo");
            Foo foo = fooClass.newInstance();
            foo = null;
            fooClass = null;
        } catch (Exception e) {
            e.printStackTrace();
        }
        while (true) {
            System.gc();
            Thread.sleep(1000);
        }

    }

    /**
     * 主方法和类加载不在同一个线程
     *类加载器和被初始化的类都被回收了
     * @throws Exception
     */
    @Test
    public  void test2() throws Exception {
        Thread t = new Thread(()->{
            LocalClassLoader localClassLoader = new LocalClassLoader();
            Class fooClass = null;
            try {
                fooClass = (Class)localClassLoader.findClass("com.tank.jvm.threadlocal.Foo");
                Foo foo = fooClass.newInstance();
                foo = null;
                fooClass = null;
            } catch (Exception e) {
                e.printStackTrace();
            }

        });
        t.start();
        while (true) {
            System.gc();
            Thread.sleep(1000);
        }
    }

    /**
     *方法线程和类加载同线程
     * 手动清除threadLocal缓存
     * 初始对象被回收；classLoader未被回收
     * @throws InterruptedException
     */
    @Test
    public void test3() throws InterruptedException {
        LocalClassLoader localClassLoader = new LocalClassLoader();
        Class fooClass = null;
        try {
            fooClass = (Class)localClassLoader.findClass("com.tank.jvm.threadlocal.Foo");
            Foo foo = fooClass.newInstance();
            foo.removeMC();
            foo= null;
            fooClass = null;
        } catch (Exception e) {
            e.printStackTrace();
        }
        while (true) {
            System.gc();
            Thread.sleep(1000);
        }

    }
}

总结

. ThreadLocal维护每个执行线程设置的变量值；一个线程可以参见多个ThreadLocal对象存放线程执行上下文值
. ThreadLocal使用不当会造成内存泄露问题
. 线程执行完成被回收;
. 当前线程未结束但手动调用remove清理threadLocal值并设置对象为null可被回收
. ThreadLocal本身并无内存泄露bug，如果线程执行中定义了大对象即使不再被使用也会导致不被回收