Java并发（二十）：线程本地变量ThreadLocal

ThreadLocal是一个本地线程副本变量工具类。

主要用于将私有线程和该线程存放的副本对象作一个映射，各个线程之间的变量互不干扰，在高并发场景下，能够实现无状态的调用，特别适用于各个线程依赖不一样的变量值完成操做的场景。

读写锁ReentrantReadWriteLock 记录线程持有的读锁数量时使用了ThreadLocal。Java并发（十）：读写锁ReentrantReadWriteLock

1、ThreadLocal的核心机制

每一个Thread线程内部都有一个Map，Tread类的ThreadLocal.ThreadLocalMap属性

Map里面存储线程本地对象（key也就是当前的ThreadLoacal对象）和线程的变量副本（value）

Thread内部的Map是由ThreadLocal维护的，由ThreadLocal负责向map获取和设置线程的变量值

数据结构：

2、ThreadLocal源码分析

 ThreadLocal核心方法：

• get()：返回此线程局部变量的当前线程副本中的值。
• initialValue()：返回此线程局部变量的当前线程的“初始值”。
• remove()：移除此线程局部变量当前线程的值。
• set(T value)：将此线程局部变量的当前线程副本中的值设置为指定值。

内部类 ThreadLocalMap：

      static class Entry extends WeakReference<ThreadLocal<?>> {
          /** The value associated with this ThreadLocal. */
          Object value;

          Entry(ThreadLocal<?> k, Object v) {
              super(k);
              value = v;
          }
      }

Entry继承自WeakReference（弱引用，生命周期只能存活到下次GC前），但只有Key是弱引用类型的，Value并不是弱引用。

ThreadLocalMap的set()方法：

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();
    }

ThreadLocalMap中解决Hash冲突的方式并不是链表的方式，而是采用线性探测的方式，所谓线性探测，就是根据初始key的hashcode值肯定元素在table数组中的位置，若是发现这个位置上已经有其余key值的元素被占用，则利用固定的算法寻找必定步长的下个位置，依次判断，直至找到可以存放的位置。

ThreadLocalMap解决Hash冲突的方式就是简单的步长加1或减1，寻找下一个相邻的位置。

显然ThreadLocalMap采用线性探测的方式解决Hash冲突的效率很低，若是有大量不一样的ThreadLocal对象放入map中时发送冲突，或者发生二次冲突，则效率很低。

因此这里引出的建议是：每一个线程只存一个变量，这样的话全部的线程存放到map中的Key都是相同的ThreadLocal，若是一个线程要保存多个变量，就须要建立多个ThreadLocal，多个ThreadLocal放入Map中时会极大的增长Hash冲突的可能。

get()方法：

步骤：
（1）获取当前线程的ThreadLocalMap对象threadLocals
（2）从map中获取线程存储的K-V Entry节点。
（3）从Entry节点获取存储的Value副本值返回。
（4）map为空的话返回初始值null，即线程变量副本为null，在使用时须要注意判断NullPointerException。

    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 getMap(Thread t) {
        return t.threadLocals;
    }

set()方法：

步骤：
（1）获取当前线程的成员变量map
（2）map非空，则从新将ThreadLocal和新的value副本放入到map中。
（3）map空，则对线程的成员变量ThreadLocalMap进行初始化建立，并将ThreadLocal和value副本放入map中。

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 getMap(Thread t) {
    return t.threadLocals;
}

void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

 initialValue()方法：

该方法定义为protected级别且返回为null，很明显是要子类实现它的，因此咱们在使用ThreadLocal的时候通常都应该覆盖该方法。该方法不能显示调用，只有在第一次调用get()或者set()方法时才会被执行，而且仅执行1次。

 protected T initialValue() {
        return null;
    }

3、使用场景

简单使用场景一：

public class SeqCount {

    private static ThreadLocal<Integer> seqCount = new ThreadLocal<Integer>(){
        // 实现initialValue()
        public Integer initialValue() {
            return 0;
        }
    };

