ThreadLocal
引发的问题：
- Java中的引用类型有哪几种?
- 每种引用类型的特点是什么?
- 每种引用类型的应用场景是什么?
- ThreadLocal是什么？
- ThreadLocal应用在什么地方? Spring事务方面应用到了吗？
- ThreadLocal会产生内存泄漏了解吗?
1 引用类型
Java中四大引用类型：
-
强 引用: 最普通的引用 Object o = new Object()
-
软 引用: 垃圾回收器, 内存不够的时候回收 (缓存)
-
弱 引用: 垃圾回收器看见就会回收 (防止内存泄漏)
-
虚 引用: 垃圾回收器看见二话不说就回收,跟没有一样 (管理堆外内存) DirectByteBuffer -> 应用到NIO Netty
**注：**finalize() ->当对象被回收时, finalize()方法会被调用, 但是不推荐使用去回收一些资源,因为不知道他什么时候会被调用, 有时候不一定会调用
finalize()：
public class C {
@Override
protected void finalize() throws Throwable {
System.out.println("finalize");
}
}
- 强引用：正常引用，但在没有指向的时候就会被回收
/**
* 强引用
*/
public class R1_NormalReference {
public static void main(String[] args) throws IOException {
//正常引用
C c = new C();
c = null;//没人指向
System.gc();//DisableExplicitGC
//阻塞一下,方便看结果
System.in.read();
}
}
- 软引用：垃圾回收器, 内存不够的时候回收 (缓存)
/**
* 软引用
*/
public class R2_SoftReference {
public static void main(String[] args) {
SoftReference<byte[]> soft = new SoftReference<>(new byte[1024 * 1024 * 10]);//10M
System.out.println(soft.get());
//gc回收
System.gc();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(soft.get());
//再分配一个数组,好heap(堆)放不下, 这个时候系统会回收一次, 如果不够,会把软引用回收
byte[] bytes = new byte[1024 * 1024 * 15];
System.out.println(soft.get());
}
}
结果:
[B@1540e19d
[B@1540e19d
null
前提设置 -Xmx30M 堆内存最大30M 用于测试
idea 设置：
- 弱引用：遇到GC就会被回收
/**
* 弱引用
*/
public class R3_WeakReference {
public static void main(String[] args) {
WeakReference<C> weak = new WeakReference<>(new C());
System.out.println(weak.get());
//gc回收
System.gc();
//遇到GC就会被回收
System.out.println(weak.get());
}
}
结果:
com.cz.reference.C@3c679bde
null
finalize
- 虚引用：不管三七二十一 遇到直接回收
/**
* 虚引用
*/
public class R4_PhantomReference {
private static final List<Object> LIST = new LinkedList<>();
private static final ReferenceQueue QUEUE = new ReferenceQueue();
public static void main(String[] args) {
PhantomReference<C> phantomReference = new PhantomReference<>(new C(),QUEUE);
new Thread(() -> {
while (true){
LIST.add(new byte[1024*1024]);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
System.out.println(phantomReference.get());
}
}).start();
new Thread(() -> {
while (true){
Reference<? extends C> poll = QUEUE.poll();
if (poll != null){
System.out.println("-----虚引用对象被JVm回收了--------" + poll);
return;
}
}
}).start();
}
}
结果:
null
null
finalize
null
null
总结：
- 强 正常的引用
- 软 内存不够, 进行清除
- 大对象的内存
- 常用对象的缓存
- 弱 遇到GC就会被回收
- 缓存, 没有容器引用指向的时候就需要清除缓存
- ThreadLocal
- WeakReferenceMap
- 虚 看见就回收, 且看不到值
- 管理堆外内存
2 ThreadLocal
- 从Java官方文档中的描述：ThreadLocal类用来提供线程内部的局部变是。这种变畺在多线程环境下访问（通 过get和set方法访问）时能保证各个线程的变星=相对独立于其他线程内的变垦。ThreadLocal实例通常来说都是 private static类型的，用于关联线程和线程上下文
- 我们可以得知ThreadLocal的作用是：提供线程内的周部变星，不同的线程之间不会相互干扰，这种变星在 线程的生命周朗内起作用，减少同一个线程内多个函数或组件之间一些公共变畺传递的复杂度
特点：
| 特点 | 内容 |
|---|---|
| 线程并发 | 在多线程并发场景下 |
| 传递数据 | 我们可以通过ThreadLocal在同一线程,不同组件中传递公共变量 (保存每个线程的数据,在需要的地方可以直接获取, 避免参数直接传递带来的代码耦合问题) |
| 线程隔离 | 每个线程的变量都是独立的, 不会互相影响.(核心) (各线程之间的数据相互隔离却又具备并发性,避免同步方式带来的性能损失) |
核心方法：
| 方法声明 | 描述 |
|---|---|
| public static | 创建线程局部变量 |
| protected T initialValue() | 返回当前线程局部变量的初始值 |
| public void set(T value) | 设置当前线程绑定的局部变量 |
| public T get() | 获取当前线程绑定的局部变量 |
| public void remove() | 移除当前线程绑定的局部变量 |
3 Synchronized
- 虽然ThreadLocal模式与Synchronized关键字都用于处理多线程并发访问变量的问题, 不过两者处理问题的角度和思路不同
ThreadLocal 和 Synchronized 的区别：
| Synchronized | ThreadLocal | |
|---|---|---|
| 原理 | 同步机制采用以时间换空间的方式,只提供了一份变量, 让不同的线程排队访问 | ThreadLocal采用以空间换时间的方式, 为每一个线程都提供了一份变量的副本, 从而实现同访问而相不干扰 |
| 侧重点 | 多个线程之间访问资源的同步 | 多线程中让每个线程之间的数据相互隔离 |
4 内部结构
JDK 早期设计：
- 每个ThreadLocal都创建一个Map, 然后用Thread(线程) 作为Map的key, 要存储的局部变量作为Map的value, 这样就能达到各个线程的局部变量隔离的效果, 这是最简单的设计方法
JDK8 优化设计(现在的设计)：
- JDK8中ThreadLocal的设计是 : 每个Thread维护一个ThreadLocalMap, 这个Map的key是ThreadLocal实例本身,value才是真正要存储的值Object
具体过程如下：
- 每个THreadLocal线程内部都有一个Map(ThreadLocalMap)
- Map里面存储的ThreadLocal对象(key)和线程变量副本(Value)也就是存储的值
- Thread内部的Map是由ThreadLocal维护的, 有THreadLocal负责向map获取和设置线程变量值
- 对于不同的线程, 每次获取value(也就是副本值),别的线程并不能获取当前线程的副本值, 形成了副本的隔离,互不干扰
对比：
5 ThreadLocalMap
- 基本结构：ThreadLocalMap是ThreadLocal的静态内部类, 没有实现Map接口, 用独立的方式实现了Map的功能, 其内部的Entry也是独立实现
继承结构：
类结构信息：
成员变量：
/**
* The initial capacity -- MUST be a power of two.
* 初始化容量,必须是2的整数次幂
*/
private static final int INITIAL_CAPACITY = 16;
/**
* 存放数据的table, 同样数组长度必须是2的整数次幂
* The table, resized as necessary.
* table.length MUST always be a power of two.
*/
private Entry[] table;
/**
* 数组里entrys的个数,可以判断table是否超过阈值 (存储的格式)
* The number of entries in the table.
*/
private int size = 0;
/**
* 阈值 进行扩容的阈值,表使用大于他的时候,进行扩容
* The next size value at which to resize.
*/
private int threshold; // Default to 0
存储结构-Entry：
/**
* 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.
翻译:
* Entry继承WeakReference, 并且用ThreadLocal作为key
* 如果key为null(entry.get() == null)意味着key不在被引用,因此这时候entry也可以从tab
*中清除(被垃圾回收器回收)
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
注意：(ThreadLocal) key是弱引用, 其目的就是讲ThreadLocal对象的生命周期和和线程的生命周期解绑. 减少内存使用
6 内存泄漏
- 内存溢出: Memory overflow 没有足够的内存提供申请者使用
- 内存泄漏: Memory Leak 程序中已经动态分配的堆内存由于某种原因, 程序未释放或者无法释放, 造成系统内部的浪费, 导致程序运行速度减缓甚至系统崩溃等严重结果. 内存泄漏的堆积终将导致内存溢出
如果 Key 是强引用：
-
假设ThreadLocalMap中的key使用了强引用, 那么会出现内存泄漏吗?
- 假设在业务代码中使用完ThreadLocal, ThreadLocal ref被回收了
- 但是因为threadLocalMap的Entry强引用了threadLocal, 造成ThreadLocal无法被回收
- 在没有手动删除Entry以及CurrentThread依然运行的前提下, 始终有强引用链threadRef → currentThread → entry, Entry就不会被回收( Entry中包括了ThreadLocal实例和value), 导致Entry内存泄漏
也就是说: ThreadLocalMap中的key使用了强引用, 是无法完全避免内存泄漏的
如果key是弱引用：
-
假设ThreadLocalMap中的key使用了弱引用, 那么会出现内存泄漏吗?
- 假设在业务代码中使用完ThreadLocal, ThreadLocal ref被回收了
- 由于threadLocalMap只持有ThreadLocal的弱引用, 没有任何强引用指向threadlocal实例, 所以threadlocal就可以顺利被gc回收, 此时Entry中的key = null
- 在没有手动删除Entry以及CurrentThread依然运行的前提下, 也存在有强引用链threadRef → currentThread → value, value就不会被回收, 而这块value永远不会被访问到了, 导致value内存泄漏
也就是说: ThreadLocalMap中的key使用了弱引用, 也有可能内存泄漏
内存泄漏的真实原因：
出现内存泄漏的真实原因出改以上两种情况，比较以上两种情况,我们就会发现：
内存泄漏的发生跟 ThreadLocalIMap 中的 key 是否使用弱引用是没有关系的。那么内存泄漏的的真正原因是什么呢？
细心的同学会发现，在以上两种内存泄漏的情况中．都有两个前提：
-
没有手动侧除这个 Entry
-
CurrentThread 依然运行
- 第一点很好理解，只要在使用完下 ThreadLocal ，调用其 remove 方法翻除对应的 Entry ，就能避免内存泄漏
- 第二点稍微复杂一点，由于ThreodLocalMap 是 Threod 的一个属性，被当前线程所引甲丁所以它的生命周期跟 Thread 一样长。那么在使用完 ThreadLocal 的使用，如果当前Thread 也随之执行结束， ThreadLocalMap 自然也会被 gc 回收，从根源上避免了内存泄漏
综上， ThreadLocal 内存泄漏的根源是：由于ThreadLocalMap 的生命周期跟 Thread 一样长，如果没有手动删除对应 key 就会导致内存泄漏
为什么使用弱引用：
为什么使用弱引用，根据刚才的分析，我们知道了：
- 无论 ThreadLocalMap 中的 key 使用哪种类型引用都无法完全避免内存泄漏，跟使用弱引用没有关系
要避免内存泄漏有两种方式：
-
使用完 ThreadLocal ，调用其 remove 方法删除对应的 Entry
-
使用完 ThreadLocal ，当前 Thread 也随之运行结束
相对第一种方式，第二种方式显然更不好控制，特别是使用线程池的时候，线程结束是不会销毁的
也就是说，只要记得在使用完ThreadLocal 及时的调用 remove ，无论 key 是强引用还是弱引用都不会有问题
那么为什么 key 要用弱引用呢？
事实上，在 ThreadLocalMap 中的set/getEntry 方法中，会对 key 为 null （也即是 ThreadLocal 为 null ）进行判断，如果为 null 的话，那么是会又如 value 置为 null 的
这就意味着使用完 ThreadLocal , CurrentThread 依然运行的前提下．就算忘记调用 remove 方法，弱引用比强引用可以多一层保障：弱引用的 ThreadLocal 会被回收．对应value在下一次 ThreadLocaIMap 调用 set/get/remove 中的任一方法的时候会被清除，从而避免内存泄漏
305
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
