ThreadLocal类的详情

ThreadLocal，从表面上读英文的意思为线程本地变量，这样也许更好了解了，就是每个线程自己独有的，不与其它线程共享的变量。

常用的就这几个，俩内部类，四个方法。

• get()方法是用来获取ThreadLocal在当前线程中保存的变量副本。
• set()用来设置当前线程中变量的副本。
• remove()用来移除当前线程中变量的副本。
• initialValue()是一个protected方法，一般是用来在使用时进行重写的，它是一个推迟加载方法。ThreadLocal没有被当前线程赋值时或者当前线程刚调用remove方法后调用get方法，返回此方法值。

举例：

定义两个不同任务的线程，分别向各自的本地变量中存放值，见证两个线程本地变量中的内容是互不干扰的。

public class MyThreadLocal {    // 采用匿名内部类的方式来重写initialValue方法    private static final ThreadLocal<Object> threadLocal = new ThreadLocal<Object>() {        /**         * ThreadLocal没有被当前线程赋值时或者当前线程刚调用remove方法后调用get方法，返回此方法值         */        @Override        protected Object initialValue() {            System.out.println("调用get方法时，当前线程共享变量没有设置，调用initialValue获取默认值！");            return null;        }    };    // 操纵int类型的任务线程    public static class MyIntegerTask implements Runnable {        private String name;        MyIntegerTask(String name) {            this.name = name;        }        public void run() {            for (int i = 0; i < 5; i++) {                // ThreadLocal.get方法获取线程变量                if (null == MyThreadLocal.threadLocal.get()) {                    // ThreadLocal.et方法设置线程变量                    MyThreadLocal.threadLocal.set(0);                    System.out.println("线程" + name + ": 0");                } else {                    int num = (Integer) MyThreadLocal.threadLocal.get();                    MyThreadLocal.threadLocal.set(num + 1);                    System.out.println("线程" + name + ": " + MyThreadLocal.threadLocal.get());                    if (i == 3) {                        MyThreadLocal.threadLocal.remove();                    }                }                try {                    Thread.sleep(1000);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }    }    // 操纵string类型的任务线程    public static class MyStringTask implements Runnable {        private String name;        MyStringTask(String name) {            this.name = name;        }        public void run() {            for (int i = 0; i < 5; i++) {                if (null == MyThreadLocal.threadLocal.get()) {                    MyThreadLocal.threadLocal.set("a");                    System.out.println("线程" + name + ": a");                } else {                    String str = (String) MyThreadLocal.threadLocal.get();                    MyThreadLocal.threadLocal.set(str + "a");                    System.out.println("线程" + name + ": " + MyThreadLocal.threadLocal.get());                }                try {                    Thread.sleep(800);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }    }    public static void main(String[] args) {        new Thread(new MyIntegerTask("IntegerTask1")).start();        new Thread(new MyStringTask("StringTask1")).start();    }}

运行结果：

调用get方法时，当前线程共享变量没有设置，调用initialValue获取默认值！线程IntegerTask1: 0调用get方法时，当前线程共享变量没有设置，调用initialValue获取默认值！线程StringTask1: a线程StringTask1: aa线程IntegerTask1: 1线程StringTask1: aaa线程IntegerTask1: 2线程StringTask1: aaaa线程IntegerTask1: 3线程StringTask1: aaaaa调用get方法时，当前线程共享变量没有设置，调用initialValue获取默认值！线程IntegerTask1: 0

get方法分析

涉及到的源码：

get();方法：供ThreadLocal对象来调用

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();    }

getMap();方法：这个方法是返回当前线程t中的一个成员变量threadLocals，它是Thread类中的一个内部类

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

看一下ThreadLocalMap的实现：可以看到ThreadLocalMap的Entry继承了WeakReference(弱引用类)，并且使用ThreadLocal作为键值。

static class ThreadLocalMap {        static class Entry extends WeakReference<ThreadLocal<?>> {            /** The value associated with this ThreadLocal. */            Object value;            Entry(ThreadLocal<?> k, Object v) {                super(k);                value = v;            }        }        。。。。。。。。。    }

getEntry();方法

