private static final int INITIAL_CAPACITY = 16;

/**

• The table, resized as necessary.
• table.length MUST always be a power of two.
  */
  private Entry[] table;

/**

• The number of entries in the table.
  */
  private int size = 0;

/**

• Construct a new map initially containing (firstKey, firstValue).
• ThreadLocalMaps are constructed lazily, so we only create
• one when we have at least one entry to put in it.
  */
  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;
  setThreshold(INITIAL_CAPACITY);
  }
  .
  .
  }

2.2.3 set(ThreadLocal<?> key, Object value)

• 如果计算的位置已经有内容了，就覆盖，否则就新建一个Entry存放，再判断是否达到阈值，不够就扩容。

/**

• Set the value associated with key.
• @param key the thread local object
• @param value the value to be 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);

for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();

if (k == key) {
e.value = value;
return;
}

if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}

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

2.2.4 setInitialValue()

• 初始化空Entry，因为有的线程ThreadLocal一开始没有存东西，但调用了get方法，这时候没内容，但还是先占个坑，返回null。

/**

• Returns the current thread’s “initial value” for this
• thread-local variable. This method will be invoked the first
• time a thread accesses the variable with the {@link #get}
• method, unless the thread previously invoked the {@link #set}
• method, in which case the {@code initialValue} method will not
• be invoked for the thread. Normally, this method is invoked at
• most once per thread, but it may be invoked again in case of
• subsequent invocations of {@link #remove} followed by {@link #get}.

• This implementation simply returns {@code null}; if the

• programmer desires thread-local variables to have an initial
• value other than {@code null}, {@code ThreadLocal} must be
• subclassed, and this method overridden. Typically, an
• anonymous inner class will be used.
• @return the initial value for this thread-local
  */
  protected T initialValue() {
  return null;
  }

/**

• Variant of set() to establish initialValue. Used instead
• of set() in case user has overridden the set() method.
• @return the initial value
  */
  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;
  }

2.2.5 getEntry(ThreadLocal<?> key)

• 利用hashcode找到对应的Entry，如果一次命中找到最好，但扩容过可能不可以一次命中，就要执行 getEntryAfterMiss 方法找。

/**

• Get the entry associated with key. This method
• itself handles only the fast path: a direct hit of existing
• key. It otherwise relays to getEntryAfterMiss. This is
• designed to maximize performance for direct hits, in part
• by making this method readily inlinable.
• @param key the thread local object
• @return the entry associated with key, or null if no such
  */
  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);
  }

/**

• Version of getEntry method for use when key is not found in
• its direct hash slot.
• @param key the thread local object
• @param i the table index for key’s hash code
• @param e the entry at table[i]
• @return the entry associated with key, or null if no such
  */
  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.2.6 整理扩容

• 阈值threshold，为数组容量的2/3。
• 当满足条件if (!cleanSomeSlots(i, sz) && sz >= threshold)，就是没有删除过，且容量使用了2/3时，先执行**rehash()**就会整理或者扩容。
• 整理完成，如果满足 if (size >= threshold - threshold / 4) 就会触发扩容，扩容2倍。

/**

• Set the resize threshold to maintain at worst a 2/3 load factor.
  */
  private void setThreshold(int len) {
  //数组长度的2/3
  threshold = len * 2 / 3;
  }

/**

• Re-pack and/or re-size the table. First scan the entire
• table removing stale entries. If this doesn’t sufficiently
• shrink the size of the table, double the table size.
  */
  private void rehash() {
  //整理
  expungeStaleEntries();

// Use lower threshold for doubling to avoid hysteresis
if (size >= threshold - threshold / 4)
resize();
}

/**

• Double the capacity of the table.
  */
  private void resize() {
  Entry[] oldTab = table;
  int oldLen = oldTab.length;
  //扩容为原来的2倍
  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;
}

2.3 set(T value)

• 这个方法就是给当前线程的副本赋设置值，我们在使用时直接在线程里直接使用，在这里会自动切换到当前线程Thread.currentThread()。
• 这里有一个**ThreadLocalMap **，我们可以看到将当前线程存进去了。
• 如果map存在就传入this也就是ThreadLocal，还有需要保存的value，否则创建，传入当前线程和value。

/**

• Sets the current thread’s copy of this thread-local variable
• to the specified value. Most subclasses will have no need to
• override this method, relying solely on the {@link #initialValue}
• method to set the values of thread-locals.
• @param value the value to be stored in the current thread’s copy of

•    this thread-local.
  

*/
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}

2.3.1 set(this, value)

• 直接调用 ThreadLocalMap.set 方法，存储或者替换内容。

2.3.2 createMap(Thread t, T firstValue)

• 创建Map就是调用 ThreadLocalMap构造方法 。

/**

• Create the map associated with a ThreadLocal. Overridden in
• InheritableThreadLocal.
• @param t the current thread
• @param firstValue value for the initial entry of the map
  */
  void createMap(Thread t, T firstValue) {
  t.threadLocals = new ThreadLocalMap(this, firstValue);
  自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

最后

只要是程序员，不管是Java还是Android，如果不去阅读源码，只看API文档，那就只是停留于皮毛，这对我们知识体系的建立和完备以及实战技术的提升都是不利的。

真正最能锻炼能力的便是直接去阅读源码，不仅限于阅读各大系统源码，还包括各种优秀的开源库。

腾讯、字节跳动、阿里、百度等BAT大厂 2019-2021面试真题解析

资料太多，全部展示会影响篇幅，暂时就先列举这些部分截图

《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门即可获取！

利的。

真正最能锻炼能力的便是直接去阅读源码，不仅限于阅读各大系统源码，还包括各种优秀的开源库。

[外链图片转存中…(img-cnz20Tfa-1712157834221)]

腾讯、字节跳动、阿里、百度等BAT大厂 2019-2021面试真题解析

[外链图片转存中…(img-qVr31vDD-1712157834221)]

资料太多，全部展示会影响篇幅，暂时就先列举这些部分截图

《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门即可获取！