美团面试：说一下 ThreadLocal 的原理？网友：现在面试不看源码不行

/** 
* This class provides thread-local variables. These variables differ from 
* their normal counterparts in that each thread that accesses one (via its 
* {@code get} or {@code set} method) has its own, independently initialized 
* copy of the variable. {@code ThreadLocal} instances are typically private 
* static fields in classes that wish to associate state with a thread (e.g., 
* a user ID or Transaction ID). 
*/

/* ThreadLocal values pertaining to this thread. This map is maintained 
* by the ThreadLocal class. */  
ThreadLocal.ThreadLocalMap threadLocals = null;

public void set(T value) { 
    Thread t = Thread.currentThread(); 
    ThreadLocalMap map = getMap(t); 
    if (map != null) 
      map.set(this, value); 
    else           
      createMap(t, value); 
  }
  //getMap方法
  ThreadLocalMap getMap(Thread t) { 
    //thred中维护了一个ThreadLocalMap 
    return t.threadLocals; 
  }
//createMapvoid 
createMap(Thread t, T firstValue) { 
//实例化一个新的ThreadLocalMap，并赋值给线程的成员变量threadLocals 
  t.threadLocals = new ThreadLocalMap(this, firstValue);
}

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

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(); 
            //如果存在key则覆盖 
              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(); 
          }

private final int threadLocalHashCode = nextHashCode(); 
 /** 
    * The next hash code to be given out. Updated atomically. Starts at 
    * zero. 
   */    
    private static AtomicInteger nextHashCode = new AtomicInteger();
 /** 
 * 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;
    /** 
    * Returns the next hash code. 
    */   
    private static int nextHashCode() { 
      return nextHashCode.getAndAdd(HASH_INCREMENT); 
    }

public T get() { 
    Thread t = Thread.currentThread(); 
    ThreadLocalMap map = getMap(t); 
    if (map != null) { 
      ThreadLocalMap.Entry e = map.getEntry(this); 
      if (e != null) { 
      @SuppressWarnings("unchecked") 
      T result = (T)e.value; 
      return result; 
      } 
     } 
      return setInitialValue(); 
    }

/** 
* Remove the entry for key. 
*/   
private void remove(ThreadLocal<?> key) { 
  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)]) {
      if (e.get() == key) { 
        e.clear(); 
        expungeStaleEntry(i); 
        return; 
        } 
      } 
    }

import java.util.concurrent.atomic.AtomicInteger;
/** 
* <h3>Exper1</h3> 
* <p>ThreadLocalId</p>
**/  
public class ThreadLocalId {
  // Atomic integer containing the next thread ID to be assigned 
  private static final AtomicInteger nextId = new AtomicInteger(0);
 // Thread local variable containing each thread's ID 
   private static final ThreadLocal <Integer> threadId = new ThreadLocal<Integer>() 
   { 
   @Override            
   protected Integer initialValue() { 
   return nextId.getAndIncrement(); 
   } 
   };
  // Returns the current thread's unique ID, assigning it if necessary 
    public static int get() { 
      return threadId.get(); 
    } 
    public static void remove() { 
      threadId.remove(); 
    } 
  }
/** 
* <h3>Exper1</h3> 
* <p></p>
**/
public class ThreadLocalMain { 
      private static void incrementSameThreadId(){ 
          try{ 
            for(int i=0;i<5;i++){ 
                System.out.println(Thread.currentThread() 
                +"_"+i+",threadId:"+ 
                ThreadLocalId.get()); 
              } 
          }finally { 
            ThreadLocalId.remove(); 
          } 
      }
      public static void main(String[] args) { 
        incrementSameThreadId(); 
        new Thread(new Runnable() { 
          @Override      
          public void run() { 
            incrementSameThreadId(); 
          } 
        }).start(); 
        new Thread(new Runnable() { 
          @Override   
          public void run() { 
            incrementSameThreadId(); 
          } 
        }).start(); 
      }
  }