前语

ThreadLocal<T>多用在多线程数据阻隔(只能阻隔一个T类型的值)，假如需求多个，则需求创立多个ThreadLocal。

private static ThreadLocal<String> sThreadLocal = new ThreadLocal<>();
public static void testMain(){
    for (int i = 0; i < 3; i++) {
        String threadName = "thread"+i;
        new Thread(() -> {
            sThreadLocal.set(threadName);
            System.out.println("threadName:"+Thread.currentThread().getName()+" name:"+sThreadLocal.get());
        },threadName).start();
    }
}
输出：
threadName:thread0 name:thread0
threadName:thread1 name:thread1
threadName:thread2 name:thread2

每个线程经过ThreadLocal对自己存储的数据没有出现脏读的情况(拿到的值是自己存的)。

ThreadLocal怎样做到在多线程间数据阻隔的

ThreadLocal是怎样做到多线程数据阻隔的，看下ThreadLocal的set方法：

public void set(T value) {
    // 拿到当时线程
    Thread t = Thread.currentThread();
    // 拿到当时线程的ThreadLocalMap，把value存储进去
    ThreadLocalMap map = getMap(t);
    if (map != null)
        // this 是ThreadLocal(自己创立的sThreadLocal用来存储多线程数据结构)，用来维持多个副本ThreadLocal设计。
        map.set(this, value);
    else
        createMap(t, value);
}
public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        // this 是ThreadLocal(自己创立的sThreadLocal用来存储多线程数据结构)，和上面set中的this共同。
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}
// ThreadLocalMap 以Thread作为key，以ThreadLocalMap作为value
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}
// 内部类
static class ThreadLocalMap {
    // 内部类 弱引证:处理十分大和生命周期十分长的线程，哈希表运用弱引证作为key
    static class Entry extends WeakReference<ThreadLocal<?>> {
        // key:ThreadLocal value:咱们数据阻隔的位置
        Object value;
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
}

可以看到每个线程都有自己的数据区threadLocals(ThreadLocal.ThreadLocalMap),当往咱们自定义的sThreadLocal调用set(value)存储的时候，会拿当时线程作为key进行存储。当咱们调用get()获取的时候依据当时线程(作为key)进行获取。实现多线程经过ThreadLocal<T>实现数据阻隔。

• 每个线程都有自己的数据区(ThreadLocal.ThreadLocalMap)存储归于自己线程的数据
• ThreadLocal<T>的set(存储)和get(获取)依据当时线程来处理

引证传递

static NumIndex numIndex = new NumIndex();
private static ThreadLocal<NumIndex> sThreadLocal = new ThreadLocal<NumIndex>() {
    @Nullable
    @Override
    protected NumIndex initialValue() {
        // 这儿留意不要这样写。会导致多线程安全问题，由于numIndex不具备多线程安全。这儿是每个线程的初始化值，不能把其他线程初始化的值写道这儿。
        return numIndex;
    }
};
static class NumIndex {
    int num = 0;
    public void increment() {
       num++;
    }
}
public static void testMain() {
    for (int i = 0; i < 3; i++) {
        String threadName = "thread" + i;
        new Thread(() -> {
            NumIndex index = sThreadLocal.get();
            index.increment();
            sThreadLocal.set(index);
            System.out.println("threadName:" + Thread.currentThread().getName() + " name:" + sThreadLocal.get().num);
        }, threadName).start();
    }
}
输出：
threadName:thread0 name:1
threadName:thread2 name:3
threadName:thread1 name:2

显着出现了多线程并发导致的数据不安全。
在运用ThreadLocal重写initialValue(一般不要重写，不然需求考虑并发问题)要留意。留意值传递和引证传递的区别。

private static ThreadLocal<Integer> sThreadLocal = new ThreadLocal<Integer>() {
    @Nullable
    @Override
    protected Integer initialValue() {
        return 0;
    }
};
public static void testMain() {
    for (int i = 0; i < 3; i++) {
        String threadName = "thread" + i;
        new Thread(() -> {
            Integer index = sThreadLocal.get();
            sThreadLocal.set(index+5);
            System.out.println("threadName:" + Thread.currentThread().getName() + " name:" + sThreadLocal.get());
        }, threadName).start();
    }
}
输出：
threadName:thread0 name:5
threadName:thread2 name:5
threadName:thread1 name:5

上面是值传递，由于是数据阻隔的不会叠加。initialValue只需重写后返回的值(可变的)不是多多线程共享的变量则不会出现线程安全问题。

总结

• 每个ThreadLocal只能保存一个变量副本，假如想保存多个，则需求创立多个ThreadLocal(从set和get中的this可以体现出来)
• ThreadLocal内部的ThreadLocalMap的内部类Entry是弱引证
• 每次用完ThreadLocal，都调用它的remove方法，清理数据