package Thread_;
 
public class ThreadLocal {
    private static java.lang.ThreadLocal<Integer> counter = new java.lang.ThreadLocal<>();
 
    public static void main(String[] args) {
        Runnable runnable = () -> {
            // 獲取當前線程的計數(shù)器值，初始值為0
            int count = counter.get() == null ? 0 : counter.get();
            System.out.println(Thread.currentThread().getName() + " 的計數(shù)器值為: " + count);
 
            // 對計數(shù)器進行累加操作
            counter.set(count + 1);
 
            // 模擬耗時操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
            // 再次獲取計數(shù)器值
            count = counter.get();
            System.out.println(Thread.currentThread().getName() + " 的累加后計數(shù)器值為: " + count);
        };
 
        // 創(chuàng)建三個線程并啟動
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        Thread thread3 = new Thread(runnable);
 
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
 

public class Thread implements Runnable{
    ...
    ...
    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;
    ...
}

// 對計數(shù)器進行累加操作
counter.set(count + 1);
 
//源碼1. set源碼：
public void set(T value) {
        Thread t = Thread.currentThread();//獲取當前線程
        ThreadLocalMap map = getMap(t);//讓map成為該線程內的threadLocals所引用的堆中的對象！
//見源碼2. 
//其實就是去嘗試引用實例化的ThreadLocalMap，但此時初始化為null，所以我們看下面的判斷：
 
        if (map != null) {
            map.set(this, value);//不為空，已經(jīng)有map，就把堆中的值賦值為counter，count + 1
        } else {
            createMap(t, value);//為空，創(chuàng)建ThreadLocalMap的對象
            //但要注意，createMap并不是讓map實例化，見下面源碼3.
        }
    }
 
//源碼2. getMap源碼：
ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    //意思就是，返回這個t線程的ThreadLocal.ThreadLocalMap threadLocals = null里面這個threadLocals 對象
    }
 
//源碼3. createMap源碼：
//傳入的this，其實就是counter。firstValue就是相應的值count + 1。
//注意，是將t.threadLocals線程內的這個ThreadLocalMap對象實例化，所以線程內部的這個對象指向了堆中內存的new...，實現(xiàn)了線程內部的數(shù)據(jù)獨立。
void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

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

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