ThreadLocal_threadlocal<boolean>-CSDN博客

本文链接：https://blog.csdn.net/sinat_28502161/article/details/109397116

文章目录

ThreadLocal

ThreadLocal

简介

ThreadLocal是一个线程内部的线程存储类，通过它可以在指定的线程存储数据，并且存储过后只能在存储的指定的线程获取它的值，其他线程无法获取它的值。每一个线程只能获取自己存储的值。

用法：

ThreadLocal<Boolean> threadLocal = new ThreadLocal<>();//ThreadLocal对象
threadLocal.set(false);//存储内容
Boolean aBoolean = threadLocal.get();//获取内容

实例：

public class ThreadLocalTest {
    public static void main(String[] args) {
        ThreadLocal<Boolean> threadLocal = new ThreadLocal<>();
        threadLocal.set(false);//存数据
        printCurrentThread(threadLocal.get());
      
        new Thread(new Runnable() {
            @Override
            public void run() {
                threadLocal.set(true);//存数据
                printCurrentThread(threadLocal.get());
            }
        }, "test1").start();//线程test1
      
        new Thread(new Runnable() {
            @Override
            public void run() {
                threadLocal.set(true);//存数据
                printCurrentThread(threadLocal.get());
            }
        }, "test2").start();//线程test2
    }

    private static void printCurrentThread(boolean b) {
        System.out.println(Thread.currentThread().getName() + ":\t" + b);//打印出线程名与传的boolean值
    }
}

结果：

main:	false
test1:	true
test2:	true

源码

ThreadLocal做为数据存储类，那么关键点在于set与get方法。

ThreadLocal #set

public void set(T value) {
  Thread t = Thread.currentThread();//获取当前线程
  ThreadLocalMap map = getMap(t);//获取线程的ThreadLocalMap
  if (map != null)
    map.set(this, value);//给map设置值，键为当前的ThreadLocal，值为传入的value
  else
    createMap(t, value);
}

/**
* getMap方法
*/
ThreadLocalMap getMap(Thread t) {
  return t.threadLocals;//返回传入的线程的ThreadLocalMap
}

/**
* createMap方法
*/
void createMap(Thread t, T firstValue) {
  t.threadLocals = new ThreadLocalMap(this, firstValue);//创建新的ThreadLocalMap并将值传入将线程的threadLocals设置为这个ThreadLocalMap
}

ThreadLocal #get

public T get() {
  Thread t = Thread.currentThread();//获取当前线程
  ThreadLocalMap map = getMap(t);//获取当前线程的map
  if (map != null) {//如果map不为空
    ThreadLocalMap.Entry e = map.getEntry(this);//获取Entry
    if (e != null) {//Entry不为空
      @SuppressWarnings("unchecked")
      T result = (T)e.value;//获取Entry的值
      return result;//返回获取的值
    }
  }
  return setInitialValue();
}

/**
* setInitialValue方法
*/
private T setInitialValue() {
  T value = initialValue();//初始值
  Thread t = Thread.currentThread();//获取当前线程
  ThreadLocalMap map = getMap(t);//获取当前线程的map
  if (map != null)//map不为空设置默认的值，也就是null
    map.set(this, value);
  else
    createMap(t, value);//map为空新建一个map在存储默认的值
  return value;//返回默认值
}
/**
* initialValue方法
*/
protected T initialValue() {
  return null;
}

分析：在调用set方法时获取当前线程，通过获取当前线程的ThreadLocalMap，在map不为空的时候将值存储进去，如果map为空那么新建一个ThreadLocalMap并设置给Thread后存储传入的数据。

通过这部分源码可以看出为什么ThreadLocal只能操作自己线程里的数据，因为这里跟它线程的ThreadLocalMap有关系，再来分析ThreadLocalMap

ThreadLocalMap

//存储数据的结构，并且是弱引用
static class Entry extends WeakReference<ThreadLocal<?>> {
  /** 与ThreadLocal关联的值 */
  Object value;

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

//table的初始容量，必须是2的幂
private static final int INITIAL_CAPACITY = 16;

//table用于存储数据，长度必须是2的幂
private Entry[] table;

//table中存在的数据的条目数
private int size = 0;

//阀值，用于扩容
private int threshold; // Default to 0

//阀值设置为当前传入的值的2/3倍
private void setThreshold(int len) {
  threshold = len * 2 / 3;
}

//下一个值
private static int nextIndex(int i, int len) {
  return ((i + 1 < len) ? i + 1 : 0);
}

//上一个值
private static int prevIndex(int i, int len) {
  return ((i - 1 >= 0) ? i - 1 : len - 1);
}

//构造函数
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;//数组里面的数据条目数量设置为1
  setThreshold(INITIAL_CAPACITY);//这是阀值
}

