package test;
public class ThreadLocalTest {
    static ThreadLocal<String> localVar = new ThreadLocal<>();
    static void print(String str) {
        //打印當前線程中本地內(nèi)存中本地變量的值
        System.out.println(str + " :" + localVar.get());
        //清除本地內(nèi)存中的本地變量
        localVar.remove();
    }
    public static void main(String[] args) {
        Thread t1  = new Thread(new Runnable() {
            @Override
            public void run() {
                //設置線程1中本地變量的值
                localVar.set("localVar1");
                //調(diào)用打印方法
                print("thread1");
                //打印本地變量
                System.out.println("after remove : " + localVar.get());
            }
        });
        Thread t2  = new Thread(new Runnable() {
            @Override
            public void run() {
                //設置線程1中本地變量的值
                localVar.set("localVar2");
                //調(diào)用打印方法
                print("thread2");
                //打印本地變量
                System.out.println("after remove : " + localVar.get());
            }
        });
        t1.start();
        t2.start();
    }
}

ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

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

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

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

public T get() {
    //(1)獲取當前線程
    Thread t = Thread.currentThread();
    //(2)獲取當前線程的threadLocals變量
    ThreadLocalMap map = getMap(t);
    //(3)如果threadLocals變量不為null，就可以在map中查找到本地變量的值
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //(4)執(zhí)行到此處，threadLocals為null，調(diào)用該更改初始化當前線程的threadLocals變量
    return setInitialValue();
}
private T setInitialValue() {
    //protected T initialValue() {return null;}
    T value = initialValue();
    //獲取當前線程
    Thread t = Thread.currentThread();
    //以當前線程作為key值，去查找對應的線程變量，找到對應的map
    ThreadLocalMap map = getMap(t);
    //如果map不為null，就直接添加本地變量，key為當前線程，值為添加的本地變量值
    if (map != null)
        map.set(this, value);
    //如果map為null，說明首次添加，需要首先創(chuàng)建出對應的map
    else
        createMap(t, value);
    return value;
}

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

package test;
public class ThreadLocalTest2 {
    //(1)創(chuàng)建ThreadLocal變量
    public static ThreadLocal<String> threadLocal = new ThreadLocal<>();
    public static void main(String[] args) {
        //在main線程中添加main線程的本地變量
        threadLocal.set("mainVal");
        //新創(chuàng)建一個子線程
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("子線程中的本地變量值:"+threadLocal.get());
            }
        });
        thread.start();
        //輸出main線程中的本地變量值
        System.out.println("mainx線程中的本地變量值:"+threadLocal.get());
    }
}

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    protected T childValue(T parentValue) {
        return parentValue;
    }
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize) {
    init(g, target, name, stackSize, null, true);
}
private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize, AccessControlContext acc,
                  boolean inheritThreadLocals) {
    //判斷名字的合法性
    if (name == null) {
        throw new NullPointerException("name cannot be null");
    }
    this.name = name;
    //(1)獲取當前線程(父線程)
    Thread parent = currentThread();
    //安全校驗
    SecurityManager security = System.getSecurityManager();
    if (g == null) { //g:當前線程組
        if (security != null) {
            g = security.getThreadGroup();
        }
        if (g == null) {
            g = parent.getThreadGroup();
        }
    }
    g.checkAccess();
    if (security != null) {
        if (isCCLOverridden(getClass())) {
            security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
        }
    }
    g.addUnstarted();
    this.group = g; //設置為當前線程組
    this.daemon = parent.isDaemon();//守護線程與否(同父線程)
    this.priority = parent.getPriority();//優(yōu)先級同父線程
    if (security == null || isCCLOverridden(parent.getClass()))
        this.contextClassLoader = parent.getContextClassLoader();
    else
        this.contextClassLoader = parent.contextClassLoader;
    this.inheritedAccessControlContext =
            acc != null ? acc : AccessController.getContext();
    this.target = target;
    setPriority(priority);
    //(2)如果父線程的inheritableThreadLocal不為null
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        //（3）設置子線程中的inheritableThreadLocals為父線程的inheritableThreadLocals
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    this.stackSize = stackSize;
    tid = nextThreadID();
}

static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
    return new ThreadLocalMap(parentMap);
}
private ThreadLocalMap(ThreadLocalMap parentMap) {
    Entry[] parentTable = parentMap.table;
    int len = parentTable.length;
    setThreshold(len);
    table = new Entry[len];
    for (int j = 0; j < len; j++) {
        Entry e = parentTable[j];
        if (e != null) {
            @SuppressWarnings("unchecked")
            ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
            if (key != null) {
                //調(diào)用重寫的方法
                Object value = key.childValue(e.value);
                Entry c = new Entry(key, value);
                int h = key.threadLocalHashCode & (len - 1);
                while (table[h] != null)
                    h = nextIndex(h, len);
                table[h] = c;
                size++;
            }
        }
    }
}

/**
 * 是繼承自WeakReference的一個類，該類中實際存放的key是指向ThreadLocal的弱引用和與之對應的value值(該value值
 * 就是通過ThreadLocal的set方法傳遞過來的值)由于是弱引用，當get方法返回null的時候意味著回收引用
 */
static class Entry extends WeakReference<ThreadLocal<?>> {
    /** value就是和ThreadLocal綁定的 */
    Object value;
    //k：ThreadLocal的引用，被傳遞給WeakReference的構造方法
    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}
//WeakReference構造方法(public class WeakReference<T> extends Reference<T> )
public WeakReference(T referent) {
    super(referent); //referent：ThreadLocal的引用
}
//Reference構造方法
Reference(T referent) {
    this(referent, null);//referent：ThreadLocal的引用
}
Reference(T referent, ReferenceQueue<? super T> queue) {
    this.referent = referent;
    this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}