java源码学习---ThreadLocal

最新推荐文章于 2024-10-18 16:13:48 发布

weixin-sjk6070

最新推荐文章于 2024-10-18 16:13:48 发布

阅读量105

点赞数

分类专栏：编程

本文链接：https://blog.csdn.net/chunzhenwang/article/details/104419601

版权

编程专栏收录该内容

16 篇文章 0 订阅

订阅专栏

ThreadLocal 是一个线程安全副本，用于储存仅允许当前线程能访问/修改的值,不知从何时起看到了”线程安全“这种字眼就会不自觉想到性能问题，但是ThreadLocal是实现线程安全的另外一种方案"空间换时间"。

先看2个小Demo

使用ThreadLocal

public class ThreadLoacalTest{

// 定义线程安全副本
private final static ThreadLocal<Integer> THREAD_NUMBER = new ThreadLocal<Integer>();

// 继承Thread重写run()
static class ThreadTest extends Thread{
    @Override
    public void run() {
        for (int i=0; i < 3 ;i++){
            // 如果THREAD_NUMBER 为null，赋值0，否则+1
            THREAD_NUMBER.set(THREAD_NUMBER.get() == null ? 0 : THREAD_NUMBER.get() + 1);
            // 打印信息
            System.out.println(Thread.currentThread().getName() + ":" + THREAD_NUMBER.get());
        }
        THREAD_NUMBER.remove();
    }
}

public static void main(String[] args) {
    ThreadTest t1 = new ThreadTest();
    ThreadTest t2 = new ThreadTest();
    ThreadTest t3 = new ThreadTest();
    t1.start();
    t2.start();
    t3.start();
}

}

不使用ThreadLocal

public class Test {

// 定义普通常量
public static Integer THREAD_NUMBER = 0;

// 继承Thread重写run()
static class ThreadTest extends Thread{
    @Override
    public void run() {
        for (int i=0; i < 3 ;i++){
            // 打印信息
            System.out.println(Thread.currentThread().getName() + ":" + THREAD_NUMBER++);
        }
    }
}

public static void main(String[] args) {
    ThreadTest t1 = new ThreadTest();
    ThreadTest t2 = new ThreadTest();
    ThreadTest t3 = new ThreadTest();
    t1.start();
    t2.start();
    t3.start();
}

}

从上面的打印结果可以看出，使用了ThreadLocal的常量不会与其他线程共享，而没有使用ThreadLocal的常量是会与其他线程共享

接下来看源码

从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);
}
1.先获取当前线程对象

2.通过当前线程对象获取一个ThreadLocalMap 实例（以下简称map）

3.如果map不为null 则直接向map插入数据

4.如果为null则调用createMap()创建一个map并且向map插入数据

该map以当前对象作为key，这样我们就只需要关注value而不用维护key

getMap()

可以看到这个threadLocals属性是Thread的，但是类是属于ThreadLocal的一个内部类ThreadLocalMap

因为这个map对象属于Thread的实例，每个Thread都是特有的map，所以能提供整个线程使用且不与其他线程共享

ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
ThreadLocal.ThreadLocalMap threadLocals = null;
createMap()

2个参数，一个是key(当前ThreadLocal实例)，一个是value(我们维护的对象)

下面代码可以看出值都是保存在一个Entry对象的数组里面，以及一些初始化的工作

Entry又是ThreadLocal.ThreadLocalMap 的一个内部类 ThreadLocal.ThreadLocalMap.Entry

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.set()

在这里向Entry[]添加元素，计算出下标，如果该下标位置没有元素，则直接插入元素。如果有元素，则遍历数组直到没有元素的下标位置才停下进行存储，如果遇到相同key则更新元素并且遇到key为null的Entry时，会删除元素。存储完之后判断当前数组容量是否需要扩容，如果进行了扩容，所有元素都会重新存储一遍

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) {
        replaceStaleEntry(key, value, i);
        return;
    }
}

tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
    rehash();

}
接下来看看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();
}
我们获取ThreadLocal维护的变量都是直接通过ThreadLocal的get()获取

1.获取当前线程对象

2.通过当前线程对象获取map

3.通过当前对象向map获取值(Entry对象)，如果map与Entry对象都不为null则直接返回存储的值

4.如果值为null，则调用setInitialValue()初始化键值对并返回null

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;
}
setInitialValue() 先通过initialValue()初始化值，然后保存到map并且返回初始化的值

（判断是否需要创建map这个步骤实在不想写了，ThreadLocal里面太多这样的操作了）

protected T initialValue() {
return null;
}
ThreadLocalMap.getEntry()

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);
}
首先是计算出key对应值储存的下标，当元素不为null且key相等，则返回对应的值，如果下标与key不对应，则遍历数组查询，整个数组都不存在该key，则返回null，如果遇到key为null的Entry时，会删除元素

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;

while (e != null) {
    ThreadLocal<?> k = e.get();
    if (k == key)
        return e;
    if (k == null)
        expungeStaleEntry(i);
    else
        i = nextIndex(i, len);
    e = tab[i];
}
return null;

}
以上源码学习总结：

1.ThreadLocal原理是该类主要操作一个Thread类的 ThreadLocalMap threadLocals属性,该属性是属于每个Thread实例特有的，所以能提供整个线程使用且不与其他线程共享

2.ThreadLocalMap 的底层其实是一个素组，当计算到的存储下标已存在元素，则循环判断是否为null(能否存储)，如果存在相同key则更新元素

3.get()、set()操作的时候如果碰到了key为null的情况都会删除key为null的 Entry 对象

都说ThreadLocal是以"空间换时间",以上代码也证实了确实如此。但是有个问题，就是空间用得越多，就越容易OOM。所以Entry继承了WeakReference弱引用。

static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;

Entry(ThreadLocal<?> k, Object v) {
    super(k);
    value = v;
}

}
这里的key是弱引用，就是key指向的对象(ThreadLocal)如果没有其他强引用的情况下，下次GC的时候就会被回收,这保证了一定的垃圾回收效率，但是如果存在其他强引用情况下，GC并不会回收该对象，所以我们使用ThreadLocal的时候需要注意有没有被强引用