ThreadLocal原理简单刨析

ThreadLocal原理简单刨析

ThreadLocal实现了各个线程的数据隔离，要知道数据是如何隔离的，就要从源代码分析。

ThreadLocal原理

需要提前说明的是：ThreadLocal只是一个向线程对象中存取数据的工具，ThreadLocal对象本身并不储存数据。

源码剖析

public class TestThread {
    public static void main(String[] args) {
        ThreadLocal<String> local = new ThreadLocal<>();
        local.set("main's data");
        System.out.println("main get = " + local.get());
    }
}
/*
main get = main's data
*/

让我们从源码的角度分析，到底发生了什么。

set()原理

// 向当前线程放入数据
public void set(T value) {
        Thread t = Thread.currentThread(); // t 就是main线程
        ThreadLocalMap map = getMap(t); // 获取当前线程从父类Thread中继承的一个实例变量threadLocals
        if (map != null) {
            map.set(this, value); // this代表当前的ThreadLocal对象，也就是local
        } else {
            createMap(t, value); // 创建新的map
        }
    }
// 获取存放数据的容器ThreadLocalMap, 实际上是Thread对象的一个实例变量。
ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
// 实例化ThreadLocalMap对象，并将t线程中的threadLocals实例变量引用到该对象
void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

get()原理

public T get() {
        Thread t = Thread.currentThread(); // 获取当前的线程，也就是main线程
        ThreadLocalMap map = getMap(t); // 获取ThreadLocalMap对象
        if (map != null) {
            // Entry对象可以理解为键值对
            ThreadLocalMap.Entry e = map.getEntry(this); // this就是local，获取以local为键的Entry对象
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value; // 有值就获取值并返回
                return result;
            }
        }
        return setInitialValue(); // 返回的值还是null
    }
private T setInitialValue() {
        T value = initialValue(); // initialValue()返回null, 此时value的值是null
        Thread t = Thread.currentThread(); // 此时t是main线程
        ThreadLocalMap map = getMap(t); // 获取当前线程从父类Thread中继承的一个实例变量threadLocals
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value);
        }
        if (this instanceof TerminatingThreadLocal) {
            TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
        }
        return value; // 最后value还是null
    }
// 返回null
protected T initialValue() {
        return null;
    }

InheritableThreadLocal

InheritableThreadLocal顾名思义，可以可以达到子线程继承父线程中数据的效果。通过一段代码来看效果。

public class TestThread {
    public static void main(String[] args) {
        InheritableThreadLocal<String> local = new InheritableThreadLocal<>();
        local.set("main's data");
        Thread one = new One(local);
        one.start();
        System.out.println("main get = " + local.get());
    }
}
class One extends Thread {
    private int value;
    public InheritableThreadLocal<String> local;
    public One(InheritableThreadLocal<String> local) {
        this.local = local;
    }
    @Override
    public void run() {
        local.set("one's data");
        System.out.println("one get = " + local.get());
    }
}
/*
main get = main's data
one get = main's data
*/

父线程使用InheritableThreadLocal和ThreadLocal存数据的区别

InheritableThreadLocal继承了ThreadLocal类。它重写了父类中的三个方法。

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    protected T childValue(T parentValue) {
        return parentValue;
    }
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

set()发生了什么变化

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t); // 在这里会调用重写了的getmap()方法
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value); // 调用了重写了的createMap()方法
        }
    }

其实只发生了一件事，之前存数据的字段是threadLocals，现在变成了inheritableThreadLocals。

子线程继承父线程数据的过程

继承数据的关键在于子线程对象在实例化的时候会从父线程的threadLocals中拷贝数据。子线程对象在实例化的时候，会先实例化父类，也就是会执行下面的构造函数,，然后顺序执行下列构造器。

1. public One(InheritableThreadLocal<String> local) {
        this.local = local;
   }
2. public Thread() {
        this(null, null, "Thread-" + nextThreadNum(), 0);
   }
3. public Thread(ThreadGroup group, Runnable target, String name,
                  long stackSize) {
        this(group, target, name, stackSize, null, true);
   }
4. private Thread(ThreadGroup g, Runnable target, String name,
                   long stackSize, AccessControlContext acc,
                   boolean inheritThreadLocals) {
    	...
        Thread parent = currentThread(); // parent就是main线程
    	if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals = // 这里的this是子线程，也就是one线程
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    	...
	}

在第三个构造器可以看到传给下一个构造器中inheritableThreadLocals的参数的值是true。

接下来再来看看第四个构造器中ThreadLocal.createInheritableMap()函数是干什么用的，其实就是将父线程中的数据拷贝给子线程。

static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
        return new ThreadLocalMap(parentMap);
}
// 本质上就是循环遍历拷贝父线程的数据，然后给子线程
private ThreadLocalMap(ThreadLocalMap parentMap) {
    Entry[] parentTable = parentMap.table;
    int len = parentTable.length;
    setThreshold(len);
    table = new Entry[len];
    for (Entry e : parentTable) {
        if (e != null) {
            @SuppressWarnings("unchecked")
            ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
            if (key != null) {
                Object value = key.childValue(e.value);
                Entry c = new Entry(key, value);
                int h = key.threadLocalHashCode & (len - 1);
                while (table[h] != null)
                    h = nextIndex(h, len);
                table[h] = c;
                size++;
            }
        }
    }
}

这样子线程就获取了父线程的中的数据，达到了继承数据的效果。

不过有一点需要需要注意，子线程对象不是引用父线程对象中的数据，而是直接在子线程对象实例化的过程中拷贝了一份过来，所以子线程跑起来之后，父子线程中的数据就不相关了。不过如果存入的数据是引用类型，那么还是会有实时共享的效果。