ThreadLocal用法及原理

• 苏格团队
• 做者：ZhiCheng

与Synchonized的对照: ThreadLocal和Synchonized都用于解决多线程并发訪问。但是ThreadLocal与synchronized有本质的差异。synchronized是利用锁的机制，使变量或代码块在某一时该仅仅能被一个线程訪问。而ThreadLocal为每一个线程都提供了变量的副本，使得每一个线程在某一时间訪问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反，它用于在多个线程间通讯时能够得到数据共享。

Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。

---

1、用法

把要线程隔离的数据放进ThreadLocal

static ThreadLocal<T> threadLocal = new ThreadLocal<T>() {
	protected T initialValue() {
		这里通常new一个对象返回
    }
}
复制代码

线程获取相关数据的时候只要

threadLocal.get();
复制代码

想修改、赋值只要

threadLocal.set(val)
复制代码

二 、使用场景

如上面说到的，ThreadLocal是用于线程间的数据隔离，ThreadLocal为每一个线程都提供了变量的副本。

• 举例1：联想一下服务器（例如tomcat）处理请求的时候，会从线程池中取一条出来进行处理请求，若是想把每一个请求的用户信息保存到一个静态变量里以便在处理请求过程当中随时获取到用户信息。这时候能够建一个拦截器，请求到来时，把用户信息存到一个静态ThreadLocal变量中，那么在请求处理过程当中能够随时从静态ThreadLocal变量获取用户信息。

• 举例2：Spring的事务实现也借助了ThreadLocal类。Spring会从数据库链接池中得到一个connection，然会把connection放进ThreadLocal中，也就和线程绑定了，事务须要提交或者回滚，只要从ThreadLocal中拿到connection进行操做。

3、原理分析

一、get()方法

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {//当map已存在
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();//初始化值
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}
复制代码

上面先取到当前线程，而后调用getMap方法获取对应的ThreadLocalMap，ThreadLocalMap是ThreadLocal的静态内部类，而后Thread类中有一个这样类型成员，因此getMap是直接返回Thread的成员

ThreadLocal.ThreadLocalMap threadLocals = null;
复制代码

来看下ThreadLocal的内部类ThreadLocalMap源码，留个大体印象

static class ThreadLocalMap {
	private static final int INITIAL_CAPACITY = 16;//初始数组大小
    private Entry[] table;//每一个能够拥有多个ThreadLocal
    private int size = 0;
    private int threshold;//扩容阀值
    static class Entry extends WeakReference<ThreadLocal<?>> {
        Object value;

        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
 
    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);
    }
    
    private void set(ThreadLocal<?> key, Object value) {
        Entry[] tab = table;
        int len = tab.length;
        int i = key.threadLocalHashCode & (len-1);
        for (Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) {
            ThreadLocal<?> k = e.get();
            if (k == key) {
                e.value = value;
                return;
            }
            if (k == null) {
            		//循环利用key过时的Entry
                replaceStaleEntry(key, value, i);
                return;
            }
        }
        tab[i] = new Entry(key, value);
        int sz = ++size;
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
            rehash();
    }
	...
｝
复制代码

能够看到有个Entry内部静态类，它继承了WeakReference，总之它记录了两个信息，一个是ThreadLocal<?>类型，一个是Object类型的值。getEntry方法则是获取某个ThreadLocal对应的值，set方法就是更新或赋值相应的ThreadLocal对应的值。里面涉及到扩容策略、Entry哈希冲突、循环利用等等再也不深刻，留个大体印象就好。

回顾下get()方法中的代码

if (map != null) {
    ThreadLocalMap.Entry e = map.getEntry(this);
    if (e != null) {
        @SuppressWarnings("unchecked")
        T result = (T)e.value;
        return result;
    }
}
return setInitialValue();
复制代码

map为null或e为null就会走到setInitialValue，若是咱们是第一次get()方法，那map会是空的，因此接下来先看setInitialValue()方法

private T setInitialValue() {
		//调用咱们实现的方法获得须要线程隔离的值
    T value = initialValue();
    Thread t = Thread.currentThread();
    //拿到相应线程的ThreadLocalMap成员变量
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}
复制代码

上面initialValue就是实例化ThreadLocal要实现的方法，这里又取了线程的ThreadLocalMap，不为空就把值set进去（键为TreadLocal自己，值就是initialValue返回的值）；为空就建立一个map同时添加一个值进去,最后返回value。

map.set(this, value)这句代码在上面的ThreadLocalMap源码中能够看到大体流程，下面看看createMap()作了什么事

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


ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    table = new Entry[INITIAL_CAPACITY];
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    	//建立一个Entry，加入数组
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    setThreshold(INITIAL_CAPACITY);
}
复制代码

能够看到在new ThreadLocalMap以后，就会建立一个Entry加入到数组中，最后把ThreadLocalMap的引用赋值给Thread的threadLocals成员变量

在回顾下get()方法中的代码

if (map != null) {
    ThreadLocalMap.Entry e = map.getEntry(this);
    if (e != null) {
        @SuppressWarnings("unchecked")
        T result = (T)e.value;
        return result;
    }
}
return setInitialValue();
复制代码

如今map不会为空了，再次调用get方法就会调用map的getEntry方法（上面的ThreadLocalMap源码中能够看到大体流程），拿到相应的Entry，而后就能够拿到相应的值返回出去

二、set方法

分析完get()方法，那么set()方法就天然而然的明白了，就再也不赘述

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

总结

• 原理

  ThreadLocal的实现原理是，在每一个线程中维护一个Map，键是ThreadLocal类型，值是Object类型。当想获取ThreadLocal的值时，就从当前线程中拿出Map，而后在把ThreadLocal自己做为键从Map中拿出值返回。

• 优缺点

  **优势：**提供线程内的局部变量。每一个线程都本身管理本身的局部变量，互不影响

  **缺点：**内存泄漏问题。能够看到ThreadLocalMap中的Entry是继承WeakReference的，其中ThreadLocal是以弱引用形式存在Entry中，若是ThreadLocal在外部没有被强引用，那么垃圾回收的时候就会被回收掉，又由于Entry中的value是强引用，就会出现内存泄漏。虽然ThreadLocal源码中的会对这种状况进行了处理，但仍是建议不须要用TreadLocal的时候，手动调remove方法。