從獲取用戶信息來(lái)看ThreadLocal做了些什么

 public static HttpServletRequest getRequest() {    RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();    return requestAttributes == null ? null :((ServletRequestAttributes)requestAttributes).getRequest();  }

private static final ThreadLocal<RequestAttributes> requestAttributesHolder = new NamedThreadLocal<>("Request attributes");private static final ThreadLocal<RequestAttributes> inheritableRequestAttributesHolder = new NamedInheritableThreadLocal<>("Request context");/** * Return the RequestAttributes currently bound to the thread. * @return the RequestAttributes currently bound to the thread, * or {@code null} if none bound */@Nullablepublic static RequestAttributes getRequestAttributes() {RequestAttributes attributes = requestAttributesHolder.get();if (attributes == null) {attributes = inheritableRequestAttributesHolder.get();}return attributes;}

public class Thread implements Runnable {
   ThreadLocal.ThreadLocalMap threadLocals = null;
   ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;  }

public T get() {   //獲取當(dāng)前線程       Thread t = Thread.currentThread();   //從當(dāng)前線程中獲取線程變量ThreadLocalMap       ThreadLocalMap map = getMap(t);       if (map != null) {           //從map中根據(jù)key(也就是當(dāng)前ThreadLocal對(duì)象)獲取其對(duì)應(yīng)的Entry節(jié)點(diǎn)           ThreadLocalMap.Entry e = map.getEntry(this);           if (e != null) {               @SuppressWarnings("unchecked")               T result = (T)e.value;               return result;          }      }   //初始化當(dāng)前線程的ThredLocalMap或者當(dāng)前ThreadLocal對(duì)應(yīng)的屬性值   //這個(gè)方法和set()方法類似，但是這個(gè)方法的默認(rèn)value值是null       return setInitialValue();}
/***set()方法和setInitialValue()類似，但是set()方法是去設(shè)置ThreadLocal對(duì)應(yīng)的值*如果當(dāng)前線程的ThreadLocalMap為null，將會(huì)先創(chuàng)建map再設(shè)置第一個(gè)值*/public void set(T value) {       Thread t = Thread.currentThread();       ThreadLocalMap map = getMap(t);       if (map != null)           map.set(this, value);       else           createMap(t, value);}

static class ThreadLocalMap {
       /**        * 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<ThreadLocal<?>> {           /** The value associated with this ThreadLocal. */           Object value;
           Entry(ThreadLocal<?> k, Object v) {               super(k);               value = v;          }      }
       /**        * The initial capacity -- MUST be a power of two.        */       private static final int INITIAL_CAPACITY = 16;
       /**        * The table, resized as necessary.        * table.length MUST always be a power of two.        */       private Entry[] table;

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

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

}