1 package test;
 2 
 3 public class ThreadLocalTest {
 4 
 5     static ThreadLocal<String> localVar = new ThreadLocal<>();
 6 
 7     static void print(String str) {
 8         //打印當(dāng)前線程中本地內(nèi)存中本地變量的值
 9         System.out.println(str + " :" + localVar.get());
10         //清除本地內(nèi)存中的本地變量
11         localVar.remove();
12     }
13 
14     public static void main(String[] args) {
15         Thread t1  = new Thread(new Runnable() {
16             @Override
17             public void run() {
18                 //設(shè)置線程1中本地變量的值
19                 localVar.set("localVar1");
20                 //調(diào)用打印方法
21                 print("thread1");
22                 //打印本地變量
23                 System.out.println("after remove : " + localVar.get());
24             }
25         });
26 
27         Thread t2  = new Thread(new Runnable() {
28             @Override
29             public void run() {
30                 //設(shè)置線程1中本地變量的值
31                 localVar.set("localVar2");
32                 //調(diào)用打印方法
33                 print("thread2");
34                 //打印本地變量
35                 System.out.println("after remove : " + localVar.get());
36             }
37         });
38 
39         t1.start();
40         t2.start();
41     }
42 }

 1 public void set(T value) {
 2     //(1)獲取當(dāng)前線程（調(diào)用者線程）
 3     Thread t = Thread.currentThread();
 4     //(2)以當(dāng)前線程作為key值，去查找對應(yīng)的線程變量，找到對應(yīng)的map
 5     ThreadLocalMap map = getMap(t);
 6     //(3)如果map不為null，就直接添加本地變量，key為當(dāng)前定義的ThreadLocal變量的this引用，值為添加的本地變量值
 7     if (map != null)
 8         map.set(this, value);
 9     //(4)如果map為null，說明首次添加，需要首先創(chuàng)建出對應(yīng)的map
10     else
11         createMap(t, value);
12 }

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals; //獲取線程自己的變量threadLocals，并綁定到當(dāng)前調(diào)用線程的成員變量threadLocals上
}

1 void createMap(Thread t, T firstValue) {
2     t.threadLocals = new ThreadLocalMap(this, firstValue);
3 }

1 public T get() {
 2     //(1)獲取當(dāng)前線程
 3     Thread t = Thread.currentThread();
 4     //(2)獲取當(dāng)前線程的threadLocals變量
 5     ThreadLocalMap map = getMap(t);
 6     //(3)如果threadLocals變量不為null，就可以在map中查找到本地變量的值
 7     if (map != null) {
 8         ThreadLocalMap.Entry e = map.getEntry(this);
 9         if (e != null) {
10             @SuppressWarnings("unchecked")
11             T result = (T)e.value;
12             return result;
13         }
14     }
15     //(4)執(zhí)行到此處，threadLocals為null，調(diào)用該更改初始化當(dāng)前線程的threadLocals變量
16     return setInitialValue();
17 }
18 
19 private T setInitialValue() {
20     //protected T initialValue() {return null;}
21     T value = initialValue();
22     //獲取當(dāng)前線程
23     Thread t = Thread.currentThread();
24     //以當(dāng)前線程作為key值，去查找對應(yīng)的線程變量，找到對應(yīng)的map
25     ThreadLocalMap map = getMap(t);
26     //如果map不為null，就直接添加本地變量，key為當(dāng)前線程，值為添加的本地變量值
27     if (map != null)
28         map.set(this, value);
29     //如果map為null，說明首次添加，需要首先創(chuàng)建出對應(yīng)的map
30     else
31         createMap(t, value);
32     return value;
33 }

