ThreadLocal，很多地方叫做线程本地变量，也有些地方叫做线程本地存储。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。

假如每个线程中都有一个connect变量，各个线程之间对connect变量的访问实际上是没有依赖关系的，即一个线程不需要关心其他线程是否对这个connect进行了修改的。ThreadLocal在每个线程中对该变量会创建一个副本，即每个线程内部都会有一个该变量，且在线程内部任何地方都可以使用，线程之间互不影响，这样一来就不存在线程安全问题，也不会严重影响程序执行性能。

　　但是要注意，虽然ThreadLocal能够解决上面说的问题，但是由于在每个线程中都创建了副本，所以要考虑它对资源的消耗，比如内存的占用会比不使用ThreadLocal要大。

第一句是取得当前线程，然后通过getMap(t)方法获取到一个map，map的类型为ThreadLocalMap。然后接着下面获取到<key,value>键值对，注意这里获取键值对传进去的是  this，而不是当前线程t。

如果获取成功，则返回value值。

如果map为空，则调用setInitialValue方法返回value。

ThreadLocalMap getMap(Thread t){

    return t.threadLocals;

}

在getMap中，是调用当期线程t，返回当前线程t中的一个成员变量threadLocals。

成员变量threadLocals是什么：

ThreadLocal.ThreadLocalMap threadLocals = null;

实际上就是一个ThreadLocalMap，这个类型是ThreadLocal类的一个内部类

ThreadLocalMap的Entry继承了WeakReference，并且使用ThreadLocal作为键值。

setInitialValue方法的具体实现：

就是如果map不为空，就设置键值对，为空，再创建Map，看一下createMap的实现：

ThreadLocal是如何为每个线程创建变量的副本的：

　　首先，在每个线程Thread内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，这个threadLocals就是用来存储实际的变量副本的，键值为当前ThreadLocal变量，value为变量副本（即T类型的变量）。

　　初始时，在Thread里面，threadLocals为空，当通过ThreadLocal变量调用get()方法或者set()方法，就会对Thread类中的threadLocals进行初始化，并且以当前ThreadLocal变量为键值，以ThreadLocal要保存的副本变量为value，存到threadLocals。

　　然后在当前线程里面，如果要使用副本变量，就可以通过get方法在threadLocals里面查找。

　　1）实际的通过ThreadLocal创建的副本是存储在每个线程自己的threadLocals中的；

　　2）为何threadLocals的类型ThreadLocalMap的键值为ThreadLocal对象，因为每个线程中可有多个threadLocal变量，就像上面代码中的longLocal和stringLocal；

　　3）在进行get之前，必须先set，否则会报空指针异常；

如果想在get之前不需要调用set就能正常访问的话，必须重写initialValue()方法。

如果没有先set的话，即在map中查找不到对应的存储，则会通过调用setInitialValue方法返回i，而在setInitialValue方法中，有一个语句是T value = initialValue()， 而默认情况下，initialValue方法返回的是null。

---------------------

作者：wespten

来源：CSDN

原文：https://blog.csdn.net/qq_35029061/article/details/86495625

版权声明：本文为博主原创文章，转载请附上博文链接！

ThreadLocal的内部方法

1.protected T initialValue()

①该方法实现只返回 null，并且修饰符为protected，很明显，如果用户想返回初始值不为null，则需要定义线程变量时重写该方法；

1    /**

2      * @return the initial value for this thread-local

3      */

4    protected T initialValue() {

5        return null;

6    }

复制代码

1 //定义ThreadLocal时重写initialValue方法，返回用户想要的值

2 private static ThreadLocal t = new ThreadLocal() {

3    public Object initialValue() {

4        A a = new A();

5        return a;

6    }

7 };

复制代码

②返回此线程局部变量的当前线程的初始值。最多在每次访问线程来获得每个线程局部变量时调用此方法一次，即线程第一次使用 get() 方法访问变量的时候。如果线程先于 get 方法调用 set(T) 方法，则不会在线程中再调用 initialValue 方法。

