ThreadLocal 相关解析

ThreadLocal

ThreadLocal 作用

提供线程内的局部变量,不同的线程之间不会相互干扰,这种变量在线程的生命周期内起作用,减少同一个线程内多个函数或组件组件一些公共变量的传递的复杂度.

1. 线程并发:在多线程并发的情况下。
2. 传递数据:同一线程的不同组件间传递数据。
3. 线程隔离:不同线程互不干扰。

ThreadLocal 与 synchronized 的区别

• 相同点: 处理多线程并发访问变量的问题。

• 原理：

  • synchronized	ThreadLocal
    同步机制，采用以时间换空间的方式，只提供一份变量，不同线程排队访问	采用以空间换取时间的方式，为每一个线程提供一份变量的副本，从而实现同时访问而互不干扰

• 侧重点：

  • synchronized	ThreadLocal
    多个线程之间访问资源的同步	多线程中让每个线程之间的数据之间相互隔离

Thread、ThreadLocal、ThreadLocalMap 之间的关系。

内存泄露相关

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

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


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

// get 
public T get() {
    Thread t = Thread.currentThread();
    // Thread.currentThread().threadLocals
    // map 就是 threadLocals
    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();
}

// setInitialValue
private T setInitialValue() {
    // initialValue() 默认 null
    T value = initialValue();
    Thread t = Thread.currentThread();
    // Thread.currentThread().threadLocals
    // map 就是 threadLocals
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

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

// threadLocals  -> ThreadLocal.ThreadLocalMap	
static class ThreadLocalMap {
    static class Entry extends WeakReference<ThreadLocal<?>> {
        Object value;
        
        // k:threadLocal;  v:value
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    // 初始容量 - 必须是 2 的幂
    private static final int INITIAL_CAPACITY = 16;
    // Entry数组，根据需要调整大小。table.length 必须始终是 2 的幂
    private Entry[] table;
    // table 中的条目数
    private int size = 0;
    // 要调整大小的下一个大小值
    private int threshold; // Default to 0
}

如果一个对象的所有引用都是弱引用的话，该对象会被回收。

如果ThreadLocal不使用static修饰，可能出现Entry[i]的key为null而value不为null,可能会导致内存泄露。（set方法可能会清除过期的Entry中ThreadLocal对应的value ）

通常使用static 修饰ThreadLocal ,那么ThreadLocal的生命周期和它的持有的类相同, 所以也就不会出现key 为null的情况、弱引用也失去了意义 。所以这时候就要调用remove()。

remove：清除ThreadLocal在Entry[]对应的key和value，并将对应的Entry[i]置为NULL

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

    private void remove(ThreadLocal<?> key) {
        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)]) {
            if (e.get() == key) {
                e.clear(); // 清除key
                expungeStaleEntry(i);  // 清除value，并将tab[i]置为null
                return;
            }value
        }
    }

    private int expungeStaleEntry(int staleSlot) {
        Entry[] tab = table;
        int len = tab.length;

        // expunge entry at staleSlot  =>  与此线程本地关联的值 | 内存泄露
        tab[staleSlot].value = null;
        tab[staleSlot] = null;
        size--;
        .................   
    }