ThreadLocal线程本地变量

概念

ThreadLoacl主要是用来做线程间共享但又不关联的共享变量的存储。当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，也就是只是共用这个变量以及该变量的初始值,所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
public class ThreadLocalTest {  
  
    public void test(){  
        ThreadLocal<Integer> local = new ThreadLocal<Integer>(){  
            @Override  
            protected Integer initialValue() {  
                return 0;  
            }  
        };  
        ExecutorService service = Executors.newFixedThreadPool(3);  
        for(int i=0;i<3;i++){  
            service.execute(new Runnable() {  
                @Override  
                public void run() {  
                    Integer num = local.get();  
                    Integer init = num;  
                    while(++num<10);   
                    System.out.println("当前线程为:" + Thread.currentThread().getName() + ",初始值为："+init+",结果数据为:" + num);  
                }  
            });  
        }  
        service.shutdown();  
    }  
      
    public static void main(String[] args) {  
        new ThreadLocalTest().test();  
    }  
}  

当前线程为:pool-1-thread-1,初始值为：0,结果数据为:10  
当前线程为:pool-1-thread-3,初始值为：0,结果数据为:10  
当前线程为:pool-1-thread-2,初始值为：0,结果数据为:10  

 通过测试代码可以看到，虽然三个线程使用了同一个ThreadLocal变量，并各自进行加到10操作，但是三个线程之间并没有相互影响，而只是共享了变量初始值。

ThreadLocal源码分析

1. get()

首先查看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();  
    }  

可以看到get方法首先取得当前线程对象，接着借此调用getMap方法返回ThreadLocalMap对象。

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

 而getMap方法最终是从当前线程中取得ThreadLocalMap实例，查看线程类：

/* ThreadLocal values pertaining to this thread. This map is maintained  
 * by the ThreadLocal class. */  
    ThreadLocal.ThreadLocalMap threadLocals = null;  

发现它是线程类的实例成员，也就是说，每一个线程都有自己独立的ThreadLocalMap实例。

在我们第一次调用ThreadLocal的get()方法时，getMap()方法返回是null(这一点可以通过查看Thread类的构造方法最终执行的init方法发现，构造线程时没有对ThreadLocal.ThreadLocalMap threadLocals进行初始化)，所以执行了setInitialValue方法。

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

其中initialValue()方法就是我们重写过的方法，在上面的例子中我们返回的是0.由于是第一次执行，getMap(t)方法方的是null，所以接着看createMap方法：

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

终于创建了当前线程t的ThreadLocalMap，其中参数this为当前ThreadLocal实例，firstValue为其初始值：

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

在ThreadLocalMap构造方法中，创建了一个类似Map的对象，并且以ThreadLocal实例为key，initialValue()方法的返回值为value。所以每一个线程都有一个独立的这样的ThreadLocalMap对象将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)不再返回null，所以进入if块，然后以当前ThreadLocal实例为Key，取得当前线程的ThreadLocalMap中对应的值，当然如果发现不存在这样的键值对entry，那么还是进行执行setInitialValue.

2. set(T value)

这个方法就是重新设置每一个线程的本地ThreadLocal变量的值

 

public void set(T value) {  
        Thread t = Thread.currentThread();  
        ThreadLocalMap map = getMap(t);  
        if (map != null)  
            map.set(this, value);  
        else  
            createMap(t, value);  
} 

这里取得当前线程，然后根据当前的thradLocal实例取得其map。然后重新设置 map.set(this, value);这时这个线程的thradLocal里的变量副本就被重新设置值了！

3. remove()

就是清空ThreadLocalMap里的key-value键值对，这样一来。下次再调用get时又会调用initialValue这个方法返回设置的初始值.

public void remove() {  
         ThreadLocalMap m = getMap(Thread.currentThread());  
         if (m != null)  
             m.remove(this);  
}

总结：

1、每个线程都有自己的局部变量

每个线程都有一个独立于其他线程的上下文ThreadLocalMap来保存这个变量。

2、独立于变量的初始化副本

ThreadLocal可以给一个初始值，而每个线程都会获得这个初始化值的一个副本，这样才能保证不同的线程都有一份拷贝。

3、状态与某一个线程相关联

ThreadLocal 不是用于解决共享变量的问题的，也不是为了协调线程同步而存在，而是为了方便每个线程处理自己的状态而引入的一个机制。