0x61c88647的特点

这个数是Integer有符号整数的0.618倍，既黄金比例，斐波拉契数列。使用这个比例，可以使key在数组上被更均匀的分散。

首先来看一个例子：

    private static final int HASH_INCREMENT = 0x61c88647;

    public static void main(String[] args) {
        magicHash(16);
        magicHash(32);
    }

    private static void magicHash(int size) {
        int hashCode = 0;
        for (int i = 0; i < size; i++, hashCode = i * HASH_INCREMENT + HASH_INCREMENT) {
            System.out.print((hashCode & (size - 1)) + " ");
        }
        System.out.println("\n");
    }

输出结果：

使用这个来累加获取到的数组下标，他的数据分布是均匀的，也就是说，当我从任意位置开始检索某一个值的时候，概率上是一样的。

0x61c88647 是 Java 中 ThreadLocal 相关的一个魔数（Magic Number） ，它是 ThreadLocal 用于计算哈希值的一个常量，目的是减少哈希冲突，优化 ThreadLocal 在 Thread 内部的 ThreadLocalMap 中的存储分布。

private final int threadLocalHashCode = nextHashCode();

private static AtomicInteger nextHashCode = new AtomicInteger();

// 哈希值增量，即魔数 0x61c88647
private static final int HASH_INCREMENT = 0x61c88647;

