ThreadLocal为每一个线程创建一个单独的变量副本，而每个线程都可以独立地改变自己所拥有的变量副本，而不会影响其他线程所对应的副本。
Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMap。
ThreadLocalMap有自己的独立实现，可以简单地将它的key视作ThreadLocal，value为代码中放入的值（实际上key并不是ThreadLocal本身，而是它的一个弱引用）。
每个线程在往ThreadLocal里放值的时候，都会往自己的ThreadLocalMap里存，读也是以ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。
ThreadLocal是为了方便每个线程处理自己的状态而引入的一个机制。
1.ThreadLocal是什么
该类提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其get 或 set方法）的每个线程都有自己的局部变量，它独立于变量的初始化副本。
ThreadLocal实例通常是类中的 private static 字段，它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联 。所以ThreadLocal与线程同步机制不同，线程同步机制是多个线程共享同一个变量，而ThreadLocal是为每一个线程创建一个单独的变量副本，故而每个线程都可以独立地改变自己所拥有的变量副本，而不会影响其他线程所对应的副本。可以这么说ThreadLocal为多线程环境下变量问题提供了另外一种解决思路。
Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMap。
ThreadLocalMap有自己的独立实现，可以简单地将它的key视作ThreadLocal，value为代码中放入的值（实际上key并不是ThreadLocal本身，而是它的一个弱引用）。
每个线程在往ThreadLocal里放值的时候，都会往自己的ThreadLocalMap里存，读也是以ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。
ThreadLocal并不是为线程保存对象的副本，它仅仅只起到一个索引的作用。它主要为每一个线程隔离一个类的实例，这个实例的作用范围仅限于线程内部。
2.ThreadLocal使用示例
示例一：
package com.cloud;
public class ThreadLocalDemo {
private static ThreadLocal<Integer> countValue = new ThreadLocal<Integer>(){
// 实现initialValue()
public Integer initialValue() {
return 0;
}
};
public int nextSeq(){
countValue.set(countValue.get() + 1);
return countValue.get();
}
public static void main(String[] args){
ThreadLocalDemo demo = new ThreadLocalDemo();
MyThread thread1 = new MyThread(demo);
MyThread thread2 = new MyThread(demo);
MyThread thread3 = new MyThread(demo);
MyThread thread4 = new MyThread(demo);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
}
private static class MyThread extends Thread{
private ThreadLocalDemo demo;
MyThread(ThreadLocalDemo demo){
this.demo = demo;
}
@Override
public void run() {
for(int i = 0 ; i < 3 ; i++){
System.out.println(Thread.currentThread().getName() + " countValue :" + demo.nextSeq());
}
}
}
}
通过设置一个countValue变量，然后每个线程绑定该变量，同时进行值更新操作，测试证明各个线程互相不影响，示例结果返回如下：
Thread-1 countValue :1
Thread-1 countValue :2
Thread-1 countValue :3
Thread-0 countValue :1
Thread-0 countValue :2
Thread-0 countValue :3
Thread-2 countValue :1
Thread-2 countValue :2
Thread-2 countValue :3
Thread-3 countValue :1
Thread-3 countValue :2
Thread-3 countValue :3
示例二：平时我们用的比较多使用threadlocal存储登录，方便一次请求调用上下文获取登录信息
@Component
public class AuthInterceptor implements HandlerInterceptor {
private static final String AUTHORIZE_TOKEN = "authorization";
public static ThreadLocal<LoginVO> localUser = new ThreadLocal<>();
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {
//网关服务会把token放在header里面
String token = request.getHeader(AUTHORIZE_TOKEN);
//如果为空，则输出错误代码
if (StringUtils.isBlank(token)) {
//设置方法不允许被访问，405错误代码
response.setStatus(HttpStatus.METHOD_NOT_ALLOWED.value());
return false;
}
//解析令牌数据
try {
Claims claims = JwtUtil.parseJWT(token);
LoginVO loginVO = JSONObject.parseObject(claims.getSubject(), LoginVO.class);
localUser.set(loginVO);
} catch (Exception e) {
e.printStackTrace();
//解析失败，响应401错误
response.setStatus(HttpStatus.UNAUTHORIZED.value());
return false;
}
return true;
}
}
3.ThreadLocal源码
ThreadLocal虽然解决了这个多线程变量的复杂问题，但是它的源码实现却是比较简单的。ThreadLocalMap是实现ThreadLocal的关键，我们先从它入手。
ThreadLocalMap
ThreadLocalMap其内部利用Entry来实现key-value的存储，如下：
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
从上面代码中可以看出Entry的key就是ThreadLocal，而value就是值。同时，Entry也继承WeakReference，所以说Entry所对应key（ThreadLocal实例）的引用为一个弱引用.
ThreadLocalMap的源码稍微多了点，我们就看两个最核心的方法getEntry()、set(ThreadLocal> key, Object value)方法。
set(ThreadLocal> key, Object value)
private void set(ThreadLocal<?> key, Object value) {
ThreadLocal.ThreadLocalMap.Entry[] tab = table;
int len = tab.length;
// 根据 ThreadLocal 的散列值，查找对应元素在数组中的位置
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();
// key 存在，直接覆盖
if (k == key) {
e.value = value;
return;
}
// key == null，但是存在值（因为此处的e != null），说明之前的
//ThreadLocal对象已经被回收了
if (k == null) {
// 用新元素替换陈旧的元素
replaceStaleEntry(key, value, i);
return;
}
}
// ThreadLocal对应的key实例不存在也没有陈旧元素，new 一个
tab[i] = new ThreadLocal.ThreadLocalMap.Entry(key, value);
int sz = ++size;
// cleanSomeSlots 清楚陈旧的Entry（key == null）
// 如果没有清理陈旧的 Entry 并且数组中的元素大于了阈值，则进行 rehash
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
get()
返回当前线程所对应的线程变量
public T get() {
// 获取当前线程
Thread t = Thread.currentThread();
// 获取当前线程的成员变量 threadLocal
ThreadLocalMap map = getMap(t);
if (map != null) {
// 从当前线程的ThreadLocalMap获取相对应的Entry
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
// 获取目标值
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
首先通过当前线程获取所对应的成员变量ThreadLocalMap，然后通过ThreadLocalMap获取当前ThreadLocal的Entry，最后通过所获取的Entry获取目标值result。
getMap()方法可以获取当前线程所对应的ThreadLocalMap，如下：
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
set(T value)
设置当前线程的线程局部变量的值。
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null){
map.set(this, value);
}else{
createMap(t, value);
}
}
获取当前线程所对应的ThreadLocalMap，如果不为空，则调用ThreadLocalMap的set()方法，key就是当前ThreadLocal，如果不存在，则调用createMap()方法新建一个，如下：
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
210
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