1  public void remove() {
2     //獲取當(dāng)前線程綁定的threadLocals
3      ThreadLocalMap m = getMap(Thread.currentThread());
4      //如果map不為null，就移除當(dāng)前線程中指定ThreadLocal實(shí)例的本地變量
5      if (m != null)
6          m.remove(this);
7  }

 1 package test;
 2 
 3 public class ThreadLocalTest2 {
 4 
 5     //(1)創(chuàng)建ThreadLocal變量
 6     public static ThreadLocal<String> threadLocal = new ThreadLocal<>();
 7 
 8     public static void main(String[] args) {
 9         //在main線程中添加main線程的本地變量
10         threadLocal.set("mainVal");
11         //新創(chuàng)建一個(gè)子線程
12         Thread thread = new Thread(new Runnable() {
13             @Override
14             public void run() {
15                 System.out.println("子線程中的本地變量值:"+threadLocal.get());
16             }
17         });
18         thread.start();
19         //輸出main線程中的本地變量值
20         System.out.println("mainx線程中的本地變量值:"+threadLocal.get());
21     }
22 }

 1 public class InheritableThreadLocal<T> extends ThreadLocal<T> {
 2     
 3     protected T childValue(T parentValue) {
 4         return parentValue;
 5     }
 6 
 7     ThreadLocalMap getMap(Thread t) {
 8        return t.inheritableThreadLocals;
 9     }
10 
11     void createMap(Thread t, T firstValue) {
12         t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
13     }
14 }

 1 private void init(ThreadGroup g, Runnable target, String name,
 2                   long stackSize) {
 3     init(g, target, name, stackSize, null, true);
 4 }
 5 private void init(ThreadGroup g, Runnable target, String name,
 6                   long stackSize, AccessControlContext acc,
 7                   boolean inheritThreadLocals) {
 8     //判斷名字的合法性
 9     if (name == null) {
10         throw new NullPointerException("name cannot be null");
11     }
12 
13     this.name = name;
14     //(1)獲取當(dāng)前線程(父線程)
15     Thread parent = currentThread();
16     //安全校驗(yàn)
17     SecurityManager security = System.getSecurityManager();
18     if (g == null) { //g:當(dāng)前線程組
19         if (security != null) {
20             g = security.getThreadGroup();
21         }
22         if (g == null) {
23             g = parent.getThreadGroup();
24         }
25     }
26     g.checkAccess();
27     if (security != null) {
28         if (isCCLOverridden(getClass())) {
29             security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
30         }
31     }
32 
33     g.addUnstarted();
34 
35     this.group = g; //設(shè)置為當(dāng)前線程組
36     this.daemon = parent.isDaemon();//守護(hù)線程與否(同父線程)
37     this.priority = parent.getPriority();//優(yōu)先級同父線程
38     if (security == null || isCCLOverridden(parent.getClass()))
39         this.contextClassLoader = parent.getContextClassLoader();
40     else
41         this.contextClassLoader = parent.contextClassLoader;
42     this.inheritedAccessControlContext =
43             acc != null ? acc : AccessController.getContext();
44     this.target = target;
45     setPriority(priority);
46     //(2)如果父線程的inheritableThreadLocal不為null
47     if (inheritThreadLocals && parent.inheritableThreadLocals != null)
48         //（3）設(shè)置子線程中的inheritableThreadLocals為父線程的inheritableThreadLocals
49         this.inheritableThreadLocals =
50             ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
51     this.stackSize = stackSize;
52 
53     tid = nextThreadID();
54 }

 1 static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
 2     return new ThreadLocalMap(parentMap);
 3 }
 4 
 5 private ThreadLocalMap(ThreadLocalMap parentMap) {
 6     Entry[] parentTable = parentMap.table;
 7     int len = parentTable.length;
 8     setThreshold(len);
 9     table = new Entry[len];
10 
11     for (int j = 0; j < len; j++) {
12         Entry e = parentTable[j];
13         if (e != null) {
14             @SuppressWarnings("unchecked")
15             ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
16             if (key != null) {
17                 //調(diào)用重寫的方法
18                 Object value = key.childValue(e.value);
19                 Entry c = new Entry(key, value);
20                 int h = key.threadLocalHashCode & (len - 1);
21                 while (table[h] != null)
22                     h = nextIndex(h, len);
23                 table[h] = c;
24                 size++;
25             }
26         }
27     }
28 }

 1 /**
 2  * 是繼承自WeakReference的一個(gè)類，該類中實(shí)際存放的key是
 3  * 指向ThreadLocal的弱引用和與之對應(yīng)的value值(該value值
 4  * 就是通過ThreadLocal的set方法傳遞過來的值)
 5  * 由于是弱引用，當(dāng)get方法返回null的時(shí)候意味著坑能引用
 6  */
 7 static class Entry extends WeakReference<ThreadLocal<?>> {
 8     /** value就是和ThreadLocal綁定的 */
 9     Object value;
10 
11     //k：ThreadLocal的引用，被傳遞給WeakReference的構(gòu)造方法
12     Entry(ThreadLocal<?> k, Object v) {
13         super(k);
14         value = v;
15     }
16 }
17 //WeakReference構(gòu)造方法(public class WeakReference<T> extends Reference<T> )
18 public WeakReference(T referent) {
19     super(referent); //referent：ThreadLocal的引用
20 }
21 
22 //Reference構(gòu)造方法     
23 Reference(T referent) {
24     this(referent, null);//referent：ThreadLocal的引用
25 }
26 
27 Reference(T referent, ReferenceQueue<? super T> queue) {
28     this.referent = referent;
29     this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
30 }