深入分析ThreadLocal

ThreadLocal是什么

首先我们要明白一点，线程同步主要是为了完成线程间数据共享和同步，保持数据的完整性。而ThreadLocal正如他的名字一样是线程的本地变量，也就是线程所私有的。因此他和线程同步无关，（因为不存在线程之间共享变量的问题，就不需要使用同步机制）。ThreadLocal虽然提供了一种解决多线程环境下成员变量的问题，但是它并不是解决多线程共享变量的问题。那么ThreadLocal到底是什么呢？

官方文档是这样介绍它的：

This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its {@code get} or {@code set} method) has its own, independently initialized copy of the variable. {@code ThreadLocal} instances are typically private static fields in classes that wish to associate state with a thread (e.g.,a user ID or Transaction ID).

中文翻译

该类提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其get 或 set方法）的每个线程都有自己的局部变量，它独立于变量的初始化副本。ThreadLocal实例通常是类中的 private static 字段，它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联。正如这句话所说，spring 中的事务就使用了ThreadLocal来保证同一个线程中的所有操作使用的是同一个数据库连接。

所以ThreadLocal与线程同步机制不同，线程同步机制是多个线程共享同一个变量，而ThreadLocal是为每一个线程创建一个单独的变量副本，故而每个线程都可以独立地改变自己所拥有的变量副本，而不会影响其他线程所对应的副本。可以说ThreadLocal为多线程环境下变量问题提供了另外一种解决思路。

如何使用ThreadLocal

简单案例

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-0 seqCount :1
Thread-2 seqCount :1
Thread-3 seqCount :1
Thread-1 seqCount :2
Thread-0 seqCount :2
Thread-2 seqCount :2
Thread-3 seqCount :2
Thread-1 seqCount :3
Thread-0 seqCount :3
Thread-2 seqCount :3
Thread-3 seqCount :3

从运行结果可以看出，ThreadLocal确实是可以达到线程隔离机制，确保变量的安全性。

不过这里要注意一个问题，不要使用对象的引用来设置ThreadLocal的初始值，这样会导致线程共享此对象

就像下面这样写

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

class A{
   // ....
}

具体过程请参考：对ThreadLocal实现原理的一点思考

总结一般使用ThreadLocal的方式是：

设置ThreadLocal对象为静态内部私有属性
使用initalValue方法进行初始化值的时候，不要使用引用对象，这样会造成线程间共享此对象，从而达不到线程私有变量的的效果。

具体代码如下

private statis ThreadLocal<T> objectName = new  ThreadLocal(){
   private T initialValue() {
   		//下面写法肯定有问题，主要是告诉你要声明一个对
   		//象，而不是返回对象的引用
       return new T() ;
   }
}

ThreadLocal源码解析

ThreadLocal定义了四个方法：

get()：返回当前线程对应的ThreadLocal中的值。
initialValue()：用于初始化当前线程对应的ThreadLocal的“初始值”。
remove()：删除当前线程对应的ThreadLocal值。
set(T value)：设置当前线程对应的ThreadLocal中的值。

除了这四个方法，ThreadLocal内部还有一个静态内部类ThreadLocalMap，该内部类才是实现线程隔离机制的关键，get()、set()、remove()都是基于该内部类操作。ThreadLocalMap提供了一种用键值对方式存储每一个线程的变量副本的方法，key为当前ThreadLocal对象，value则是对应线程的变量副本。

对于ThreadLocal需要注意的有两点：

ThreadLocal实例本身是不存储值，它只是提供了一个在当前线程中找到副本值得key。
是ThreadLocal包含在Thread中，而不是Thread包含在ThreadLocal中，有些小伙伴会弄错他们的关系。

下图是Thread、ThreadLocal、ThreadLocalMap的关系

ThreadLocal虽然解决了这个多线程变量的复杂问题，但是它的源码实现却是比较简单的。ThreadLocalMap是实现ThreadLocal的关键，我们先从它入手。

1. ThreadLocal是什么
1. 1.1. 如何使用ThreadLocal
2. ThreadLocal源码解析