Java線程變量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));
}

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

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

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

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

//如果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;
}

//如果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;
    }
};