ThreadLocal
简介
ThreadLocal提供局部线程变量，这个变量与普通的变量不同，每个线程在访问ThreadLocal实例的时候，（通过get或者set方法）都有自己的、独立初始化变量副本。ThreadLocal实例通常是类中的私有静态字段，使用它的目的是希望将状态（用户ID或者事务ID）与线程关联起来。
每个线程都有自己的、独立初始化变量副本，意味着避免了线程安全问题
使用
- ThreadLocal
.withInitial()：创建ThreadLocal并设置初始值 - initialValue()：返回局部线程变量的当前线程的初始化值
- get()：返回局部线程变量在当前线程副本的值
- set()：设置局部线程变量在当前线程副本的值
- remove()：删除线程的局部线程变量副本
案例
class House {
int saleCount;
public synchronized void saleHouse(int size) {
this.saleCount += size;
}
}
public class SaleHouse {
public static void main(String[] args) {
House house = new House();
for (int i = 0; i < 5; i++) {
new Thread(() -> {
int size = new Random().nextInt(5) + 1;
System.out.println(size);
house.saleHouse(size);
}, String.valueOf(i)).start();
}
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Total: " + house.saleCount);
}
}
现在需要记录每个销售员的业绩，可以使用ThreaLocal设置每个线程变量进行存储
class House {
int saleCount;
ThreadLocal<Integer> saleVolume = ThreadLocal.withInitial(() -> 0);
public synchronized void saleHouse() {
this.saleCount++;
}
public void saleVolumeByThreadLocal() {
saleVolume.set(saleVolume.get() + 1);
}
}
public class SaleHouse {
public static void main(String[] args) {
House house = new House();
for (int i = 0; i < 5; i++) {
new Thread(() -> {
int size = new Random().nextInt(5) + 1;
for (int i1 = 0; i1 < size; i1++) {
house.saleHouse();
house.saleVolumeByThreadLocal();
}
System.out.println(Thread.currentThread().getName() + " sales " + house.saleVolume.get());
}, String.valueOf(i)).start();
}
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Total: " + house.saleCount);
}
}
- 由于是每个线程独有的一个副本变量，因此是绝对线程安全的，不需要将方法变为同步方法
清除局部变量
必须回收自定义的ThreadLocal变量，尤其是在线程池的场景下，线程经常会复用，如果不清理则会造成后续逻辑业务和内存泄漏问题，所以要在代码中使用try-catch进行回收。
ThreadLocal源码解读
Thread ThreadGroup ThreadLocal三者的区别？
- Thread中含有ThreadLocalGroup的属性，而ThreadLocalGroup是ThreadLocal的静态内部类
- ThreadLocalGroup中有一个继承了弱引用WeakReference的Entry内部类
- Entry维护了一个ky键值对，键为当前线程的ThreadLocal，值为任意对象
static class ThreadLocalMap {
/**
* The entries in this hash map extend WeakReference, using
* its main ref field as the key (which is always a
* ThreadLocal object). Note that null keys (i.e. entry.get()
* == null) mean that the key is no longer referenced, so the
* entry can be expunged from table. Such entries are referred to
* as "stale entries" in the code that follows.
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
...
}
原话是：JVM内部维护了一个线程版的Map<ThreadLocal, value>(通过ThreadLocal对象的set方法，把ThreadLocal对象自己当作key放入到ThreadMap中)，每个线程要用到的时候，用当前线程去自己的map里面以相应的ThreadLocal取，通过这样每个线程都拥有了独立的变量。
private T get(Thread t) {
ThreadLocalMap map = getMap(t); // 首先获取当前线程的ThreadLocalMap
if (map != null) {
if (map == ThreadLocalMap.NOT_SUPPORTED) {
return initialValue();
} else {
ThreadLocalMap.Entry e = map.getEntry(this); // 再获取this(ThreadLocal)的值
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T) e.value;
return result;
}
}
}
return setInitialValue(t);
}
ThreadLocal实现数据隔离的原理
-
ThreaLocal只是一个外壳，真正起存储作用的是ThreadLocal的ThreadLocalMap这个内部类，ThreadLocal本身只是作为一个key好从ThreadLocalMap获取value
-
每个Thread维护了一个ThreadLocalMap引用，ThreadLocalMap使用Entry进行的存储
-
ThreadLocal调用set方法时，就是往ThreadLocalMap设置值，key为ThreadLocal，值为传递来的对象
正因为上述原理，ThreadLocal才能实现每个线程拥有一份副本，实现数据隔离
为什么ThreadLocal 的 ThreadLocalMap要使用弱引用
内存泄漏：不会被使用的对象和变量的内存不能被回收，就是内存泄漏
内存溢出：内存泄漏达到一定程度导致无法分配内存，即OOM，就会导致内存溢出
回答这个问题，首先要看一下Java的四种引用：
对于普通的对象，如果没有其他的引用关系，只要超过了引用的作用域范围或者显式地赋值为null，就会被垃圾回收器回收
强引用 Reference
- 强引用是常见的普通对象引用，只要还有强引用指向一个对象，就表明对象还存活，垃圾回收器就不会碰这种对象
- 只要把一个对象赋值给一个引用变量，这个引用变量就是强引用
- 当一个对象被强引用变量引用，它就处于可达状态，垃圾回收器就不可能回收它
- 即使该对象以后永远也用不到，JVM也不会回收，因此强引用是造成JAVA泄漏的主要原因之一
class MyObject {
@Override
protected void finalize() throws Throwable {
System.out.println("--- invoke finalize method!");
}
}
public class ReferenceDemo {
public static void main(String[] args) {
var object = new MyObject();
System.out.println("gc before:" + object);
object = null;
System.gc();
System.out.println("gc after:" + object);
}
}
gc before:com.hikaru.juc.threadLocal.MyObject@7cd84586
gc after:null
--- invoke finalize method!
finalize是在对象被不可撤销的清理之前执行的撤销操作
System.gc() 人工gc
SoftReference 软引用
- 软引用是相对强引用弱化了一些的引用，可以让对象豁免一些垃圾收集
- 当内存充足的时候它不会被回收
- 当内存不足的时候就会被回收
- 所以经常使用在对内存敏感的程序中，如在高速缓存中
weakReference 弱引用
- 比软引用弱化的引用，只要gc就会被回收
虚引用
下面回到最初的问题，为什么ThreadLocal的ThreadLocalMap的Entry要使用弱引用：
ThreadLocal<String> t1 = new ThreadLocal<>();
t1.set("hello");
t1.get();
在创建ThreadLocal的时候，会有强引用变量指向ThreadLocal对象，并且ThreadLocalMap的Entity的key会以弱引用的方式同时指向该对象，当强引用的作用域过期则只有弱引用指向ThreaLocal，而如果不是使用弱引用则ThreaLocal对象就一直不能被垃圾回收从而导致内存泄漏问题。
ThreadLocal之清除脏Entity
问题分析：当我们为ThreadLocal赋值时，实际上就是为当前线程的ThreadLocalMap中添加Entry键值对，而Entry中的key是弱引用，当ThreadLocal外部强引用被赋值为null，那么系统GC的时候，根据可达性分析，没有任何链路能够到达这个ThreadLocal实例，如此一来，ThreadLocalMap就出现了key为null的Entity。
接下来如果线程迟迟不能结束（线程池复用线程），这些key的对象就会由于ThreadLocalMap的强引用链导致永远无法回收，造成内存泄漏。因此，弱引用不能保证内存泄漏问题。
remove方法会寻找脏Entity，即key==null的Entity进行删除。
标签：JUC,变量,ThreadLocalMap,ThreadLocal,线程,引用,内存 From： https://www.cnblogs.com/tod4/p/17201196.html