ThreadLocal

ThreadLocal

• 一个对象的所有线程会共享其全局变量——>线程不安全

  解决方式：
  方式一：同步机制，加锁（时间换空间）
  方式二：ThreadLocal在每个线程中都创建了一个变量的副本，线程各自访问自己的副本变量，则不存在变量共享问题。（空间换时间）

  变量与线程的关系private static，所以ThreadLocal与线程的关系private static
  eg：session

• 同一个线程内多个函数/组件间公共变量传递复杂，降低了多模块间的耦合度。关联线程和线程上下文

ThreadLocalMap

每一个thread都有一个threadLocalMap变量，key=threadLocal value=值
（一个thread可以有多个threadLocal）

public class Thread implements Runnable {
	//存储与此线程相关的threadLocal，值由threadLocal维护
	ThreadLocal.ThreadLocalMap threadLocals;
}

jdk1.7的实现方式为每一个threadLocal都有一个threadLocalMap变量，key=threadID value=值

• 储存的entry减少，之前由thread数量决定，现在由threadLocal决定
• thread销毁对应的threadLocalMap也销毁。threadLocalMap的生命周期=线程的生命周期，内存使用减少

get

private T get(Thread t) {
	ThreadLocalMap map = getMap(t);
    if (map != null) {
        if (map == ThreadLocalMap.NOT_SUPPORTED) {
            return initialValue();
        } else {
        	//根据ThreadLocalHash计算index，取得Entry 
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T) e.value;
                return result;
            }
        }
    }
    return setInitialValue(t);
}

private T setInitialValue(Thread t) {
	T value = initialValue();
    ThreadLocalMap map = getMap(t);
    assert map != ThreadLocalMap.NOT_SUPPORTED;
    if (map != null) {
        map.set(this, value);
    } else {
        createMap(t, value);
    }
    if (this instanceof TerminatingThreadLocal<?> ttl) {
        TerminatingThreadLocal.register(ttl);
    }
    return value;
}

set

private void set(Thread t, T value) {
    ThreadLocalMap map = getMap(t);
    if (map == ThreadLocalMap.NOT_SUPPORTED) {
        throw new UnsupportedOperationException();
    }
    if (map != null) {
        map.set(this, value);
    } else {
        createMap(t, value);
    }
}

//存入值
private void set(ThreadLocal<?> key, Object value) {

    // We don't use a fast path as with get() because it is at
    // least as common to use set() to create new entries as
    // it is to replace existing ones, in which case, a fast
    // path would fail more often than not.

    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.refersTo(key)) {
            e.value = value;
            return;
        }

        if (e.refersTo(null)) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }

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

//初始化map
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

remove

private void remove(Thread t) {
   ThreadLocalMap m = getMap(t);
    if (m != null && m != ThreadLocalMap.NOT_SUPPORTED) {
        m.remove(this);
    }
}

内存泄漏

引用链：threadRef->thread->threadLocalMap->entry->value

弱引用：如果这个对象只存在弱引用，那么在下一次GC时会被清理。

ThreadLocalMap 中使用的 key 为 ThreadLocal 的弱引用。所以如果 ThreadLocal 没有被外部强引用，在GC时ThreadLocal 会被清理掉，ThreadLocalMap中使用这个 ThreadLocal 的 key 也会被设为null。由于value 是强引用，不会被清理，依然存在，就会出现 key 为 null 的 value，value无法访问。在map中value为强引用不会被清除，直到map被清除。然而由于threadLocalMap的生命周期=线程，线程池通常采取线程复用的方法，所以线程池中的线程很难结束。所以value可能一直无法回收。

key用强/弱引用

• key用强引用：引用ThreadLocal的对象被回收了，但threadLocalMap中还有threadLocal的强引用，若未手动删除，threadLocal不会被回收，导致entry内存泄漏
• key用弱引用：引用ThreadLocal的对象被回收了，但threadLocalMap中还有threadLocal的弱引用，即使未手动删除，threadLocal也会被回收，导致value内存泄漏
• 结论：若未手动删除key，都会导致内存泄漏。强引用threadLocal不会被回收，弱引用value。 内存泄漏与强/弱引用无关，根本原因在于threadLocalMap的生命周期=线程。

解决方式：用完threadLocal，调用remove清除无用的entry，由于Entry继承了弱引用类，会在下次GC时被JVM回收。get()，set()，remove()，会顺便移除key=null的entry

entry继承了弱引用

public class ThreadLocal<T> {

	static class ThreadLocalMap {
		private Entry[] table;
	
		//轻量级map，桶中存entry而非entry链表
		//Entry 继承弱引用
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

hash冲突

轻量级map桶中存entry，可能出现hash冲突。

开放寻址法/线性探测法：从冲突位置往后找到一个空闲位置存入

应用

• spring中，只有无状态的bean可以在多线程下共享，大部分bean为单例，部分（requestContextHolder）采用ThreadLocal处理，使有状态bean线程共享，多线程安全
• web应用分多层（服务层，持久层），下层向上层通过接口开放功能调用，接受请求到返回响应所有程序调用属于同一线程

ThreadLocal和synchronized

ThreadLocal	synchronized
空间换时间	时间换空间
每一个线程一个变量副本，独立隔离，互不影响	共享变量，排队访问
java类，共享对象机制	保留字，锁机制
简单 方便 并发性更高