作为从JDK1.2就引入的特性，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变量（简直废话）。这些变量不同于寻常变量，它们为每个线程独立分配一个变量的拷贝。ThreadLocal实例一般定义为private static的（下面会详细解释），用于将一个线程和一个状态关联，例如一个用户id（user ID）或者事务id（Transaction ID）（此处为ThreadLocal的使用场景）

翻译的比较鸡肋，主要的含义就是说，通过它，解决之前线程之间共享变量的问题，暂时可先这么理解吧。

使用简介

类似关键字synchronized，ThreadLocal也是用于线程之间共享变量问题的处理，不同的是，synchronized会锁住变量，当一个线程使用的时候，其他线程只能等待；而ThreadLocal是给每个线程分配一个拷贝，这样每个线程就独享自己的拷贝，不存在冲突问题。synchronized是时间换空间，ThreadLocal是空间换时间。
看下使用方法吧

public class ThreadLocalTest {

    private static ThreadLocal<Integer> threadlocal = new ThreadLocal<Integer>() {
        @Override
        protected Integer initialValue() {
            return 0;
        }
    };

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new ThreadA(i).start();
        }

    }

    public static class ThreadA extends Thread {

        private int index;

        public ThreadA(int index) {
            super();
            this.index = index;
        }

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println("Thread " + index + " print " + threadlocal.get());
                threadlocal.set(threadlocal.get() + 1);
            }

        }

    }
}

输出如下

Thread 0 print 0
Thread 2 print 0
Thread 2 print 1
Thread 2 print 2
Thread 2 print 3
Thread 2 print 4
Thread 1 print 0
Thread 1 print 1
Thread 1 print 2
Thread 1 print 3
Thread 1 print 4
Thread 0 print 1
Thread 0 print 2
Thread 0 print 3
Thread 0 print 4

当然上面只是一个简单的实例，在正常使用场景中，我们里面的泛型可以使一些更复杂的类型，例如SimpleDateFormatter等

原理剖析

关注ThreadLocal暴露出来的几个方法

    protected T initialValue() {
        return null;
    }
    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();
    }
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

来来来，下面一起看下上述几个方法的作用

protected T initialValue()
这是一个子类可继承修改的方法，作用如其名所示，就是初始化值使用

public T get()
返回当前线程对应的“thread-local”值，即获取当前线程“存储”在对应的ThreadLocal中的数据。
我们稍微看一下这个方法，逻辑比较简单

1. 获取当前线程
2. 从当前线程中获取ThreadLocalMap类型的属性，通过查看getMap方法

    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

我们发现，这个ThreadLocalMap其实就是Thread中的一个属性，也就是说实际线程要获取的值还是存储在Thread中。
从ThreadLocalMap.Entry e = map.getEntry(this)中，我们可以看到，在线程中的ThreadLocalMap中，其key为ThreadLocal本身，value为需要获取的对象

3. 若ThreadLocalMap.Entry有值，则返回对应的值，否则返回初始对象，即在initialValue中设置的值。

看明白了public T get()，那么public void set(T value)和public void remove()就很好理解了。

内存问题

我们查看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的key为一个弱引用，即当所有指向该key的强引用均消失的时候，即使有弱引用指向该对象，GC触发的时候依然会回收这个对象。

image

真的如此吗？我们翻阅下ThreadLocalMap的源码，发现有如下代码

        private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;

                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

看下关键代码段

               if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } 

上述代码，会在key为null的时候，回收对应的value，即在这里做了一些回收的动作，而这个expungeStaleEntry方法，当我们调用ThreadLocal的get,set,remove方法的时候会触发，但是不会自动触发，指导线程自动结束，所以，最好的实践场景就是，每次所用完之后显示调用remove方法来显示释放。

使用场景

经过上面的描述，大家可以看到，ThreadLocal用在多线程的场景，将一些平时非线程安全的对象（例如SimpleDateFormat），分装一个线程安全的方法来使用，同时，其与synchronized的区别在于，ThreadLocal维护多分拷贝，以空间来换取时间上的提升。
有人说，如果你为每个线程维护一个自己的变量拷贝，那还不如每个线程自己来维护这个变量。是的，说的没错，我们也可以自己在线程中自己来声明、使用变量。但是，ThreadLocal相比较与本地变量，有如下的优势

1. 减少变量的传递。
   当我们的变量需要当成一个参数来传递给内部的方法的时候，使用ThreadLocal，可以直接使用，不用传递参数。
2. 减少重复代码的编写
   若我们在多个线程中都要使用类似的变量，使用ThreadLocal的时候，可以进行一处声明，多处使用，减少重复代码。

一个经典的使用场景就是web请求的处理，在web容器中，当来了一个请求的时候，容器会使用单独的线程处理每个请求的时候，这个时候我们可以使用ThreadLocal来记录线程中的一些状态，在线程执行过程中，可直接通过get方法就可以直接获取。

以上为自己的一些理解，若有不正确的地方，请大家指正！