ThreadLocal

ThreadLocal：线程本地变量，其通过在每一个线程中为变量存储副本的方式，解决变量的多线程访问的问题。与Synchroniezd等加锁方式不同，其是通过以空间换时间的方式。
ThreadLocal的方法主要为一下四个：

public T get() { }
public void set(T value) { }
public void remove() { }
protected T initialValue() { }

一个典型的ThreadLocal用法：

public class ThreadOtherTest implements Runnable{

    public ThreadLocal<String> getLocal() {
        return local;
    }

    public void setLocal(ThreadLocal<String> local) {
        this.local = local;
    }

    private ThreadLocal<String>local;

    /* (non-Javadoc)
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
        // TODO Auto-generated method stub
        local.set(Thread.currentThread().toString());
        System.out.println(local.get());
    }

}

public class ThreadLocalTest3 {

    private ThreadLocal<String>strThreadLocal=new ThreadLocal<>();

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadLocalTest3 test3=new ThreadLocalTest3();
        test3.strThreadLocal.set(Thread.currentThread().getName().toString());
        System.out.println(test3.strThreadLocal.get());

        Thread thread=new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                test3.strThreadLocal.set(Thread.currentThread().getName().toString());
                System.out.println(test3.strThreadLocal.get());
            }
        });
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        ThreadOtherTest otherThread=new ThreadOtherTest();
        otherThread.setLocal(test3.strThreadLocal);
        Thread thread2=new Thread(otherThread);
        thread2.start();
        try {
            thread2.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println(test3.strThreadLocal.get());

    }


}

运行结果:

main
Thread-0
Thread[Thread-1,5,main]
main

结果说明，threadLocal类型的变量，在每个线程中的值都是不一样而且互相不影响。

原理分析：

通过上面的示意图，可以看出，在每个Thread内部，都会维护一个ThreadLocalMap的容器变量，用于存储各类ThreadLocal键值对。
下面看看threadLocal的get方法源码

    public T get() {
        Thread t = Thread.currentThread();  //获取所在的线程
        ThreadLocalMap map = getMap(t);     //得到线程内部的ThreadLocalMap 
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);  //在ThreadLocalMap 中根据ThreadLocal变量获得线程本地的变量值。
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

然后看看get方法的源码

    public void set(T value) {
        Thread t = Thread.currentThread();  //获取本地线程
        ThreadLocalMap map = getMap(t);   //获得线程的ThreadLocalMap 
        if (map != null)
            map.set(this, value);  //以（ThreadLocal变量，值）形式存进去ThreadLocalMap 
        else
            createMap(t, value);
    }

ThreadLocal为什么会内存泄漏

摘自http://www.importnew.com/22039.html
ThreadLocal为什么会内存泄漏

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

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

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

使用static的ThreadLocal，延长了ThreadLocal的生命周期，可能导致的内存泄漏（参考ThreadLocal 内存泄露的实例分析）。
分配使用了ThreadLocal又不再调用get(),set(),remove()方法，那么就会导致内存泄漏。
为什么使用弱引用

从表面上看内存泄漏的根源在于使用了弱引用。网上的文章大多着重分析ThreadLocal使用了弱引用会导致内存泄漏，但是另一个问题也同样值得思考：为什么使用弱引用而不是强引用？

我们先来看看官方文档的说法：

To help deal with very large and long-lived usages, the hash table entries use WeakReferences for keys.
为了应对非常大和长时间的用途，哈希表使用弱引用的 key。

下面我们分两种情况讨论：

key 使用强引用：引用的ThreadLocal的对象被回收了，但是ThreadLocalMap还持有ThreadLocal的强引用，如果没有手动删除，ThreadLocal不会被回收，导致Entry内存泄漏。
key 使用弱引用：引用的ThreadLocal的对象被回收了，由于ThreadLocalMap持有ThreadLocal的弱引用，即使没有手动删除，ThreadLocal也会被回收。value在下一次ThreadLocalMap调用set,get，remove的时候会被清除。
比较两种情况，我们可以发现：由于ThreadLocalMap的生命周期跟Thread一样长，如果都没有手动删除对应key，都会导致内存泄漏，但是使用弱引用可以多一层保障：弱引用ThreadLocal不会内存泄漏，对应的value在下一次ThreadLocalMap调用set,get,remove的时候会被清除。

因此，ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄漏，而不是因为弱引用。

ThreadLocal 最佳实践

综合上面的分析，我们可以理解ThreadLocal内存泄漏的前因后果，那么怎么避免内存泄漏呢？

每次使用完ThreadLocal，都调用它的remove()方法，清除数据。
在使用线程池的情况下，没有及时清理ThreadLocal，不仅是内存泄漏的问题，更严重的是可能导致业务逻辑出现问题。所以，使用ThreadLocal就跟加锁完要解锁一样，用完就清理。