ThreadLocalMap #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;
  //根据threadLocalHashCode进行一个位运算（取模）得到索引i
  int i = key.threadLocalHashCode & (len-1);
 
  for (Entry e = tab[i];
       e != null;
       e = tab[i = nextIndex(i, len)]) {
    ThreadLocal<?> k = e.get();//获取当前下标Entry的值
    //如果获取的ThreadLocal相同直接替换e的值 *1*
    if (k == key) {
      e.value = value;
      return;
    }
    //如果Entry key对应的k为为null那么清空所有key为null的数据 *2*
    if (k == null) {
      replaceStaleEntry(key, value, i);
      return;
    }
  }
  //如果上述都不满足，直接添加 *3*
  tab[i] = new Entry(key, value);
  int sz = ++size;
  if (!cleanSomeSlots(i, sz) && sz >= threshold)
    rehash();
}
//哈希值
private final int threadLocalHashCode = nextHashCode();

private static final int HASH_INCREMENT = 0x61c88647;
//返回下一个哈希值
private static int nextHashCode() {
  return nextHashCode.getAndAdd(HASH_INCREMENT);
}

根据threadLocalHashCode进行一个位运算（取模）得到索引i：

值	余数(索引i)
0x61c88647	7
0xc3910c8e	14
0x255992d5	5
0x8722191c	12
上一值+0x61c88647	…
…	…

总结如下：

对于某一ThreadLocal来讲，他的索引值i是确定的，在不同线程之间访问时访问的是不同的table数组的同一位置即都为table[i]，只不过这个不同线程之间的table是独立的。
对于同一线程的不同ThreadLocal来讲，这些ThreadLocal实例共享一个table数组，然后每个ThreadLocal实例在table中的索引i是不同的。

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);
}

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;
}

ThreadLocal#remove

public void remove() {
  ThreadLocalMap m = getMap(Thread.currentThread());//获取当前线程的ThreadLocalMap
  if (m != null)//如果ThreadLocalMap不为空
    m.remove(this);//调用ThreadLocalMap的remove方法
}

/**
* ThreadLocalMap#remove
*/
private void remove(ThreadLocal<?> key) {
  Entry[] tab = table;
  int len = tab.length;//table的长度
  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();
      expungeStaleEntry(i);
      return;
    }
  }
}

/**
* ThreadLocalMap.Entry#clear
*/
public void clear() {
  this.referent = null;//值设置为null
}

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

  // expunge entry at staleSlot
  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();
    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;
}

ThreadLocal特性

ThreadLocal和Synchronized都是为了解决多线程中相同变量的访问冲突问题，不同的点是

Synchronized是通过线程等待，牺牲时间来解决访问冲突
ThreadLocal是通过每个线程单独一份存储空间，牺牲空间来解决冲突，并且相比于Synchronized，ThreadLocal具有线程隔离的效果，只有在线程内才能获取到对应的值，线程外则不能访问到想要的值。

正因为ThreadLocal的线程隔离特性，使他的应用场景相对来说更为特殊一些。在android中Looper、ActivityThread以及AMS中都用到了ThreadLocal。当某些数据是以线程为作用域并且不同线程具有不同的数据副本的时候，就可以考虑采用ThreadLocal。

总结

每个Thread维护一份ThreadLocalMap的引用，在threadLocals为空时调用set或get方法会创建ThreadLocalMap并将引用指向Thread的threadLocals
ThreadLocalMap是ThreadLocal的静态内部类使用Entry存储数据
使用ThreadLocal存储的数据是存储在线程自己的threadLocals中，即线程自己的ThreadLocalMap中
ThreadLocalMap的键为ThreadLocal，一个线程可以有多个ThreadLocal来存储数据所以以Map键值对形式存储数据
ThreadLocal本身不存储数据，只是作为Thread的ThreadLocalMap中的键来存储数据，以便线程以ThreadLocal为key存储与获取数据