由浅入深全面解析ThreadLocal
目录
简介
- 线程并发：在多线程并发的场景下使用
- 传递数据：我们可以通过ThreadLocal在同一线程，不同组件中传递公共变量
- 线程隔离：每个线程的变量都是独立的，不会相互影响
基本使用
常用方法
代码案例实现
(1) 不使用ThreadLocal时模拟多线程存取数据
public class ThreadLocalDemo1 {
private String content;
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public static void main(String[] args) {
ThreadLocalDemo1 threadLocalDemo = new ThreadLocalDemo1();
for (int i = 0; i < 5; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
/**
* 每一个线程存一个变量，过一会取出这个变量
*/
threadLocalDemo.setContent(Thread.currentThread().getName() + "的数据");
System.out.println("------------------------");
System.out.println(Thread.currentThread().getName() + "----->" + threadLocalDemo.getContent());
}
});
thread.setName("线程" + i);
thread.start();
}
}
}
结果：
------------------------
线程0----->线程4的数据
------------------------
线程4----->线程4的数据
------------------------
线程2----->线程4的数据
------------------------
线程3----->线程4的数据
------------------------
线程1----->线程4的数据
（2） 使用ThreadLocal对多线程进行数据隔离，把数据绑定到ThreadLocal
（传统解决方案首先想到的就是加锁，确实可以实现，但是却牺牲了效率，需要等待上一个线程之行结束才可以往下之行）
public class ThreadLocalDemo2 {
ThreadLocal<String> threadLocal = new ThreadLocal<>();
private String content;
public String getContent() {
return threadLocal.get();
}
public void setContent(String content) {
threadLocal.set(content);
}
public static void main(String[] args) {
ThreadLocalDemo2 threadLocalDemo2 = new ThreadLocalDemo2();
for (int i = 0; i < 5; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
/**
* 每一个线程存一个变量，过一会取出这个变量
*/
threadLocalDemo2.setContent(Thread.currentThread().getName()+"的数据");
System.out.println("------------------------");
System.out.println(Thread.currentThread().getName() + "----->" + threadLocalDemo2.getContent());
}
});
thread.setName("线程" + i);
thread.start();
}
}
}
结果：
------------------------
------------------------
------------------------
线程3----->线程3的数据
------------------------
线程2----->线程2的数据
线程1----->线程1的数据
线程0----->线程0的数据
------------------------
线程4----->线程4的数据
ThreadLocal与synchronized的区别
二者都是用来处理多线程并发访问的问题，但是二者的原理和侧重点不一样，简要说就是，ThreadLocal牺牲了空间，而synchronized是牺牲了时间来保证线程安全（隔离）。
总结：在上述的案例当中，使用ThreadLocal更为合理，这样保证了程序拥有了更高的并发性。
ThreadLocal现在的设计（JDK1.8）
- 简介
每一个Thread维护一个ThreadLocalMap，这个Map的key为ThreadLocal实例本身，而value则为实际存储的值。 - 具体过程
（1）每一个Thread内部都有一个Map（ThreadLocalMap）
（2）Map里面存储的ThreadLocal对象（key）和线程的变量副本（value）
（3）Thread的Map是由ThreadLocal来维护的，由ThreadLocal负责向Map获取和设置线程的变量值。
（4）对于线程获取值，每一个副本只能获取当前线程本地的副本值，别的线程无法访问到，互不干扰，实现了线程隔离。 - 对比与1.8之前的设计（相当于Thread与ThreadLocal的角色互换了）
- 1.8设计的好处
（1）每个Map存储的Entry数量变少了（因为实际状况下Thread比ThreadLocal多）
（2）当Thread销毁时，ThreadLocalMap也会随之销毁，避免内存的浪费
ThreadLocal核心方法源码分析
- get方法源码
public T get() {
// 获取当前线程
Thread t = Thread.currentThread();
// 获取ThreadLocalMap
ThreadLocalMap map = getMap(t);
// map不为空时，获取里面的Entry
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
// 返回结果
return result;
}
}
// 没有则赋值初始值null并返回
return setInitialValue();
}
- set方法源码
public void set(T value) {
// 获取当前线程
Thread t = Thread.currentThread();
// 获取ThreadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null) {
// 不为空直接set
map.set(this, value);
} else {
// map为空则创建并set
createMap(t, value);
}
}
- initialValue方法返回初始值（protected修饰为了让子类覆盖设计的）需要自定义初始值可以重写该方法
protected T initialValue() {
return null;
}
- remove方法
public void remove() {
// 获取当前线程的ThreadLocalMap
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null) {
// 移除ThreadLocalMap
m.remove(this);
}
}
- setInitialValue方法
private T setInitialValue() {
// 得到初始化值null
T value = initialValue();
// 获取当前线程
Thread t = Thread.currentThread();
// 获取线程中ThreadLocalMap
ThreadLocalMap map = getMap(t);
// map存在的话把null设置进去，不存在则创建一个并将null设置进去
if (map != null) {
map.set(this, value);
} else {
createMap(t, value);
}
// 如果当前ThreadLocal属于TerminatingThreadLocal（关闭的ThreadLocal）则register（注册）到TerminatingThreadLocal
if (this instanceof TerminatingThreadLocal) {
TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
}
return value;
}
ThreadLocalMap源码分析
- 简介
ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，是独自设计实现Map功能，内部的Entry也是独立的。 - 结构图解
- 成员变量
// Entry类，继承弱应用，为了和Thread的生命周期解绑
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
/**
* The initial capacity -- MUST be a power of two.
* 初始容量，必须是二的幂
*/
private static final int INITIAL_CAPACITY = 16;
/**
* The table, resized as necessary.
* table.length MUST always be a power of two.
* 根据需要调整大小。长度必须是2的幂。
*/
private Entry[] table;
/**
* The number of entries in the table.
* table中的entrie数量
*/
private int size = 0;
/**
* The next size value at which to resize.
* 要调整大小的下一个大小值
*/
private int threshold; // Default to 0
/**
* Set the resize threshold to maintain at worst a 2/3 load factor.
* 设置调整大小阈值以维持最坏的2/3负载因子
*/
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
/**
* Increment i modulo len.
* 增量一
*/
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
/**
* Decrement i modulo len.
* 减量一
*/
private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
弱引用与内存泄露（内存泄漏和弱引用没有直接关系）
- 内存泄漏/溢出概念
（1）Memory overflow：内存溢出，没有足够的空间提供给申请者使用
（2）Memory leak：内存泄漏，系统中已动态分配的堆内存由于某种原因无法释放或者没有释放，导致系统内存堆积，影响系统运行，甚至导致系统崩溃。内存泄漏终将导致内存溢出。 - 强/弱引用概念
（1）Strong Referce：强引用，我们常见的对象引用，只要有一个强引用指向对象，也就表明还“活着”，这种状况下垃圾回收机制（GC）是不会回收的。
（2）Weak Referce：弱引用，继承了WeakReferce的对象，垃圾回收器发现了只具有弱引用的对象，不管当前系统的内存是否充足，都会回收他的内存。 - 如果key，即Entry使用强引用，也无法避免内存泄漏
因为Entry是在Thread当前线程中，生命周期和Thread一样，没有手动删除Entry时Entry就会内存泄漏。 - 也就是说，只要在调用完ThreadLocal后及时使用remove方法，才能避免内存泄漏
ThreadLocal核心源码（Hash冲突解决）
- 从构造方法入手
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
// 初始化table
table = new Entry[INITIAL_CAPACITY];
// 计算索引在数组中的位置（核心代码）
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
// 设置值
table[i] = new Entry(firstKey, firstValue);
size = 1;
// 设置阈值（INITIAL_CAPACITY的三分之二）
setThreshold(INITIAL_CAPACITY);
}
- 重点分析int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
private final int threadLocalHashCode = nextHashCode();
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
private static AtomicInteger nextHashCode = new AtomicInteger();
private static final int HASH_INCREMENT = 0x61c88647;
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
}
（1）这里定义了一个AtomicInteger，每次获取并加上HASH_INCREMENT（0x61c88647，这个值与斐波那契数（黄金分割）有关），是为了让哈希码能够均匀的分布在2的n次方的数组（Entry[]）里面，也就尽可能避免了哈希冲突。
（2）hashcode & (INITIAL_CAPACITY - 1) 相当于hashcode % (INITIAL_CAPACITY - 1) 的高效写法，所以size必须为2的次幂，这样最大程度避免了哈希冲突。
- set方法源码分析
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
// 计算索引
int i = key.threadLocalHashCode & (len-1);
/**
*
* 使用线性探测法查找元素
* */
for (Entry e = tab[i];
e != null;
// 使用线性探测法查找元素
e = tab[i = nextIndex(i, len)]) {
// 获取到该Entry对应的ThreadLocal
ThreadLocal<?> k = e.get();
if (k == key) {
// key存在则覆盖value
e.value = value;
return;
}
// key为null但是值不为null，这说明了之前使用过，但是ThreadLocal被垃圾回收了，当前的Entry是一个陈旧的（Stale）元素
if (k == null) {
// key（ThreadLocal）不存在，则新Entry替换旧的Entry，此方法做了不少垃圾清理的动作，避免了内存泄漏。
replaceStaleEntry(key, value, i);
return;
}
}
// ThreadLocal中未找到key也没有陈旧的元素，此时则在这个位置新创建一个Entry
tab[i] = new Entry(key, value);
int sz = ++size;
// cleanSomeSlots用于清理e.get()为null的key，如果大于阈值（2/3容量）则rehash（执行一次全表扫描清理工作）
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
/**
* 线性探测法查找元素，到最后一个时重定位到第一个
*/
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
