ThreadLocal的理解

ThreadLocal（线程本地变量）

ThreadLocal不是用来解决共享对象访问的，而主要是提供了保持对象的方法和避免参数传递的方便的对象访问方式。在每个线程内部都有对目标资源的“副本”。每个线程对自己内部的资源进行修改，不影响别的线程中该资源的状态。

1. 每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保存到其中，各管各的，线程可以正确访问到自己的对象。

2. 将一个共用的ThreadLocal静态实例作为key，将不同对象的引用保存到不同线程的ThreadLocalMap中，然后在线程执行的各处通过这个静态ThreadLocal实例的get（）方法取得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。

我们现在假设有一个数据库连接管理类，有一个静态的数据库连接对象，其中有两个方法，一个是获取数据库连接对象，一个是关闭数据库连接对象，我们如果对获取数据库连接对象和关闭数据库连接对象没有进行同步，在多线程下就会有问题，如一个线程正在使用获取到的数据库连接进行操作，而另一个线程此时进行了关闭数据库连接的操作，还有可能在获取数据库连接中多次创建数据库连接，而在关闭数据库连接中多次进行关闭。因此就需要在在获取和关闭数据库连接及使用数据库连接的地方进行同步的地方进行同步，这样的话，当一个线程在使用数据库连接进行操作的时候，其他的线程只能等待，这样的话，效率就大大的降低了。

此时我们发现，每个线程的数据库连接之间没有依赖关系，即每个线程不需要关心其他的线程对数据库连接进行了怎样的修改，这时我们也可能想到写一个方法，在每个线程中调用这个方法创建数据库连接对象，但这样就会出现大量的参数传递。

所以我们就可以考虑使用ThreadLocal，因为ThreadLocal在每个线程中对该变量会创建一个副本（重新创建），即每个线程中都会有一个该变量，且在线程内部的任何地方都可以使用，线程之间对该变量的使用互不影响，这样一来就不会存在线程安全问题，自然也就不会影响程序的性能。但是使用ThreadLocal由于在每个线程中创建了对象的副本，所以眼考虑对资源的消耗，如内存占用会比不使用ThreadLocal要大（属于空间换时间，而是用同步属于时间换空间）。

public class Test {	
	
	private static ThreadLocal<Student> stu = new ThreadLocal<Student>();
	private static ThreadLocal<String> name = new ThreadLocal<String>();
	private static AtomicInteger a = new AtomicInteger(1);
	
	public static void main(String[] args) {
		
		for(int i=0;i<4;i++){
			new Thread(new Runnable(){
				@Override
				public void run() {					
					if(stu.get() == null){
						stu.set(new Student(a.incrementAndGet()));
					}
					if(name.get() == null){
						name.set(Thread.currentThread().getName());
					}
					System.out.println(stu.get().age+" "+name.get());
				}
			}).start();
		}	
	}	
}

ThreadLocal源码解析

先看一下ThreadLocal提供了的方法：

我们先看一下ThreadLocal是如何为每个线程创建一个变量的副本的。

先看get（）方法

 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）取得一个map，而这个map类型为ThreadLocalMap，然后当map不为null时，获取到<key,value>键值对，这里获取键值对传进去的是this，即当前的ThreadLocal对象。如果获取成功，然会获取value值。

我们看一下getMap方法：

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

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

 ThreadLocal.ThreadLocalMap threadLocals = null;

实际上是一个ThreadLocalMap，这个类是ThreadLocal类的一个内部类。我们先看一下其中的键值对类型Entry。

static class ThreadLocalMap {

        /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

可以看到Entry继承了WeakReference，并且使用ThreadLocal作为键值。

我们看一下setInitiaValue方法的实现。

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

