你还不知道ThreadLocal线程本地存储吗

ThreadLocal线程本地存储

当访问共享数据时，通常需要使用同步来控制并发程序的访问。那么有没有别的方法来解决呢？当然有，那就是使得共享数据不共享了，ThreadLocal就实现了该操作。该类提供了线程局部变量，为每一个线程创建一个单独的变量副本，使得每个线程都可以独立的改变自己所拥有的变量副本，而不会影响其他线程所对应的副本，消除了竞争条件。

采用的以空间换时间的做法，在每个Thread里维护一个以开地址法实现的ThreadLocal.ThreadLocalMap，把数据隔离
线程本地存储根除了对变量的共享，每当线程访问threadLocals变量时，访问的都是各自线程自己的threadLocals变量。

public class ThreadLocalVariableHolder {
    private static ThreadLocal<Integer> myThreadLocal = new ThreadLocal<Integer>() {
        // 初始值默认为null 设置初始值为0
        protected Integer initialValue() {
            return 0;
        }
    };

    public static void increment() {
        myThreadLocal.set(myThreadLocal.get() + 1);
    }

    public static int get(){
        return myThreadLocal.get();
    }

    public static void main(String[] args) {
        // 线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        for(int i=0;i<3;i++){
            executorService.execute(new MyThread());
        }
        executorService.shutdown();
    }
}

public class MyThread implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            ThreadLocalVariableHolder.increment();
            System.out.println(Thread.currentThread().getName() + ":" + ThreadLocalVariableHolder.get());
            Thread.yield();
        }
    }
}

输出结果

pool-1-thread-1:1
pool-1-thread-2:1
pool-1-thread-3:1
pool-1-thread-1:2
pool-1-thread-2:2
pool-1-thread-3:2
pool-1-thread-1:3
pool-1-thread-2:3
pool-1-thread-3:3

可以看到ThreadLocal把不同线程的数据进行了隔离，互不影响

来看一下ThreadLocal是如何实现的吧

Thread类

// 线程的本地变量存储在线程的threadLocals变量中，并不是存储在ThreadLocal实例中
// 每一个线程都有一个自己的ThreadLocalMap，ThreadLocalMap类似于Map，key为ThreadLocal对象，value为存储的值，所以一个ThreadLocalMap可以存储多个ThreadLocal

ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

ThreadLocal源码逻辑

ThreadLocal对象通过Thread.currentThread()获取当前Thread对象
当前Thread获取对象内部持有的ThreadLocalMap容器
从ThreadLocalMap容器中用ThreadLocal对象作为key，操作当前Thread中的变量副本

提供了四个方法：

get() 返回此线程局部变量的当前线程副本中的值

public T get() {
   // 获取当前线程
    Thread t = Thread.currentThread();
   // 获取当前线程实例的threadLocals
    ThreadLocalMap map = getMap(t);
   // 不为空
    if (map != null) {
       // 根据当前的ThreadLocal对象引用来取值
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
   // 为空则设置key为当前的ThreadLocal对象，value为initialValue设置的初始值
    return setInitialValue();
}

initialValue() 返回此线程局部变量当前线程的初始值，当线程第一次调用get()或set()方法时调用，并且只调用一次
remove() 移除此线程局部变量当前线程的值

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

set(T value) 将此线程局部变量的当前线程副本中的值设置为指定值

public void set(T value) {
  // 获取当前线程
  Thread t = Thread.currentThread();
  // 获取该线程实例对象的threadLocals变量   getMap方法 return t.threadLocals;
  ThreadLocalMap map = getMap(t);
  // 不为空，key为当前的ThreadLocal对象引用，value为所存储的值
  if (map != null)
    map.set(this, value);
  else
    // 为空，则为threadLocals实例化对象
    createMap(t, value);
}

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

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

还有一个静态内部类 ThreadLocalMap 提供了一种用键值对方式存储每一个线程的变量副本的方法，key为当前的ThreadLocal对象，value为对象线程的变量副本

public class MyThread implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            ThreadLocalVariableHolder.increment();
            System.out.println(Thread.currentThread().getName() + ":" + ThreadLocalVariableHolder.get());
            Thread.yield();
        }
    }
}

public class ThreadLocalVariableHolder {
    private static ThreadLocal<Integer> myThreadLocal = new ThreadLocal<Integer>() {
        // 初始值默认为null 设置初始值为0
        protected Integer initialValue() {
            return 0;
        }
    };

    public static void increment() {
        myThreadLocal.set(myThreadLocal.get() + 1);
    }

    public static int get(){
        return myThreadLocal.get();
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for(int i=0;i<5;i++){
            executorService.execute(new MyThread());
        }
        executorService.shutdown();
    }
}

执行结果