private static int nextHashCode() {
    // 每次创建 ThreadLocal 实例时，哈希值累加 HASH_INCREMENT
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

0x61c88647 是 HASH_INCREMENT 的值，它是一个黄金比例相关的质数（接近 2³² × (√5-1)/2，约等于 2654435769）。
每次创建 ThreadLocal 实例时，其 threadLocalHashCode 会在上一个实例的基础上累加 0x61c88647。
这种哈希值生成方式能保证不同 ThreadLocal 实例的哈希值在 ThreadLocalMap 中分布更均匀，减少哈希冲突（因为 ThreadLocalMap 采用开放地址法解决冲突，均匀分布能提升效率）。

为什么选择 0x61c88647？

这个魔数的设计基于斐波那契散列法（Fibonacci Hashing），其核心优势是：

当哈希表容量为 2ⁿ 时（ThreadLocalMap 初始容量为 16，扩容后仍为 2ⁿ），使用该增量生成的哈希值能均匀分布在哈希表的每个槽位，最大限度减少冲突。
相比普通的增量（如 1），能避免哈希值集中在某些区域，提升 ThreadLocalMap 的存取效率。

ThreadLocal源码解析

ThreadLocal实际上一种线程隔离机制，也是为了保证在多线程环境下对于共享变量的访问的安全性。如以下demo

public class ThreadLocalDemo {

    static ThreadLocal local=new ThreadLocal(){
        protected Integer initialValue(){
        return 0; //初始化一个值
    }
};

    public static void main(String[] args) {
        Thread[] thread=new Thread[5];
        for (int i=0;i<5;i++){
            thread[i]=new Thread(()->{
                int num=local.get(); //获得的值都是0
                local.set(num+=5); //设置到local中
                System.out.println(Thread.currentThread().getName()+""-""+num);
            });
        }
        for (int i = 0; i < 5; i++) {
            thread[i].start();
        }
    }
}

结果如下：

说明ThreadLocal的对象，在每一个线程中都是单独存在，互不干扰。说明它是线程隔离的。

线程隔离

那么ThreadLocal是如何做到线程隔离机制的，我们直接来看源码：

protected T initialValue() 设置并返回当前线程变量的一个初始值
set(T value) 将信息 value 放到当前线程的 thread-local 变量中
T get() 获取set(T value)设置的值, 如果没有则返回初始值
remove() 移除线程中的这个 thread-local 变量

set()方法

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

看注释可以知道，当前线程set的其实是这个ThreadLocal变量的副本，所以每个线程访问的是自己内部的副本变量以达到线程隔离的效果。

set()方法首先会获取到当前线程，然后从这个线程获取ThreadLocalMap，这个集合是存放在Thread类中的，而不是ThreadLocal类中：

/* ThreadLocal values pertaining to this thread. This map is maintained

- by the ThreadLocal class. */
  ThreadLocal.ThreadLocalMap threadLocals = null;

注释：(存放)与此线程相关的ThreadLocal值，这个map由ThreadLocal类维护。

所以这个ThreadLocalMap就是存放每条线程的ThreadLocal的副本。

ThreadLocalMap

在 Java 中，每个 Thread 内部维护了一个 ThreadLocalMap（类似 HashMap 的哈希表），用于存储该线程的 ThreadLocal 变量及其对应的值。ThreadLocalMap 的键是 ThreadLocal 实例本身，值是线程私有变量。

/**

- The entries in this hash map extend WeakReference, using
- its main ref field as the key (which is always a
- ThreadLocal object).  Note that null keys (i.e. entry.get()
- == null) mean that the key is no longer referenced, so the
- entry can be expunged from table.  Such entries are referred to
- as ""stale entries"" in the code that follows.
   */static class Entry extends WeakReference&gt; {/* * The value associated with this ThreadLocal. */
  Object value;

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

注释：这个Entry继承了弱引用，使用ThreadLocal对象作为key，当key==null时，意味着不再引用该键，因此可以从Entry中删除该项。被删除的数据在后文被称作“stale entries”即不干净的Entry（后面有一个replaceStaleEntry()方法替换掉“stale entries”）。

所以ThreadLocalMap其实是通过Entry来存放数据的，并且它和ThreadLocal是WeakReference弱引用关系（清理key==null的数据）。

弱引用：当一个对象仅仅被weak reference（弱引用）指向, 而没有任何其他strong reference（强引用）指向的时候, 如果这时GC运行, 那么这个对象就会被回收，不论当前的内存空间是否足够，这个对象都会被回收。

ThreadLocalMap为空时

继续看如何创建ThreadLocalMap，当从当前线程获取到的map为空时，会创建一个ThreadLocalMap，并将这个ThreadLocal实例和设置的值存入这个map：

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

进入new ThreadLocalMap(this, firstValue)构造方法：

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

注释：创建一个初始值包含threadLocal和firstValue值的map，ThreadLocalMaps是延时构造的，所以在至少有一个entry的时候才会创建。

看代码：table = new Entry[INITIAL_CAPACITY];首先来看这个table：

/**

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

是ThreadLocalMap的一个属性，一个Entry[] 数组，可扩容，长度必须是2的幂。而new Entry[INITIAL_CAPACITY]则是对其的初始化，INITIAL_CAPACITY是其初始化长度16。

int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);：这里是为了产生table[]数组的下标，首先来看threadLocalHashCode 属性：

private final int threadLocalHashCode = nextHashCode();

为了计算 ThreadLocal 在 ThreadLocalMap 中的存储位置（哈希索引），ThreadLocal 使用了以下哈希计算逻辑（以 JDK 8 为例）：

继续：

/**

 - Returns the next hash code.
  */
  private static int nextHashCode() {
  return nextHashCode.getAndAdd(HASH_INCREMENT);
  }

先来看nextHashCode：

/**

- The next hash code to be given out. Updated atomically. Starts at
- zero.
  */
  private static AtomicInteger nextHashCode =
  new AtomicInteger();

注释说明了这个属性是下一个要给出的hashCode（更新这个属性是原子性的，且从零开始）。

再来看nextHashCode.getAndAdd(HASH_INCREMENT);：表示下一个要给出的hashCode的按HASH_INCREMENT的值累加上去的，此处我们找到了这个神奇的0x61c88647：

/**

- The difference between successively generated hash codes - turns
- implicit sequential thread-local IDs into near-optimally spread
- multiplicative hash values for power-of-two-sized tables.
  */
  private static final int HASH_INCREMENT = 0x61c88647;

综上所述：创建ThreadLocalMap时，会将ThreadLocal和value存放入一个Entry（就是前文弱引用的那个），并将这个Entry放入一个Entry[]数组中，下标的值按累加0x61c88647的值与上(INITIAL_CAPACITY - 1)获取到。而后续，当线程每次set一个值，都会将ThreadLocal和value存放入一个Entry，并按类似的方法计算下标值。

ThreadLocalMap不为空时

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