ThreadLocal概述

一、概述

        ThreadLocal被称为线程局部变量，用于在线程中保存数据。由于在ThreadLocal中保存的数据仅属于当前线程，所以该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。

        ThreadLocal用于在同一个线程间，在不同的类和方法之间共享数据的的场景，也可以用于在不同线程间隔离数据的场景。
ThreadLocal利用Thread中的ThreadLocalMap来进行数据存储。

示例： 

public class Test01 {

	public static ThreadLocal threadLoacl = new ThreadLocal();

	public static void main(String[] args) throws InterruptedException {

		Thread t1 = new Thread(new Runnable() {

			@Override
			public void run() {
				threadLoacl.set("苏妲己");
				show();
				Sample.dosth();
			}
		}, "线程1");

		Thread t2 = new Thread(new Runnable() {

			@Override
			public void run() {
				threadLoacl.set("ddc");
				show();
				Sample.dosth();
			}
		}, "线程2");

		t1.start();
		t2.start();

		t1.join();
		t2.join();
	}

	public static void show() {
		System.out.println("show" + Thread.currentThread().getName() + "分配角色:" + threadLoacl.get());
	}
}

class Sample {
	// 线程1或线程2
	public static void dosth() {
		System.out.println("dosth:" + Thread.currentThread().getName() + "分配角色:" + Test01.threadLoacl.get());
	}
}

二、常用方法 

1. 存储数据至当前线程的ThreadLocalMap：public void set(T value)

public void set(T value) {
        // 获取当前线程
        Thread t = Thread.currentThread();

        // 获取当前线程的ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        // 存储数据到当前的ThreadLocalMap中
        // 使用ThreadLocal做key 保存数据value
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

2. 从当前线程的ThreadLocalMap中获取数据：public T get()

public T get() {
        // 获取当前线程的ThreadLocalMap
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t); 

        // 使用ThreadLocal对象做key，获取数据(Entry类型)
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

3. 从当前线程的 ThreadLocalMap 中删除数据： public void remove()

在线程池的线程复用场景中，线程执行完毕时一定要调用 remove() ，避免在线程被重 新放入线程池中时被本地变量的旧状态仍然被保存。

public void remove() {
     // 获取当前线程的ThreadLocalMap
     ThreadLocalMap m = getMap(Thread.currentThread());
     // 使用当前ThreadLocal对象做key，删除数据
     if (m != null)
         m.remove(this);
}

        ThreadLocal的get()方法、set()方法和remove()方法，其实最终操作的都是ThreadLocalMap类中的数据。

三、ThreadLocalMap内部结构

        ThreadLocalMap内部数据结构是一个Entry类型的数组。每个Entry对象的key为ThreadLocal对象，value为存储的数据。

static class ThreadLocalMap {
     static class Entry extends WeakReference> {
     Object value;
     Entry(ThreadLocal k, Object v) {
         super(k);
         value = v;
     }
 }
     ...
     private Entry[] table;
     ...
}

 3.1 为什么使用ThreadLocal做key

        如果在应用中，一个线程中只使用了一个 ThreadLocal 对象，那么使用 Thread 做 key 也是可以的，代表每个 Thread 线程对应一个 value 。

示例：

public class ThreadLocalService {
     private static final ThreadLocal threadLocal = new ThreadLocal<>();
} 

但是，在实际应用程序开发过程中，一个线程中很有可能不只使用了一个 ThreadLocal 对象。这时使用 Thread 做 key 就会产生混淆:

public class ThreadLocalService {
     private static final ThreadLocal threadLocal1 = new ThreadLocal<>();
     private static final ThreadLocal threadLocal2 = new ThreadLocal<>();
     private static final ThreadLocal threadLocal3 = new ThreadLocal<>();
}

所以，不能使用 Thread 做 key ，而应该改成用 ThreadLocal 对象做 key ，这样才 能通过具体 ThreadLocal 对象的 get() 方法，获取到当前线程的 ThreadLocalMap ， 然后进一步获取到对应的 Entry 。

3.2 ThreadLocalMap如何查找数据

         当我们使用 ThreadLocal 获取当前线程中保存的 Value 数据时，是以 ThreadLocal 对象作为 Key ，通过访问 Thread 当前线程对象的内部 ThreadLocalMap 集合来获取到 Value 。

        ThreadLocalMap 集合的底层数据结构使用 Entry[] 数组保存 Key-Value 键值对数据。所以，当通过 ThreadLocal 的 get 、 set() 、 remove() 等方法，访问 ThreadLocalMap 时，最终都会通过一个下标，来完成对数组中的元素访问。

int i = key.threadLocalHashCode & (len-1);

通过 key 的“ hashCode 值”跟"数组的长度减1" 做“ & 按位与”运算。其中 key 就是 ThreadLocal 对象。这种计算方式，相当于用“ hashCode 值”跟“数组的长 度”进行“ % 取余”运算。

        假设： len=16 ， key.threadLocalHashCode=31

        hash & len-1 的计算结果与 hash % len 的计算结果一直，均为 15 ，但是“&按位与”运算的效率更高。

3.3 父子线程如何共享数据

        在实际工作中，有可能需要在父子线程中共享数据的。即：在父线程中往 ThreadLocal 设置了值，在子线程中能够获取到。

public class ThreadLocalTest {
    public static void main(String[] args) {
        ThreadLocal threadLocal = new ThreadLocal();
        threadLocal.set("叮叮车");
        System.out.println("main主线程:"+threadLocal.get());
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程:"+threadLocal.get());
            }
        });
        thread.start();
    }
}

