ThreadLocal本地线程变量,意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。通过使用get()和set()方法,获取默认值或将其值更改为当前线程所存的副本的值从而避免了线程安全的问题
ThreadLoal 变量，线程局部变量，同一个 ThreadLocal 所包含的对象，在不同的 Thread 中有不同的副本。这里有几点需要注意：
总的来说，ThreadLocal 适用于每个线程需要自己独立的实例且该实例需要在多个方法中被使用，也即变量在线程间隔离而在方法或类间共享的场景
ThreadLocal
但是ThreadLocal与synchronized有本质的区别：
synchronized或者lock,有个管理员,好比,现在大家签到,多个同学(线程),但是只有一只笔,只能同一个时间,只有一个线程(同学)签到,加锁(同步机制是以时间换空间,执行时间不一样,类似于排队)
ThreadLocal,人人有份,每个同学手上都有一支笔,自己用自己的,不用再加锁来维持秩序(同步机制是以空间换时间,为每一个线程都提供了一份变量的副本,从而实现同时访问,互不干扰同时访问,肯定效率高啊)
一句话理解ThreadLocal，threadlocl是作为当前线程中属性ThreadLocalMap集合中的某一个Entry的key值Entry（threadlocl,value），虽然不同的线程之间threadlocal这个key值是一样，但是不同的线程所拥有的ThreadLocalMap是独一无二的，也就是不同的线程间同一个ThreadLocal（key）对应存储的值(value)不一样，从而到达了线程间变量隔离的目的，但是在同一个线程中这个value变量地址是一样的。
卖房示例代码：
/***
* 看每个销售员可以出售多少套房子
*/
class House{
/**
initialValue():返回此线程局部变量的当前线程的"初始值"
对于initialValue()较为老旧,jdk1.8又加入了withInitial()方法
ThreadLocal<Integer>threadLocal=new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return 0;
}
};*/
//public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier)
//withInitial(Supplier<? extends S> supplier):创建线程局部变量
//ThreadLocal本地线程变量,线程自带的变量副本
ThreadLocal<Integer>threadLocal=
ThreadLocal.withInitial(()->0);
public void saleHouse(){
//T get():返回当前线程的此线程局部变量的副本中的值。
Integer value = threadLocal.get();
value++;
//void set(T value):将当前线程的此线程局部变量的副本设置为指定的值。
threadLocal.set(value);
}
}
public class ThreadLocalDemo {
public static void main(String[] args) {
House house = new House();
new Thread(()->{
try{
for (int i = 1; i <=3; i++) {
house.saleHouse();
}
System.out.println(Thread.currentThread().getName()+"\t"+"卖出:"+house.threadLocal.get());
}catch (Exception e){
e.getStackTrace();
}finally {
//void remove():删除此线程局部变量的当前线程的值
//在阿里巴巴手册中有说明,尽量在代理中使用try-finally块进行回收
house.threadLocal.remove();
//下面获取到的值是线程的初始值0
System.out.println("**********"+house.threadLocal.get());
}
},"t1").start();
new Thread(()->{
try{
for (int i = 1; i <=5; i++) {
house.saleHouse();
}
System.out.println(Thread.currentThread().getName()+"\t"+"卖出:"+house.threadLocal.get());
}catch (Exception e){
e.getStackTrace();
}finally {
house.threadLocal.remove();
}
},"t2").start();
new Thread(()->{
try{
for (int i = 1; i <=8; i++) {
house.saleHouse();
}
System.out.println(Thread.currentThread().getName()+"\t"+"卖出:"+house.threadLocal.get());
}catch (Exception e){
e.getStackTrace();
}finally {
house.threadLocal.remove();
}
},"t3").start();
System.out.println(Thread.currentThread().getName()+"\t"+"卖出了:"+house.threadLocal.get());
}
}
/**
* t1 卖出:3
* t2 卖出:5
* **********0
* main 卖出了:0
* t3 卖出:8
* */
代码总结
用途说明:在对一些业务日志写入数据库的时候,日期调用了sdf的静态,导致了会报错或者日期乱了(生产故障)
此时可以使用ThreadLocal解决该问题
代码示例如下:
/**
* 在对一些业务日志写入数据库的时候,日期调用了sdf的静态,导致了会报错或者日期乱了
* */
public class ThreadLocalDataUtils {
public static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
/**
解决方案一:加入synchronized,用时间换空间,效率低
*/
/**
如果不加会导致线程安全问题,SimpleDateFormat类内部有一个Calendar对象引用,
SimpleDateFormat相关的日期信息,例如sdf.parse(dateStr),sdf.format(date)
诸如此类的方法参数传入的日期相关String,Date等等, 都是交由Calendar引用来储存的.
这样就会导致一个问题如果你的SimpleDateFormat是个static的,那么多个thread之间
就会共享这个SimpleDateFormat,同时也是共享这个Calendar引用(相当于买票案列)
*/
//public static synchronized Date parse(String stringDate) throws ParseException {
public static Date parse(String stringDate) throws ParseException {
System.out.println(sdf.parse(stringDate));
return sdf.parse(stringDate);
}
/***
* 解决方案二:使用ThreadLocal,用空间换时间,效率高
* ThreadLocal中变量副本会人手一份,每次使用完了threadLocal后都要将资源进行释放的处理
*/
public static final ThreadLocal<SimpleDateFormat>sdfThreadLocal=
ThreadLocal.withInitial(()->new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
public static Date parseByThreadLocal(String stringDate) throws ParseException {
return sdfThreadLocal.get().parse(stringDate);
}
//3 DateTimeFormatter 代替 SimpleDateFormat
public static final DateTimeFormatter DATE_TIME_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
public static String formatForDateTime(LocalDateTime localDateTime) {
return DATE_TIME_FORMAT.format(localDateTime);
}
public static LocalDateTime parseForDateTime(String dateString) {
return LocalDateTime.parse(dateString,DATE_TIME_FORMAT);
}
public static void main(String[] args) throws Exception{
for (int i = 1; i <=3; i++) {
new Thread(()->{
try {
//ThreadLocalDataUtils.parse("2021-03-30 11:20:30");
//System.out.println(ThreadLocalDataUtils.parseByThreadLocal("2021-03-30 11:20:30"));
System.out.println(ThreadLocalDataUtils.parseForDateTime("2021-03-30 11:20:30"));
// System.out.println(ThreadLocalDataUtils.formatForDateTime(LocalDateTime.now()));
} catch (Exception e) {
e.printStackTrace();
}finally {
ThreadLocalDataUtils.sdfThreadLocal.remove();
}
},String.valueOf(i)).start();
}
}
}
源码分析:
/**
* 设置当前线程对应的ThreadLocal的值
*
* @param value 将要保存在当前线程对应的ThreadLocal的值
*/
public void set(T value) {
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 判断map是否存在
if (map != null)
// 存在则调用map.set设置此实体entry
map.set(this, value);
else
// 1)当前线程Thread 不存在ThreadLocalMap对象
// 2)则调用createMap进行ThreadLocalMap对象的初始化
// 3)并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
createMap(t, value);
}
/**
* 获取当前线程Thread对应维护的ThreadLocalMap
*
* @param t the current thread 当前线程
* @return the map 对应维护的ThreadLocalMap
*/
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
/**
*创建当前线程Thread对应维护的ThreadLocalMap
*
* @param t 当前线程
* @param firstValue 存放到map中第一个entry的值
*/
void createMap(Thread t, T firstValue) {
//这里的this是调用此方法的threadLocal
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
/*
* firstKey : 本ThreadLocal实例(this)
* firstValue ： 要保存的线程本地变量
*/
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//初始化table
table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY];
//计算索引(重点代码)
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
//设置值
table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
size = 1;
//设置阈值
setThreshold(INITIAL_CAPACITY);
}
/**
* 返回当前线程中保存ThreadLocal的值
* 如果当前线程没有此ThreadLocal变量,
* 则它会通过调用{@link #initialValue} 方法进行初始化值
*
* @return 返回当前线程对应此ThreadLocal的值
*/
public T get() {
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 如果此map存在
if (map != null) {
// 以当前的ThreadLocal 为 key,调用getEntry获取对应的存储实体e
ThreadLocalMap.Entry e = map.getEntry(this);
// 对e进行判空
if (e != null) {
@SuppressWarnings("unchecked")
// 获取存储实体 e 对应的 value值
// 即为我们想要的当前线程对应此ThreadLocal的值
T result = (T)e.value;
return result;
}
}
/*
初始化 : 有两种情况有执行当前代码
第一种情况: map不存在,表示此线程没有维护的ThreadLocalMap对象
第二种情况: map存在, 但是没有与当前ThreadLocal关联的entry
*/
return setInitialValue();
}
/**
* 初始化
*
* @return the initial value 初始化后的值
*/
private T setInitialValue() {
// 调用initialValue获取初始化的值
// 此方法可以被子类重写, 如果不重写默认返回null
T value = initialValue();
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 判断map是否存在
if (map != null)
// 存在则调用map.set设置此实体entry
map.set(this, value);
else
// 1)当前线程Thread 不存在ThreadLocalMap对象
// 2)则调用createMap进行ThreadLocalMap对象的初始化
// 3)并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
createMap(t, value);
// 返回设置的值value
return value;
}
/**
* 删除当前线程中保存的ThreadLocal对应的实体entry
*/
public void remove() {
// 获取当前线程对象中维护的ThreadLocalMap对象
ThreadLocalMap m = getMap(Thread.currentThread());
// 如果此map存在
if (m != null)
// 存在则调用map.remove
// 以当前ThreadLocal为key删除对应的实体entry
m.remove(this);
}
为什么源代码用弱引用？
key为null的entry,原理解析
set、get方法会去检查所有键为null的Entry对象
结论
(在finally后面调用remove方法！！！)
如上文所述，ThreadLocal 适用于如下两种场景
对于第一点，每个线程拥有自己实例，实现它的方式很多。例如可以在线程内部构建一个单独的实例。ThreadLoca 可以以非常方便的形式满足该需求。
对于第二点，可以在满足第一点（每个线程有自己的实例）的条件下，通过方法间引用传递的形式实现。ThreadLocal 使得代码耦合度更低，且实现更优雅。
一个简单的用ThreadLocal来存储Session的例子：
private static final ThreadLocal threadSession = new ThreadLocal();
public static Session getSession() throws InfrastructureException {
Session s = (Session) threadSession.get();
try {
if (s == null) {
s = getSessionFactory().openSession();
threadSession.set(s);
}
} catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
return s;
}
每个线程内需要保存类似于全局变量的信息（例如在拦截器中获取的用户信息），可以让不同方法直接使用，避免参数传递的麻烦却不想被多线程共享（因为不同线程获取到的用户信息不一样）。
例如，用 ThreadLocal 保存一些业务内容（用户权限信息、从用户系统获取到的用户名、用户ID 等），这些信息在同一个线程内相同，但是不同的线程使用的业务内容是不相同的。
在线程生命周期内，都通过这个静态 ThreadLocal 实例的 get() 方法取得自己 set 过的那个对象，避免了将这个对象（如 user 对象）作为参数传递的麻烦。
比如说我们是一个用户系统，那么当一个请求进来的时候，一个线程会负责执行这个请求，然后这个请求就会依次调用service-1()、service-2()、service-3()、service-4()，这4个方法可能是分布在不同的类中的。这个例子和存储session有些像。
public class ThreadLocalDemo {
public static void main(String[] args) {
User user = new User("jack");
new Service1().service1(user);
}
}
class Service1 {
public void service1(User user){
//给ThreadLocal赋值，后续的服务直接通过ThreadLocal获取就行了。
UserContextHolder.holder.set(user);
new Service2().service2();
}
}
class Service2 {
public void service2(){
User user = UserContextHolder.holder.get();
System.out.println("service2拿到的用户:"+user.name);
new Service3().service3();
}
}
class Service3 {
public void service3(){
User user = UserContextHolder.holder.get();
System.out.println("service3拿到的用户:"+user.name);
//在整个流程执行完毕后，一定要执行remove
UserContextHolder.holder.remove();
}
}
class UserContextHolder {
//创建ThreadLocal保存User对象
public static ThreadLocal<User> holder = new ThreadLocal<>();
}
class User {
String name;
public User(String name){
this.name = name;
}
}
执行的结果：
service2拿到的用户:jack
service3拿到的用户:jack
我们知道在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域。就是因为Spring对一些Bean（如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等）中非线程安全的“状态性对象”采用ThreadLocal进行封装，让它们也成为线程安全的“状态性对象”，因此有状态的Bean就能够以singleton的方式在多线程中正常工作了。
一般的Web应用划分为展现层、服务层和持久层三个层次，在不同的层中编写对应的逻辑，下层通过接口向上层开放功能调用。在一般情况下，从接收请求到返回响应所经过的所有程序调用都同属于一个线程。
这样用户就可以根据需要，将一些非线程安全的变量以ThreadLocal存放，在同一次请求响应的调用线程中，所有对象所访问的同一ThreadLocal变量都是当前线程所绑定的。
参考文献：
B站周扬老师的JUC并发编程
https://www.bilibili.com/video/BV1ar4y1x727