Java中的ThreadLocal源码及弱引用解析

package Thread_;
 
public class ThreadLocal {
    private static java.lang.ThreadLocal<Integer> counter = new java.lang.ThreadLocal<>();
 
    public static void main(String[] args) {
        Runnable runnable = () -> {
            // 获取当前线程的计数器值，初始值为0
            int count = counter.get() == null ? 0 : counter.get();
            System.out.println(Thread.currentThread().getName() + " 的计数器值为: " + count);
 
            // 对计数器进行累加操作
            counter.set(count + 1);
 
            // 模拟耗时操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
            // 再次获取计数器值
            count = counter.get();
            System.out.println(Thread.currentThread().getName() + " 的累加后计数器值为: " + count);
        };
 
        // 创建三个线程并启动
        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;
    ...
}

// 对计数器进行累加操作
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);//不为空，已经有map，就把堆中的值赋值为counter，count + 1
        } else {
            createMap(t, value);//为空，创建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...，实现了线程内部的数据独立。
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;
            }
        }