运行结果为null，就是没有获取到

        在这种情况下使用 ThreadLocal 是行不通的。 main 方法是在主线程中执行的，相当于父线程。在 main 方法中开启了另外一个线程，相当于子线程。两个线程对象，各自拥有不同的 ThreadLocalMap 。应该使用 InheritableThreadLocal ，它是 JDK 自带的 类，继承了ThreadLocal 类。

public class ThreadLocalTest {
    public static void main(String[] args) {
        InheritableThreadLocal threadLocal = new InheritableThreadLocal();
        threadLocal.set("叮叮车");
        System.out.println("main主线程:"+threadLocal.get());
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程:"+threadLocal.get());
            }
        });
        thread.start();
    }
}

结果成功获取到值

3.4 ThreadLocal如何避免内存泄漏

使用完毕后，在 finally 调用 ThreadLocal 对象的 remove() 方法。 例如：

public class CurrentUser {
    private static final ThreadLocal THREA_LOCAL = new ThreadLocal();

    public static void set(UserInfo userInfo) {
        THREA_LOCAL.set(userInfo);
    }

    public static UserInfo get() {
        THREA_LOCAL.get();
    }

    public static void remove() {
        THREA_LOCAL.remove();
    }
}

然后在业务代码中调用相关方法：

public void doSamething(UserDto userDto) {
     UserInfo userInfo = convert(userDto);

     try{
     CurrentUser.set(userInfo);
     ...
    
     //业务代码
     UserInfo userInfo = CurrentUser.get();
     ...
     } finally {
         CurrentUser.remove();
     }
}

        需要特别注意的地方是：一定要在 finally 代码块中，调用 remove() 方法清理没用的数据。如果业务代码出现异常，也能及时清理没用的数据。

        remove() 方法中会把 Entry 中的 key 和 value 都设置成 null ，这样就能被 GC 及时回收，无需触发额外的清理机制，所以它能解决内存泄露问题。

四、ThreadLocal应用场景

4.1 线程数据隔离

        ThreadLocal 的主要价值在于线程隔离， ThreadLocal 中的数据只属于当前线程，该数据对别的线程是不可见的，起到隔离作用。这样操作，可以在多线程环境下，可以防止当前线程的数据被其他线程修改。另外，由于各个线程之间的数据相互隔离，避免了同步加锁带来的性能损失，大大提升了并发性的性能。

        例如： SqlSession 会话对象绑定，避免多个线程使用同一个 SqlSession 对象，由于关闭导致异常。

    private static final ThreadLocal threadSession= new ThreadLocal();
    public static SqlSession getSession(){
        SqlSession s = (SqlSession)threadSession.get();
        if(s==null){
            s = getSqlSessionFactory().openSqlSession();
            threadSession.set(s);
        }
}

4.2 跨函数传递

        数据通常用于同一个线程内，跨类、跨方法传递数据时，如果不用 ThreadLocal ，那么相互之间的数据传递势必要靠返回值和参数，这样无形之中增加了这些类或者方法之间的耦合度。

例如：获取HttpServletRequest

// SpringMVC或SpringBoot框架使用中获取HttpServletRequest
HttpServletRequest request = 
 ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();