pool-1-thread-1:1
pool-1-thread-2:1
pool-1-thread-3:1
pool-1-thread-3:2
pool-1-thread-2:2
pool-1-thread-1:2
pool-1-thread-2:3
pool-1-thread-3:3
pool-1-thread-4:1
pool-1-thread-1:3
pool-1-thread-4:2
pool-1-thread-4:3
pool-1-thread-5:1
pool-1-thread-5:2
pool-1-thread-5:3

存在内存泄露问题，每次使用完ThreadLocal，都调用它的remove()方法，清除数据

ThreadLocalMap源码逻辑

作为数据真正存储的位置，ThreadLocalMap对于ThreadLocal还是相当重要的

// 初始容量，该容量必须是2的次幂
private static final int INITIAL_CAPACITY = 16;
// 存储数据的Entry数组
private Entry[] table;
// entry的数量
private int size = 0;
// 阈值
private int threshold; 

// Entry中key为ThreadLocal，value为值
// key是一个弱引用
// 每个线程在往ThreadLocal中放值的时候，都是放入线程本身的ThreadLocalMap中，key是ThreadLocal，从而实现了线程隔离
// 只要发生了垃圾回收，且该对象没有强引用存在的话，弱引用就会被回收
static class Entry extends WeakReference<ThreadLocal<?>> {
  /** The value associated with this ThreadLocal. */
  Object value;

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

构造函数

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
  // 初始化
    table = new Entry[INITIAL_CAPACITY];
  // 使用key的哈希值与上15 计算数组下标
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
  // 初始化该节点
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
  // 设置阈值
    setThreshold(INITIAL_CAPACITY);
}

重要方法

set方法

存储数据

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);
// 如果出现hash冲突，会采用线性探测，如果当前位置有值，则会获取下一个索引来进行存储，该结构是一个环形
  // 直到找到空闲位置为止
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) { // 槽位不为空，进行线性探测
        ThreadLocal<?> k = e.get();
   // key值与当前key值相等，直接进行覆盖
        if (k == key) {
            e.value = value;
            return;
        }
   // Entry不为null，但是key为null，当前位置的key已经为null(失效了)，则进行替换过期数据
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
      // 该循环完成，说明既没有找到原本存储key的位置，也没有找到失效的位置
    }
// 执行到这里说明查找到了entry为null的位置
    tab[i] = new Entry(key, value);
    int sz = ++size;
  // 没有清除掉失效的槽位，并且当前数量已经达到了阈值，则进行扩容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

// 获取下一个数组下标位置
 private static int nextIndex(int i, int len) {
   return ((i + 1 < len) ? i + 1 : 0);
 }

// 替换掉失效的值  staleSlot为失效的槽位
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                       int staleSlot) {
  Entry[] tab = table;
  int len = tab.length;
  Entry e;

  // Back up to check for prior stale entry in current run.
  // We clean out whole runs at a time to avoid continual
  // incremental rehashing due to garbage collector freeing
  // up refs in bunches (i.e., whenever the collector runs).
  int slotToExpunge = staleSlot;
  // 向前扫描，直到找到无效的槽位
  for (int i = prevIndex(staleSlot, len);
       (e = tab[i]) != null;
       i = prevIndex(i, len))
    // 找到无效的槽位，slotToExpunge复为当前位置
    if (e.get() == null)
      slotToExpunge = i;

  // Find either the key or trailing null slot of run, whichever
  // occurs first
  // 向后扫描，找到失效的槽位
  for (int i = nextIndex(staleSlot, len);
       (e = tab[i]) != null;
       i = nextIndex(i, len)) {
    ThreadLocal<?> k = e.get();

    // If we find key, then we need to swap it
    // with the stale entry to maintain hash table order.
    // The newly stale slot, or any other stale slot
    // encountered above it, can then be sent to expungeStaleEntry
    // to remove or rehash all of the other entries in run.
    // 找到key，替换掉无效的槽位中的值
    if (k == key) {
      e.value = value;

      tab[i] = tab[staleSlot];
      tab[staleSlot] = e;

      // Start expunge at preceding stale entry if it exists
      // 向前扫描时没有找到无效的槽位，将slotToExpunge设为当前位置
      if (slotToExpunge == staleSlot)
        slotToExpunge = i;
      // 从slotToExpunge开始清理槽位
      cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
      return;
    }

    // If we didn't find stale entry on backward scan, the
    // first stale entry seen while scanning for key is the
    // first still present in the run.
    // 如果当前的槽位已经无效，并且向前扫描时没有找到无效的槽位，将slotToExpunge设为当前位置
    if (k == null && slotToExpunge == staleSlot)
      slotToExpunge = i;
  }

  // 没有找到对应的key新增加一个entry
  // If key not found, put new entry in stale slot
  tab[staleSlot].value = null;
  tab[staleSlot] = new Entry(key, value);

  // If there are any other stale entries in run, expunge them
  // 扫描过程中存在无效的槽位，进行清理
  if (slotToExpunge != staleSlot)
    cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

// 清理无效的槽位
private boolean cleanSomeSlots(int i, int n) {
  boolean removed = false;
  Entry[] tab = table;
  int len = tab.length;
  do {
    i = nextIndex(i, len);
    Entry e = tab[i];
    // key已失效
    if (e != null && e.get() == null) {
      n = len;
      removed = true;
      i = expungeStaleEntry(i);
    }
  } while ( (n >>>= 1) != 0);
  return removed;
}

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

  // expunge entry at staleSlot
  // 去掉对value的引用
  tab[staleSlot].value = null;
  tab[staleSlot] = null;
  size--;

  // Rehash until we encounter null
  Entry e;
  int i;
  for (i = nextIndex(staleSlot, len);
       (e = tab[i]) != null;
       i = nextIndex(i, len)) {
    ThreadLocal<?> k = e.get();
    // key为null，去掉对value的引用
    if (k == null) {
      e.value = null;
      tab[i] = null;
      size--;
    } else {
      int h = k.threadLocalHashCode & (len - 1);
      if (h != i) {
        tab[i] = null;

        // Unlike Knuth 6.4 Algorithm R, we must scan until
        // null because multiple entries could have been stale.
        while (tab[h] != null)
          h = nextIndex(h, len);
        tab[h] = e;
      }
    }
  }
  return i;
}

