深入理解java.lang.ThreadLocal

什么是ThreadLocal？

ThreadLocal并非是一个线程的本地实现，它不是一个Thread，而是Threadlocalvariable(线程局部变量)。线程局部变量(ThreadLocal)就是为每一个使用该变量的线程都提供一个变量值的副本，是Java中一种较为特殊的线程绑定机制，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。

从线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收（除非存在对这些副本的其他引用）。

ThreadLocal存取的数据总是与当前线程有关的，也就是说：JVM为每一个运行的线程提供了私有的本地实例存储空间，为多线程的并发访问提供了隔离机制。

ThreadLocal类中维护一个Map，用来存储每个变量的副本，key是线程对象，value是对应线程的变量副本。ThreadLocal在spring中发挥这很大的作用例如：bean，事务管理，任务调度，AOP等模块都有身影。Spring中大部分Bean都可以声明成Singleton作用域，采用ThreadLocal进行封装，因此有状态的Bean就能够以Singleton的形式在多线程的情况进行访问。

API

ThreadLocal() 用于创建线程局部变量

T get() 返回当前线程的局部变量副本，如果是首次进去，则创建并初始化线程的变量副本

set(T value) 创建并初始化线程的变量副本

remove() 移除当前线程的变量副本

代码解析

    /**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
    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();
    }

首先通过Thread.currentThread()获取当前线程，调用getMap()获取map，map的类型是ThreadlocalMap，获取<key,value>键对值，如果不为空，返回value否则调用setInitialValue()返回一个value。看看getMap()做了哪些事情

    /**
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
            return t.threadLocals;
    }

只是单纯的调用当前线程的成员变量吗？

    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

threadLocals本质上是ThreadLocalMap，ThreadLocalMap是静态内部类

    /**
     * Variant of set() to establish initialValue. Used instead
     * of set() in case user has overridden the set() method.
     *
     * @return the initial value
     */
    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

获取map，如果map不为null就设置值，否则创建map，返回value

    /**
     * Create the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

为当前线程创建成员变量的副本

---

使用ThreadLocal实现多线程隔离案例

package cn.happy.db;

import java.util.Random;

public class ThreadLockDemo implements Runnable{

private final static ThreadLocal studentLocal = new ThreadLocal();

@Override
public void run() {
    accessStudent();
    }
}

  /**
 * 示例业务方法，用来测试
 */
public void accessStudent() {
    //获取当前线程的名字
    String currentThreadName = Thread.currentThread().getName();
    System.out.println(currentThreadName + " is running!");
    //产生一个随机数并打印
    Random random = new Random();
    int age = random.nextInt(100);
    System.out.println("thread " + currentThreadName + " set age to:" + age);
    //获取一个Student对象，并将随机数年龄插入到对象属性中
    Student student = getStudent();
    student.setAge(age);
    System.out.println("thread " + currentThreadName + " first read age is:" + student.getAge());
    try {
        Thread.sleep(500);
    }
    catch (InterruptedException ex) {
        ex.printStackTrace();
    }
    System.out.println("thread " + currentThreadName + " second read age is:" + student.getAge());
}

protected Student getStudent() {
    //获取本地线程变量并强制转换为Student类型
    Student student = (Student) studentLocal.get();
    //线程首次执行此方法的时候，studentLocal.get()肯定为null
    if (student == null) {
        //创建一个Student对象，并保存到本地线程变量studentLocal中
        student = new Student();
        studentLocal.set(student);
    }
    return student;
}

public static void main(String[] args) {
    
    ThreadLockDemo td = new ThreadLockDemo();
    Thread t1 = new Thread(td, "a");
    Thread t2 = new Thread(td, "b");
    t1.start();
    t2.start();
}

总结

Threadlocal主要用于解决多线程的情况下数据因并发导致不一样，Threadlocal为每个线程访问的数据提供一个副本，通过访问副本来运行业务，这样的结果是耗费了内存，但大大减少了线程同步所带来性能消耗，也减少了线程并发控制的复杂度。
Threadlocal与Sychronized本质上有很大的区别，Threadlocal通过副本的形式使每一个线程在同一时刻访问到不同的变量，采用“以空间换时间”的方式，而Syschronized是用锁的机制，使同一个时间内只有一个线程可以访问变量，采用“以时间换空间”的形式。Syschronized用于线程间的数据共享Threadlocal用于线程间的数据隔离。它不支持数据的原子性，只能是Object类型