一种解决多线程环境下成员变量的问题的方案，但是与线程同步无关，其思路是为每一个线程创建一个单独的变量副本，从而每个线程都可以独立地改变所拥有的变量副本，而不会影响其他线程所对应的副本；
ThreadLocal不是用于解决共享变量的问题的，也不是为了协调线程同步而存在，而是为了方便每个线程处理自己的状态而引入的一个机制；
1、threadlocal使用
void set(Object value)
设置当前线程的线程局部变量的值
public Object get()
该方法返回当前线程所对应的线程局部变量
public void remove()
将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度；
创建一个ThreadLocal对象
private ThreadLocal localInt = new ThreadLocal<>();
public int setAndGet(){
localInt.set(8);
return localInt.get();
}
设置变量的值为8
ThreadLocal里设置的值，只有当前线程自己看得见，这意味着你不可能通过其他线程为它初始化值。为了弥补这一点，ThreadLocal提供了一个withInitial()方法统一初始化所有线程的ThreadLocal的值：
private ThreadLocal localInt = ThreadLocal.withInitial(() -> 6);
上述代码将ThreadLocal的初始值设置为6，这对全体线程都是可见的
2、ThreadLocal源码分析
ThreadLocal类源码
private final int threadLocalHashCode = nextHashCode();
private static AtomicInteger nextHashCode = new AtomicInteger();
private static final int HASH_INCREMENT = 0x61c88647;
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
static class ThreadLocalMap {
private Entry[] table;//数据数组
private int size = 0;//数组大小
private int threshold; //阈值
private static final int INITIAL_CAPACITY = 16; //默认大小
static class Entry extends WeakReference> {
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);
}
}
作为一个存储数据的类，关键点就在get和set方法。
（1）set 方法
//set 方法
public void set(T value) {
//获取当前线程
Thread t = Thread.currentThread();
//实际存储的数据结构类型
ThreadLocalMap map = getMap(t);
//如果存在map就直接set，没有则创建map并set
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
//getMap方法
ThreadLocalMap getMap(Thread t) {
//thred中维护了一个ThreadLocalMap
return t.threadLocals;
}
//createMap
void createMap(Thread t, T firstValue) {
//实例化一个新的ThreadLocalMap，并赋值给线程的成员变量threadLocals
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
- 首先获取当前线程，并根据当前线程获取一个Map。
- 如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key）。
- (这里调用了ThreadLocalMap的set方法)**。
- 如果Map为空，则给该线程创建 Map，并设置初始值。
- (这里调用了ThreadLocalMap的构造方法)**。
- 构造方法`ThreadLocalMap(ThreadLocal firstKey, Object 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);
}
构造函数首先创建一个长度为16的Entry数组，然后计算出firstKey对应的索引，然后存储到table中，并设置size和threshold。
ThreadLocalMap中的set方法
private void set(ThreadLocal key, Object value) {
ThreadLocal.ThreadLocalMap.Entry[] tab = table;
int len = tab.length;
//计算索引(重点代码，刚才分析过了）
int i = key.threadLocalHashCode & (len-1);
for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal k = e.get();
//ThreadLocal 对应的 key 存在，直接覆盖之前的值
if (k == key) {
e.value = value;
return;
}
// key为 null，但是值不为 null，说明之前的 ThreadLocal 对象已经被回收了，
// 当前数组中的 Entry 是一个陈旧（stale）的元素
if (k == null) {
//用新元素替换陈旧的元素，这个方法进行了不少的垃圾清理动作，防止内存泄漏
replaceStaleEntry(key, value, i);
return;
}
}
//ThreadLocal对应的key不存在并且没有找到陈旧的元素，则在空元素的位置创建一个新的Entry。
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}- 首先还是根据key计算出索引 i，然后查找i位置上的Entry。
- 若是Entry已经存在并且key等于传入的key，那么这时候直接给这个Entry赋新的value值。
- 若是Entry存在，但是key为null，则调用replaceStaleEntry来更换这个key为空的Entry。
- 不断循环检测，直到遇到为null的地方，这时候要是还没在循环过程中return，那么就在这个null的位置新建一个Entry，并且插入，同时size增加1。
- ThreadLocalMap使用线性探测法来解决哈希冲突的；该方法一次探测下一个地址，直到有空的地址后插入，若整个空间都找不到空余的地址，则产生溢出。
（2）get()方法
//ThreadLocal中get方法
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
//ThreadLocalMap中getEntry方法
private Entry getEntry(ThreadLocal key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}
通过计算出索引直接从数组对应位置读取即可；
（3）ThreadLocal特性
- ThreadLocal和Synchronized都是为了解决多线程中相同变量的访问冲突问题；
- Synchronized是通过线程等待，牺牲时间来解决访问冲突
- ThreadLocal是通过每个线程单独一份存储空间，牺牲空间来解决冲突，并且相比于Synchronized，ThreadLocal具有线程隔离的效果，只有在线程内才能获取到对应的值，线程外则不能访问到想要的值；
- 正因为ThreadLocal的线程隔离特性，使他的应用场景相对来说更为特殊一些。在android中Looper、ActivityThread以及AMS中都用到了ThreadLocal；
- 当某些数据是以线程为作用域并且不同线程具有不同的数据副本的时候，就可以考虑采用ThreadLocal；
3、ThreadLocal内存泄漏
我们调用threadLocal的set，get方法时，会判断当前的key是否为null，将Entry中的value赋值为null，但是这个释放value还有其他条件限制，并不是一定会发生，当系统内存不足时，由于Entry中的key继承软引用，回被垃圾回收器回收调，这时，Entry中的key为null，无法被线程访问，但是value仍然占用一定的内存空间，虽然在调用set，get方法时有可能进行系统回收，仍然无法回收无用所有内存。无法被访问的vlaue就会导致内存泄漏，怎么解决内存泄漏呢，最好的方法就是当我们使用完变量副本后及时调用remove方法，手动进行垃圾回收。
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
private void remove(ThreadLocal key) {
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)]) {
if (e.get() == key) {
e.clear();//清除value
expungeStaleEntry(i);
return;
}
}
}- 当线程发生内存泄漏时，线程与内部的ThreadLocalMap之间存在着强引用，导致ThreadLocalMap无法被释放，这时由于ThreadLocalMap中的Entry的key为弱引用，ThreadLocal容易被回收，导致key为null，当调用remove方法时，会清除key为null对应的value。
- 所以为了避免内存泄漏的出现，我们在使用完ThreadLocal的set方法后，及时调用remove方法进行内存释放。避免出现内存泄漏。
免责声明：
① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。
② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