复制代码

1    /**

2      * Returns the value in the current thread's copy of this

3      * thread-local variable.  If the variable has no value for the

4      * current thread, it is first initialized to the value returned

5      * by an invocation of the {@link #initialValue} method.

6      *

7      * @return the current thread's value of this thread-local

8      */

9    public T get() {

10        Thread t = Thread.currentThread();

11        ThreadLocalMap map = getMap(t);

12        if (map != null) {

13            ThreadLocalMap.Entry e = map.getEntry(this);

14            if (e != null)

15                return (T)e.value;

16        }

17        return setInitialValue();

18    }   

复制代码

2.public T get()

①在1中已经提到，该方法返回当前线程变量副本。如果这是线程第一次调用该方法，则创建并初始化此副本。

3.public void set(T value)

①ThreadLocal中有个内部静态类ThreadLocalMap，用来存放当前线程变量副本中的值，键为当前线程变量对象，值为用户设的值；

②当使用ThreadLocal存值时，首先是获取到当前线程对象，然后获取到当前线程本地变量Map，最后将当前使用的ThreadLocal和传入的值放到Map中，也就是说ThreadLocalMap中存的值是[ThreadLocal对象, 存放的值]，这样做的好处是，每个线程都对应一个本地变量的Map，所以一个线程可以存在多个线程本地变量（即不同的ThreadLocal，就如1中所说，可以重写initialValue，返回不同类型的子类）。

复制代码

1    /**

2      * Sets the current thread's copy of this thread-local variable

3      * to the specified value.  Most subclasses will have no need to

4      * override this method, relying solely on the {@link #initialValue}

5      * method to set the values of thread-locals.

6      *

7      * @param value the value to be stored in the current thread's copy of

8      *        this thread-local.

9      */

10    public void set(T value) {

11        Thread t = Thread.currentThread();

12        ThreadLocalMap map = getMap(t);

13        if (map != null)

14            map.set(this, value);

15        else

16            createMap(t, value);

17    }

复制代码

4.public void remove()

①移除此线程中某个ThreadLocal的值，目的是为了减少内存的占用。如果再次访问此线程局部变量，那么在默认情况下它将拥有其initialValue；

②只有从jdk1.5开始才有该方法；

③当线程结束后，对应该线程的局部变量将自动被垃圾回收，因此显式调用remove清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。

复制代码

1      /**

2      * Removes the current thread's value for this thread-local

3      * variable.  If this thread-local variable is subsequently

4      * {@linkplain #get read} by the current thread, its value will be

5      * reinitialized by invoking its {@link #initialValue} method,

6      * unless its value is {@linkplain #set set} by the current thread

7      * in the interim.  This may result in multiple invocations of the

8      * <tt>initialValue</tt> method in the current thread.

9      *

10      * @since 1.5

11      */

12      public void remove() {

13          ThreadLocalMap m = getMap(Thread.currentThread());

14          if (m != null)

15              m.remove(this);

16      }

复制代码

三、ThreadLocal和同步机制synchonzied相比

1.synchonzied同步机制是为了实现同步多线程对相同资源的并发访问控制。同步的主要目的是保证多线程间的数据共享。同步会带来巨大的性能开销，所以同步操作应该是细粒度的（对象中的不同元素使用不同的锁，而不是整个对象一个锁）。如果同步使用得当，带来的性能开销是微不足道的。使用同步真正的风险是复杂性和可能破坏资源安全,而不是性能。

2.ThreadLocal以空间换取时间，提供了一种非常简便的多线程实现方式。因为多个线程并发访问无需进行等待，所以使用ThreadLocal会获得更大的性能。

3.ThreadLocal中的对象，通常都是比较小的对象。另外使用ThreadLocal不能使用原子类型，只能使用Object类型。ThreadLocal的使用比synchronized要简单得多。

4.synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反，它用于在多个线程间通信时能够获得数据共享。

5.Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。