// 进行扩容操作
private void rehash() {
  expungeStaleEntries();

  // Use lower threshold for doubling to avoid hysteresis
  if (size >= threshold - threshold / 4)
    resize();
}
// 扩容扩大2倍
private void resize() {
  Entry[] oldTab = table;
  int oldLen = oldTab.length;
  int newLen = oldLen * 2;
  Entry[] newTab = new Entry[newLen];
  int count = 0;

  for (int j = 0; j < oldLen; ++j) {
    Entry e = oldTab[j];
    if (e != null) {
      ThreadLocal<?> k = e.get();
      if (k == null) {
        e.value = null; // Help the GC
      } else {
        int h = k.threadLocalHashCode & (newLen - 1);
        while (newTab[h] != null)
          h = nextIndex(h, newLen);
        newTab[h] = e;
        count++;
      }
    }
  }

  setThreshold(newLen);
  size = count;
  table = newTab;
}

getEntry方法

获取Entry值

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
      // 没有命中
      // 在存放数据的时候采用的是开方定址法，所以可能存在当前key的散列值和元素所在索引并不完全对应的情况
        return getEntryAfterMiss(key, i, e);
}

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) // key等于null，说明该key已经失效了，进行回收，可以有效的避免内存泄漏
      expungeStaleEntry(i);
    else
      i = nextIndex(i, len);
    e = tab[i];
  }
  return null;
}

remove方法

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)]) {
      // 找到对应的key
        if (e.get() == key) {
          // 清除对ThreadLocal的弱引用
            e.clear();
          // 清理key为null的元素
            expungeStaleEntry(i);
            return;
        }
    }
}

InheritableThreadLocal类解决ThreadLocal继承性问题

InheritableThreadLocal是ThreadLocal的子类，该类提供了一个特性，可以让子线程访问在父线程中设置的本地变量

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    
    protected T childValue(T parentValue) {
        return parentValue;
    }

    // 获取ThreadLocalMap时获取的是该线程中的inheritableThreadLocals变量
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }

    // 创建ThreadLocalMap时，使用的是inheritableThreadLocals变量而不是threadLocals变量
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

如果一个线程是从其他某个线程中创建的，这个类将提供继承的值，如果一个线程A在线程局部变量中已有值，那么当线程A创建其他某个线程B时，线程B的线程局部变量将跟线程A是一样的，可以重写childValue()方法，该方法用来初始化子线程在线程局部变量中的值，使用父线程在线程局部变量中的值作为传入参数

// Thread实例化时的初始化过程
private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize, AccessControlContext acc,
                  boolean inheritThreadLocals) {
    // 省略无关代码
  
   // 当前线程
    Thread parent = currentThread();
    
    // inheritThreadLocals为true 且 父线程的inheritableThreadLocals不为null
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
       // 则设置子线程的inheritableThreadLocals，值为父线程的inheritableThreadLocals的值复制而来
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    
}

javaweb中就是使用这种方式来使得子线程可以获取请求信息的

RequestContextHolder.setRequestAttributes(requestAttributes,true);

内存泄漏问题

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

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

你还不知道ThreadLocal线程本地存储吗 — ThreadLocal内存泄漏

在ThreadLocal.ThreadLocalMap中的key为ThreadLocal对象实例，这个Map中的key是一个弱引用，当把ThreadLocal对象实例置为null后，没有任何强引用指向ThreadLocal对象实例，所以ThreadLocal对象实例会被gc回收，但是Map中的value却不会被回收(此时entry是一个key为null，但是value不为null)，因为存在一条从当前thread连接过来的强引用，只有当前thread结束之后，当前thread的强引用才会断开，此时Map中的value才会被gc回收。

但是在使用线程池的时候，由于线程是重复利用的，不会被回收，所以就可能出现内存泄漏