ThreadLocal原理

一、ThreadLocal概念

ThreadLocal 是线程的局部变量， 是每一个线程所单独持有的，其他线程不能对其进行访问。

当使用ThreadLocal维护变量的时候 为每一个使用该变量的线程提供一个独立的变量副本，即每个线程内部都会有一个该变量，这样同时多个线程访问该变量并不会彼此相互影响，因此他们使用的都是自己从内存中拷贝过来的变量的副本， 这样就不存在线程安全问题，也不会影响程序的执行性能。

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

二、与线程同步机制相比较

ThreadLocal和线程同步机制相比有什么优势呢？ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。

　　在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的，使用同步机制要求程序慎密地分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写难度相对较大。

　　而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进ThreadLocal。

　　由于ThreadLocal中可以持有任何类型的对象，低版本JDK所提供的get()返回的是Object对象，需要强制类型转换。但JDK 5.0新的ThreadLocal<T>版本通过泛型很好的解决了这个问题，在一定程度地简化ThreadLocal的使用。

　　概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

三、ThreadLocal<T>的具体体现

先了解一下ThreadLocal类提供的几个方法：

public T get() { } // 用来获取ThreadLocal在当前线程中保存的变量副本

public void set(T value) { } //set()用来设置当前线程中变量的副本

public void remove() { } //remove()用来移除当前线程中变量的副本

protected T initialValue() { } //initialValue()是一个protected方法，一般是用来在使用时进行重写的

在这个方法内部我们看到，首先通过getMap(Thread t)方法获取一个和当前线程相关的ThreadLocalMap，然后将变量的值设置到这个ThreadLocalMap对象中，当然如果获取到的ThreadLocalMap对象为空，就通过createMap方法创建。这里的this是指向threadlocal实例对象的。

其中ThreadLocal类中的get方法源码实现如下：

/**

• Returns the value in the current thread's copy of this
• thread-local variable. If the variable has no value for the
• current thread, it is first initialized to the value returned
• by an invocation of the {@link #initialValue} method.
• @return the current thread's value of this thread-local */ public T get() { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) { ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) return (T)e.value; } return setInitialValue(); } 第一句是取得当前线程，然后通过getMap(t)方法获取到一个map，map的类型为ThreadLocalMap。获取和当前线程绑定的值时，ThreadLocalMap对象是以this指向的ThreadLocal对象为键进行查找的　所以通过ThreadLocalMap的Entry获取到<key,value>键值对

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

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

　　我们上面的每一句来仔细分析：首先看一下getMap方法中做了什么：

/**

• Get the map associated with a ThreadLocal. Overridden in
• InheritableThreadLocal.
• @param t the current thread
• @return the map */ ThreadLocalMap getMap(Thread t) { return t.threadLocals; } 在getMap中，是调用当期线程t，返回当前线程t中的一个成员变量threadLocals

Thread类中的成员变量threadLocals是什么？源码如下：

ThreadLocal.ThreadLocalMap threadLocals = null;threadLocals是一个ThreadLocalMap，这个类型是ThreadLocal类的一个内部类，ThreadLocalMap的实现如下

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

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

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

/** * Variant of set() to establish initialValue. Used instead * of set() in case user has overridden the set() method. * * @return the initial value */ 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; }

/**
 * Provides the initial value of this variable for the current thread.
 * The default implementation returns {@code null}.
 *
 * @return the initial value of the variable.
 */
protected T initialValue() {
    return null;
}

如果map不为空，就设置键值对，如果map为空，调用createMap，createMap的实现

/**

• Create the map associated with a ThreadLocal. Overridden in
• InheritableThreadLocal.
• @param t the current thread
• @param firstValue value for the initial entry of the map
• @param map the map to store. */ void createMap(Thread t, T firstValue) { t.threadLocals = new ThreadLocalMap(this, firstValue); } ThreadLocalMap是ThreadLocal类的一个静态内部类，它实现了键值对的设置和获取，每个线程中都有一个独立的ThreadLocalMap副本，它所存储的值，只能被当前线程读取和修改。ThreadLocal类通过操作每一个线程特有的ThreadLocalMap副本，从而实现了变量访问在不同线程中的隔离。因为每个线程的变量都是自己特有的，完全不会有并发错误。还有一点就是，ThreadLocalMap存储的键值对中的键是this对象指向的ThreadLocal对象，而值就是你所设置的对象了。

这个时候再看set方法就简单多了，源码如下：

/** * Sets the current thread's copy of this thread-local variable * to the specified value. Most subclasses will have no need to * override this method, relying solely on the {@link #initialValue} * method to set the values of thread-locals. * * @param value the value to be stored in the current thread's copy of * this thread-local. */ public void set(T value) { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else createMap(t, value); } 在这个方法内部我们看到，首先通过getMap(Thread t)方法获取一个和当前线程相关的ThreadLocalMap，然后将变量的值设置到这个ThreadLocalMap对象中,其中以this指向的threadlocal对象为健值，当然如果获取到的ThreadLocalMap对象为空，就通过createMap方法创建。

总结一下：

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

　　2）为何threadLocals的类型ThreadLocalMap的键值为ThreadLocal对象，因为每个线程中可有多个threadLocal变量；

　　3）在进行get之前，必须先set，否则会报空指针异常；因为在上面的代码分析过程中，我们发现如果没有先set的话，即在map中查找不到对应的存储，则会通过调用setInitialValue方法返回i，而在setInitialValue方法中，有一个语句是T value = initialValue()， 而默认情况下，initialValue方法返回的是null。

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

四、ThreadLocal例子

public class Test { ThreadLocal<Long> longLocal = new ThreadLocal<Long>(){ protected Long initialValue() { return Thread.currentThread().getId(); }; }; ThreadLocal<String> stringLocal = new ThreadLocal<String>(){; protected String initialValue() { return Thread.currentThread().getName(); }; };

public void set() {
    longLocal.set(Thread.currentThread().getId());
    stringLocal.set(Thread.currentThread().getName());
}
 
public long getLong() {
    return longLocal.get();
}
 
public String getString() {
    return stringLocal.get();
}
 
public static void main(String[] args) throws InterruptedException {
    final Test test = new Test();
 
    test.set();
    System.out.println(test.getLong());
    System.out.println(test.getString());

    Thread thread1 = new Thread(){
        public void run() {
            test.set();
            System.out.println(test.getLong());
            System.out.println(test.getString());
        };
    };
    thread1.start();
    thread1.join();
    
    System.out.println(test.getLong());
    System.out.println(test.getString());
}

} public static void main(String[] args) throws InterruptedException { final Test test = new Test();

    System.out.println(test.getLong());
    System.out.println(test.getString());
 
    Thread thread1 = new Thread(){
        public void run() {
            test.set();
            System.out.println(test.getLong());
            System.out.println(test.getString());
        };
    };
    thread1.start();
    thread1.join();
    
    System.out.println(test.getLong());
    System.out.println(test.getString());
}

终端的输出结果为：

１

main

8

thread-0

共享变量test在主线程和thread１线程中，各自有一个threadlocalmap来存储该变量的副本，各自的threadlocalmap将把共享变量test中的LongLocal和StringLocal的对象作为健，以thread的id 和name为值进行存储。

上面的test中的LongLocal和StringLocal都是重写了initvalue方法的，所以在main方法中先进行getXXX时没有报异常