  protected T initialValue() {
        return null;
    }

如果map不为空，就设置键值对；为空，则创建一个map。

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

但这里，ThreadLocal如何为每个线程创建变量副本，已经清晰了：

首先，每个线程内部都有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，而这个threadLocals则是用来存储实际的变量的副本的，当前的ThreadLocal变量为key，变量副本为value。

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

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

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

2. 这里使用threadLocals的类型是map（ThreadLocalMap），是因为每个线程中可能有多个ThreadLocal变量，如上面我举得例子代码。

3. 在进行get之前，要先进行set，否则会报空指针异常（setinitiaValue方法中调用initiaValue（）方法返回的是null）。（具体情况具体分析）。

如果想在get之前不set而能正常访问，则需要重写initiaValue（）方法。

我们看一下ThreadLocalMap的初始化。

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY]; 
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY); //阈值
        }

private static final int INITIAL_CAPACITY = 16;

private final int threadLocalHashCode = nextHashCode();

 private final int threadLocalHashCode = nextHashCode();

private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

 private static AtomicInteger nextHashCode =  new AtomicInteger();

private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }

可以看到先初始化map为16，然后通过hash得到此entry的下标i，可以看到扩容的阈值为原大小*2/3。即当为entry数量为10时扩容。

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;

            while (e != null) {
                ThreadLocal<?> k = e.get();
                if (k == key)
                    return e;
                if (k == null)
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0); //可以看到当发生hash冲突时m，采用的是线性探测法。
        }

扩容时。

 private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
            int newLen = oldLen * 2; //扩容为原来的2倍
            Entry[] newTab = new Entry[newLen];
            int count = 0;

            for (int j = 0; j < oldLen; ++j) {
                Entry e = oldTab[j];
                if (e != null) {
                    ThreadLocal<?> k = e.get();
                    if (k == null) {
                        e.value = null; // Help the GC
                    } else {
                        int h = k.threadLocalHashCode & (newLen - 1);  //重新hash后还是为原来的位置
                        while (newTab[h] != null)
                            h = nextIndex(h, newLen); //发生hash冲突为先行探测法
                        newTab[h] = e;
                        count++;
                    }
                }
            }

            setThreshold(newLen);
            size = count;
            table = newTab;
        }

所以我们总结一下，ThreadLocalMap的执行流程：先初始化为16，阈值为map 大小*2/3，即原来的2/3，扩容为原来的2倍，发生hash冲突解决办法为线性探测法，扩容后还是原来的位置。

ThreadLocal的应用场景

ThreadLocal主要用于数据库连接，Session管理等（各个线程之间的变量副本相互独立）（多线程多实例）。

使用ThreadLocal关于内存泄漏的问题

ThreadLocalMap中的Entry中的key使用的是弱引用（只能活到下一次gc之前，gc时所有的只被弱引用关联的对象都会被回收），当没有任何强引用指向当前的ThreadLocal变量，垃圾回收器就会在下一次垃圾回收时将该ThreadLoca变量回收，此时在Entry中只会回收该ThreadLocal关联的key，而不会回收value，因为存在当前线程的ThreadLocalMap中Entry对此value的强引用，此时就会发生内存泄漏。

因为ThreadLocalMap是线程私有的，所以当线程对象被gc时，其所有的ThreadLocalMap也就被gc了，自然依附于它的Entry也就被gc了，也就不存在内存泄漏了。

我们其实可以发现发生内存泄漏和key使用弱引用没有关系，使用强引用也会发生内存泄漏。

这里为什么要使用弱引用而不使用强引用？

这应该是为了当外界（ThreadLocalMap外面）不再有ThreadLocal强引用的时候，可以确保在下一次gc时所有与该ThreadLocal相关联的引用（这里指ThreadLocalMap中的对该ThreadLocal的弱引用）都能被gc（自己理解的，可能有错）。

为什么JDK建议ThreadLocal使用private static修饰？

为了延长ThreadLocal的生命周期，方便在线程的任何地方调用。

参考：http://www.importnew.com/22039.html

参考：http://www.cnblogs.com/dolphin0520/p/3920407.html