private Entry getEntry(ThreadLocal<?> key) {            int i = key.threadLocalHashCode & (table.length - 1);            Entry e = table[i];            if (e != null && e.get() == key)                return e;            else                return getEntryAfterMiss(key, i, e);}

setInitialValue();方法：就是假如map不为空，就设置键值对，为空，再创立Map

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;    }

createMap();方法：假如map为空，就初始化ThreadLocalMap，哈哈明白了~

void createMap(Thread t, T firstValue) {        t.threadLocals = new ThreadLocalMap(this, firstValue);}

不难看出，get()方法，首先获取当前的线程，而后通过getMap(t)方法获取到一个map，map的类型为ThreadLocalMap。而后接着下面获取到<key,value>键值对，假如获取成功，则返回value值，假如map为空，则调用setInitialValue方法返回value。

测试完上面的例子，看完get方法的实现，应该明白ThreadLocal是怎样个原理了，大致如下(就是这样的)：首先，在每个线程Thread内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，这个threadLocals就是用来存储实际的变量的，键值为当前ThreadLocal变量，value为变量(比方说上面定义的String变量或者者Integer变量)。初始时，在Thread里面，threadLocals为空，当通过ThreadLocal变量调用get()方法或者者set()方法，就会对Thread类中的threadLocals进行初始化，并且以当前ThreadLocal变量为键值，以ThreadLocal要保存的变量为value，存到threadLocals。假如要使用副本变量，即可以通过get方法在threadLocals里面查找。

这种存储结构的好处：

1. 线程死去的时候，线程共享变量ThreadLocalMap则销毁。
2. ThreadLocalMap<ThreadLocal,Object>键值对数量为ThreadLocal的数量，一般来说ThreadLocal数量很少，相比在ThreadLocal中用Map<Thread, Object>键值对存储线程共享变量（Thread数量一般来说比ThreadLocal数量多），性能提高很多。

ThreadLocal的应用场景

最常见的ThreadLocal使用场景为 用来处理 数据库连接、Session管理等。

比方以下，代码来自：https://www.iteye.com/topic/103804

private static final ThreadLocal threadSession = new ThreadLocal();    public static Session getSession() throws InfrastructureException {        Session s = (Session) threadSession.get();        try {            if (s == null) {                s = getSessionFactory().openSession();                threadSession.set(s);            }        } catch (HibernateException ex) {            throw new InfrastructureException(ex);        }        return s;}

关于ThreadLocal导致的内存泄漏问题，和处理办法

1. 每个thread中都存在一个map，map的类型是ThreadLocal.ThreadLocalMap。 Map中的key为一个threadlocal实例。 这个Map确实使用了弱引用，不过弱引用只是针对key。每个key都弱引用指向threadlocal，当把threadlocal实例置为null以后,没有任何强引用指向threadlocal实例，所以threadlocal将会被gc回收。 但是value却不能回收，由于存在一条从currentThread连接过来的强引用。只有当前thread结束以后，currentThread才不会存在栈中，强引用断开，CurrentThread，Map，value将一律被GC回收。

2. 所以得出一个结论就是只需这个线程对象被gc回收，就不会出现内存泄露，但在threadLocal设为null和线程结束这段时间不会被回收的，就发生了我们认为的内存泄露。其实这是一个对概念了解的不一致，也没什么好争论的。最要命的是线程对象不被回收的情况，这就发生了真正意义上的内存泄露。比方使用线程池的时候，线程结束是不会销毁的，会再次使用的。即可能出现内存泄露。

3. Java为了最小化减少内存泄露的可能性和影响，在ThreadLocal的get,set的时候都会清理线程Map里所有key为null的value。所以最怕的情况就是，threadLocal对象设null了，开始发生“内存泄露”，而后使用线程池，这个线程结束，线程放回线程池中不销毁，这个线程一直不被使用，或者者分配使用了又不再调用get,set方法，那么这个期间就会发生真正的内存泄露。

一般有两种方法：

1. 使用完线程共享变量后，显示调用ThreadLocalMap.remove方法清理线程共享变量
2. JDK建议ThreadLocal定义为private static，这样ThreadLocal的弱引用问题则不存在了。