Analyse du code source ThreadLocal de la variable de thread Java

1. Les variables du thread ThreadLocal sont liées au thread actuel et enregistrent uniquement les variables du thread actuel. Elles sont isolées des autres threads et ne peuvent pas accéder aux données à l'intérieur.

2. ThreadLocal est utilisé dans Looper, et un Looper est créé et enregistré dans ThreadLocal.

//这里用到了泛型，ThreadLocal中只保存Looper对象。
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) { //保证Looper只被创建一次。
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    sThreadLocal.set(new Looper(quitAllowed));
}

Regardez comment la méthode sThreadLocal.set() enregistre les données.

Récupérez d'abord le fil de discussion actuel, puis récupérez la variable membre ThreadLocalMap du fil, puis enregistrez-la dans cette carte

key est l'objet ThreadLocal créé et la valeur est. le passé La valeur qui entre.

  public void set(T value) {
        //拿到当前线程
        Thread t = Thread.currentThread();
        //得到一个map
        ThreadLocalMap map = getMap(t);
        if (map != null){
        // 这个map是以当前对象为key的，这个this就是 ThreadLocal的实例 sThreadLocal
            map.set(this, value);
        }else{
            createMap(t, value);
        }
    }

//getMap 是从Thread中拿到了一个threadLocals变量，是ThreadLocal.ThreadLocalMap 的实例。
//保存的数据也是存在了这个map中，这也就是为什么ThreadLocal是和线程绑定的，对其他线程来说是隔离的原因所在。
ThreadLocalMap getMap(Thread t) {
      return t.threadLocals;
}

1) Enregistrez les données si la carte n'est pas vide. Prenez la première branche du jugement if ci-dessus. Cette méthode de stockage est similaire à HashMap

private void set(ThreadLocal<?> key, Object value) {
      Entry[] tab = table;
      int len = tab.length;
      // 计算出key在集合中的索引，index
      int i = key.threadLocalHashCode & (len-1);
       //开始遍历整个数组，
       //取出索引为i的Entry，如果不为空，取出下一个，进行遍历
        for (Entry e = tab[i];
               e != null;
               e = tab[i = nextIndex(i, len)]) {
              ThreadLocal<?> k = e.get();
              //如果取出的k和传进来的key一致，则把新的值存起来。
              if (k == key) {
                  e.value = value;
                  return;
              }
              //直到取出最有一个，k==null则进行存储。
              if (k == null) {
                  replaceStaleEntry(key, value, i);
                  return;
              }
          }
          //如果索引i的位置，没有Entry，则把传进来的key和value保存在这个位置。
          tab[i] = new Entry(key, value);
          int sz = ++size;
          //如果大于阈值了，则进行扩容
          if (!cleanSomeSlots(i, sz) && sz >= threshold)
              rehash();
}

2) Enregistrez les données si la carte est vide. Créez ensuite un ThreadLocalMap et affectez-le au thread actuel t.

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

 ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    //创建一个大小为16的数组
    table = new Entry[INITIAL_CAPACITY];
    //计算得到的i是数组的角标。可以参考hashMap源码分析
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    //赋值，保存数据
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    //扩容的阈值
    setThreshold(INITIAL_CAPACITY);
}

3. Voyons comment ThreadLocal obtient sa valeur.

obtient également le thread actuel t en premier, puis obtient sa variable membre ThreadLocalMap via t.

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    //如果map不为空，则从map中取值
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //如果map为空
    return setInitialValue();
}

1) Si la carte n'est pas vide, récupérez la valeur de la carte.

//如果map不为空
 private Entry getEntry(ThreadLocal<?> key) {
    //拿到key对应的索引
    int i = key.threadLocalHashCode & (table.length - 1);
    //从数组中拿到Entry
    Entry e = table[i];
    if (e != null && e.get() == key){如果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;
}

2) Si la carte obtenue est vide lors de la réception, vous devez l'initialiser à ce moment-là

//如果map为空，则调用这个方法，initialValue由用户去实现。
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;
}

//下面是Choreographer中的例子：
private static final ThreadLocal<Choreographer> sThreadInstance =
        new ThreadLocal<Choreographer>() {
    @Override
    protected Choreographer initialValue() {
        Looper looper = Looper.myLooper();
        if (looper == null) {
            throw new IllegalStateException("The current thread must have a looper!");
        }
        Choreographer choreographer = new Choreographer(looper, VSYNC_SOURCE_APP);
        if (looper == Looper.getMainLooper()) {
            mMainInstance = choreographer;
        }
        return choreographer;
    }
};

ThreadLocalMap est utilisé pour stocker les données ThreadLocal. Cet objet ThreadLocalMap est obtenu à partir du fil de discussion actuel via

et est obtenu à partir du fil de discussion actuel. La conception de ThreadLocalMap réalise l'isolation des données entre différents threads et enregistre uniquement les données du thread correspondant.

L'objet ThreadLocal lui-même est utilisé comme clé pour stocker les données dans ThreadLocalMap. map.set(this, value);

Si vous souhaitez stocker plus de données dans ThreadLocalMap, vous devez créer plusieurs objets.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!