相信大家在编程或者做项目当中，或多或少都见过ThreadLocal，不少人觉得它很高大上，会用的都是大佬级别的。实际情况真是如此吗？你是真的用不上ThreadLocal吗？这篇文章主要讲一下 ThreadLocal ，让你看完后，能够立马投入使用，成为别人眼中的大佬！
我们先来了解一下，ThreadLocal 的作用，还有它的应用场景有哪些，知道后，才能知道我该在什么场景使用它。
首先，ThreadLocal算是一种并发容器吧，因为它的内部是有ThreadLocalMap组成，ThreadLocal是为了解决多线程情况下变量不能被共享的问题，也就是多线程共享变量的问题。
ThreadLocal和Lock以及Synchronized的区别是：
ThreadLocal是给每个线程分配一个变量（对象），各个线程都存有变量的副本，这样每个线程都是使用自己（变量）对象实例，使线程与线程之间进行隔离；
而Lock和Synchronized的方式是使线程有顺序的执行。
举一个简单的例子：目前有100个学生等待签字，但是老师只有一个笔，那老师只能按顺序的分给每个学生，等待A学生签字完成然后将笔交给B学生，这就类似Lock，Synchronized的方式。而ThreadLocal是，老师直接拿出一百个笔给每个学生；在效率提高的同时也要付出一个内存消耗；也就是以空间换时间的概念
Spring的事务隔离就是使用ThreadLocal和AOP来解决的；主要是TransactionSynchronizationManager这个类；
解决SimpleDateFormat线程不安全问题；
当我们使用SimpleDateFormat的parse()方法的时候，parse()方法会先调用Calendar.clear()方法，然后调用Calendar.add()方法，如果一个线程先调用了add()方法，然后另一个线程调用了clear()方法；这时候parse()方法就会出现解析错误；如果不信我们可以来个例子：
public class SimpleDateFormatTest {
private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
public static void main(String[] args) {
for (int i = 0; i < 50; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
dateFormat();
}
});
thread.start();
}
}
/**
* 字符串转成日期类型
*/
public static void dateFormat() {
try {
simpleDateFormat.parse("2021-5-27");
} catch (ParseException e) {
e.printStackTrace();
}
}
}
这里我们只启动了50个线程问题就会出现，其实看巧不巧，有时候只有10个线程的情况就会出错：
Exception in thread "Thread-40" java.lang.NumberFormatException: For input string: ""
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.lang.Long.parseLong(Long.java:601)
at java.lang.Long.parseLong(Long.java:631)
at java.text.DigitList.getLong(DigitList.java:195)
at java.text.DecimalFormat.parse(DecimalFormat.java:2084)
at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
at java.text.DateFormat.parse(DateFormat.java:364)
at cn.haoxy.use.lock.sdf.SimpleDateFormatTest.dateFormat(SimpleDateFormatTest.java:36)
at cn.haoxy.use.lock.sdf.SimpleDateFormatTest$1.run(SimpleDateFormatTest.java:23)
at java.lang.Thread.run(Thread.java:748)
Exception in thread "Thread-43" java.lang.NumberFormatException: multiple points
at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
at java.lang.Double.parseDouble(Double.java:538)
at java.text.DigitList.getDouble(DigitList.java:169)
at java.text.DecimalFormat.parse(DecimalFormat.java:2089)
at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
其实解决这个问题很简单，让每个线程new一个自己的SimpleDateFormat，但是如果100个线程都要new100个SimpleDateFormat吗？明显不合理。
当然我们不能这么做，我们可以借助线程池加上ThreadLocal来解决这个问题：
public class SimpleDateFormatTest {
private static ThreadLocal<SimpleDateFormat> local = new ThreadLocal<SimpleDateFormat>() {
@Override
//初始化线程本地变量
protected SimpleDateFormat initialValue() {
return new SimpleDateFormat("yyyy-MM-dd");
}
};
public static void main(String[] args) {
ExecutorService es = Executors.newCachedThreadPool();
for (int i = 0; i < 500; i++) {
es.execute(() -> {
//调用字符串转成日期方法
dateFormat();
});
}
es.shutdown();
}
/**
* 字符串转成日期类型
*/
public static void dateFormat() {
try {
//ThreadLocal中的get()方法
local.get().parse("2021-5-27");
} catch (ParseException e) {
e.printStackTrace();
}
}
}
这样就优雅的解决了线程安全问题；
解决过度传参问题；例如一个方法中要调用好多个方法，每个方法都需要传递参数；例如下面示例：
void work(User user) {
getInfo(user);
checkInfo(user);
setSomeThing(user);
log(user);
}
用了ThreadLocal之后：
public class ThreadLocalStu {
private static ThreadLocal<User> userThreadLocal = new ThreadLocal<>();
void work(User user) {
try {
userThreadLocal.set(user);
getInfo();
checkInfo();
someThing();
} finally {
userThreadLocal.remove();
}
}
void setInfo() {
User u = userThreadLocal.get();
//.....
}
void checkInfo() {
User u = userThreadLocal.get();
//....
}
void someThing() {
User u = userThreadLocal.get();
//....
}
}
每个线程内需要保存全局变量（比如在登录成功后将用户信息存到ThreadLocal里，然后当前线程操作的业务逻辑直接get取就完事了，有效的避免的参数来回传递的麻烦之处），一定层级上减少代码耦合度。
…等等…
上面我们基本上知道了ThreadLocal的使用方式以及应用场景，当然应用场景不止这些这只是工作中常用到的场景；下面我们对它的原理进行分析;
我们先看一下它的set()方法;
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
是不是特别简单，首先获取当前线程，用当前线程作为key,去获取ThreadLocalMap,然后判断map是否为空，不为空就将当前线程作为key,传入的value作为map的value值；如果为空就创建一个ThreadLocalMap,然后将key和value方进去；从这里可以看出value值是存放到ThreadLocalMap中；
然后我们看看ThreadLocalMap是怎么来的？先看下getMap()方法：
//在Thread类中维护了threadLocals变量，注意是Thread类
ThreadLocal.ThreadLocalMap threadLocals = null;
//在ThreadLocal类中的getMap()方法
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
这就能解释每个线程中都有一个ThreadLocalMap，因为ThreadLocalMap的引用在Thread中维护；这就确保了线程间的隔离；
我们继续回到set()方法，看到当map等于空的时候createMap(t, value);
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
这里就是new了一个ThreadLocalMap然后赋值给threadLocals成员变量；ThreadLocalMap构造方法：
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//初始化一个Entry
table = new Entry[INITIAL_CAPACITY];
//计算key应该存放的位置
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
//将Entry放到指定位置
table[i] = new Entry(firstKey, firstValue);
size = 1;
//设置数组的大小 16*2/3=10,类似HashMap中的0.75*16=12
setThreshold(INITIAL_CAPACITY);
}
这里写有个大概的印象，后面对ThreadLocalMap内部结构还会进行详细的讲解；
下面我们再去看一下get()方法：
public T get() {
Thread t = Thread.currentThread();
//用当前线程作为key去获取ThreadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null) {
//map不为空，然后获取map中的Entry
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
//如果Entry不为空就获取对应的value值
T result = (T)e.value;
return result;
}
}
//如果map为空或者entry为空的话通过该方法初始化，并返回该方法的value
return setInitialValue();
}
get()方法和set()都比较容易理解，如果map等于空的时候或者entry等于空的时候我们看看setInitialValue()方法做了什么事：
private T setInitialValue() {
//初始化变量值 由子类去实现并初始化变量
T value = initialValue();
Thread t = Thread.currentThread();
//这里再次getMap();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
//和set()方法中的
createMap(t, value);
return value;
}
下面我们再去看一下ThreadLocal中的initialValue()方法：
protected T initialValue() {
return null;
}
设置初始值，由子类去实现；就例如我们上面的例子，重写ThreadLocal类中的initialValue()方法：
private static ThreadLocal<SimpleDateFormat> local = new ThreadLocal<SimpleDateFormat>() {
@Override
//初始化线程本地变量
protected SimpleDateFormat initialValue() {
return new SimpleDateFormat("yyyy-MM-dd");
}
};
createMap()方法和上面set()方法中createMap()方法同一个，就不过多的叙述了；剩下还有一个remove()方法
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
//2. 从map中删除以当前threadLocal实例为key的键值对
m.remove(this);
}
源码的讲解就到这里，也都比较好理解，下面我们看看ThreadLocalMap的底层结构：
上面我们已经了解了ThreadLocal的使用场景以及它比较重要的几个方法；下面我们再去它的内部结构；经过上的源码分析我们可以看到数据其实都是存放到了ThreadLocal中的内部类ThreadLocalMap中；而ThreadLocalMap中又维护了一个Entry对象，也就说数据最终是存放到Entry对象中的；
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<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
// ....................
}
在java中，栈内存归属于单个线程，每个线程都会有一个栈内存，其存储的变量只能在其所属线程中可见，即栈内存可以理解成线程的私有变量，而堆内存中的变量对所有线程可见，可以被所有线程访问！
那么ThreadLocal的实例以及它的值是不是存放在栈上呢？其实不是的，因为ThreadLocal的实例实际上也是被其创建的类持有，（更顶端应该是被线程持有），而ThreadLocal的值其实也是被线程实例持有，它们都是位于堆上，只是通过一些技巧将可见性修改成了线程可见。