    public int nextSeq(){
        seqCount.set(seqCount.get() + 1);

        return seqCount.get();
    }

    public static void main(String[] args){
        SeqCount seqCount = new SeqCount();

        SeqThread thread1 = new SeqThread(seqCount);
        SeqThread thread2 = new SeqThread(seqCount);
        SeqThread thread3 = new SeqThread(seqCount);
        SeqThread thread4 = new SeqThread(seqCount);

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }

    private static class SeqThread extends Thread{
        private SeqCount seqCount;

        SeqThread(SeqCount seqCount){
            this.seqCount = seqCount;
        }

        public void run() {
            for(int i = 0 ; i < 3 ; i++){
                System.out.println(Thread.currentThread().getName() + " seqCount :" + seqCount.nextSeq());
            }
        }
    }
}

 运行结果：

　　Thread-1 seqCount :1
　　Thread-3 seqCount :1
　　Thread-3 seqCount :2
　　Thread-3 seqCount :3
　　Thread-0 seqCount :1
　　Thread-0 seqCount :2
　　Thread-0 seqCount :3
　　Thread-2 seqCount :1
　　Thread-1 seqCount :2
　　Thread-1 seqCount :3
　　Thread-2 seqCount :2
　　Thread-2 seqCount :3

相似的ReentrantReadWriteLock中的java.util.concurrent.locks.ReentrantReadWriteLock.Sync.readHolds属性，也使用的了TreadLocal来记录占有该读锁的线程重入次数。可参考：Java并发（十）：读写锁ReentrantReadWriteLock

注意：initialValue()方法返回一个对象时，get()和set()方法操做的实际上是同一个对象的属性，不能实现线程隔离。

使用场景二：session获取场景

每一个线程访问数据库都应当是一个独立的Session会话，若是多个线程共享同一个Session会话，有可能其余线程关闭链接了，当前线程再执行提交时就会出现会话已关闭的异常，致使系统异常。此方式能避免线程争抢Session，提升并发下的安全性。

//获取Session
public static Session getCurrentSession(){
    Session session =  threadLocal.get();
    //判断Session是否为空，若是为空，将建立一个session，并设置到本地线程变量中
    try {
        if(session ==null&&!session.isOpen()){
            if(sessionFactory==null){
                rbuildSessionFactory();// 建立Hibernate的SessionFactory
            }else{
                session = sessionFactory.openSession();
            }
        }
        threadLocal.set(session);
    } catch (Exception e) {
        // TODO: handle exception
    }

    return session;
}

4、内存泄漏问题

ThreadLocalMap使用ThreadLocal的弱引用做为key，若是一个ThreadLocal没有外部强引用来引用它，那么系统 GC 的时候，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value，若是当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远没法回收，形成内存泄漏。

关于GC以及引用状态：JVM垃圾回收机制

其实，ThreadLocalMap的设计中已经考虑到这种状况，也加上了一些防御措施：在ThreadLocal的get(),set(),remove()的时候都会清除线程ThreadLocalMap里全部key为null的value。

可是这些被动的预防措施并不能保证不会内存泄漏：

　　使用static的ThreadLocal，延长了ThreadLocal的生命周期，可能致使的内存泄漏。
　　分配使用了ThreadLocal又再也不调用get(),set(),remove()方法，那么就会致使内存泄漏。

内存泄漏实例分析：ThreadLocal 内存泄露的实例分析 

解决：

每次使用完ThreadLocal，都调用它的remove()方法，清除数据。

在使用线程池的状况下，没有及时清理ThreadLocal，不只是内存泄漏的问题，更严重的是可能致使业务逻辑出现问题。因此，使用ThreadLocal就跟加锁完要解锁同样，用完就清理。

 

 

参考资料 / 相关推荐

线程管理（九）使用本地线程变量

不共享有时是最好的

【死磕Java并发】—–深刻分析ThreadLocal

Java并发编程：深刻剖析ThreadLocal

ThreadLocal-面试必问深度解析

深刻分析 ThreadLocal 内存泄漏问题

ThreadLocal 内存泄露的实例分析