Inheritable thread-local variables are used in preference to
- * ordinary thread-local variables when the per-thread-attribute being
- * maintained in the variable (e.g., User ID, Transaction ID) must be
- * automatically transmitted to any child threads that are created.
+ * 创建允许子线程继承的 ThreadLocal
*
- * @author Josh Bloch and Doug Lea
- * @see ThreadLocal
- * @since 1.2
+ * @see ThreadLocal
*/
-
public class InheritableThreadLocal
- * This method merely returns its input argument, and should be overridden
- * if a different behavior is desired.
+ * 拿到父线程的值后，可以在这里处理后再返回给子线程
*
* @param parentValue the parent thread's value
* @return the child thread's initial value
@@ -63,18 +17,18 @@ protected T childValue(T parentValue) {
}
/**
- * Get the map associated with a ThreadLocal.
+ * 获取当前线程内的 inheritableThreadLocals 属性
*
- * @param t the current thread
+ * @param t 当前线程
*/
ThreadLocalMap getMap(Thread t) {
- return t.inheritableThreadLocals;
+ return t.inheritableThreadLocals;
}
/**
- * Create the map associated with a ThreadLocal.
+ * 初始化线程中的 inheritableThreadLocals 属性
*
- * @param t the current thread
+ * @param t 当前线程
* @param firstValue value for the initial entry of the table.
*/
void createMap(Thread t, T firstValue) {
diff --git a/src/java/lang/ThreadLocal.java b/src/java/lang/ThreadLocal.java
index 43044fb3..72610902 100644
--- a/src/java/lang/ThreadLocal.java
+++ b/src/java/lang/ThreadLocal.java
@@ -1,102 +1,63 @@
package java.lang;
+
import java.lang.ref.*;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;
/**
- * This class provides thread-local variables. These variables differ from
- * their normal counterparts in that each thread that accesses one (via its
- * {@code get} or {@code set} method) has its own, independently initialized
- * copy of the variable. {@code ThreadLocal} instances are typically private
- * static fields in classes that wish to associate state with a thread (e.g.,
- * a user ID or Transaction ID).
- *
- * For example, the class below generates unique identifiers local to each
- * thread.
- * A thread's id is assigned the first time it invokes {@code ThreadId.get()}
- * and remains unchanged on subsequent calls.
- * Each thread holds an implicit reference to its copy of a thread-local
- * variable as long as the thread is alive and the {@code ThreadLocal}
- * instance is accessible; after a thread goes away, all of its copies of
- * thread-local instances are subject to garbage collection (unless other
- * references to these copies exist).
- *
- * @author Josh Bloch and Doug Lea
- * @since 1.2
+ * @param This implementation simply returns {@code null}; if the
- * programmer desires thread-local variables to have an initial
- * value other than {@code null}, {@code ThreadLocal} must be
- * subclassed, and this method overridden. Typically, an
- * anonymous inner class will be used.
- *
- * @return the initial value for this thread-local
+ * @return 该线程关联的初始值
*/
protected T initialValue() {
return null;
@@ -117,103 +78,103 @@ public static Suppose that the garbage collector determines at a certain point in time
- * that an object is weakly
- * reachable. At that time it will atomically clear all weak references to
- * that object and all weak references to any other weakly-reachable objects
- * from which that object is reachable through a chain of strong and soft
- * references. At the same time it will declare all of the formerly
- * weakly-reachable objects to be finalizable. At the same time or at some
- * later time it will enqueue those newly-cleared weak references that are
- * registered with reference queues.
+ * 弱引用(Weak Reference)
+ * 当一个对象为弱引用时，运行 GC 后会回收其引用指向的对象
+ * 它可以用于解决非静态内部类的内存泄露问题（定义一个静态内部类，并让它持有外部类的弱引用）
+ * 还可以用于实现缓存，比如 WeakHashMap
*
- * @author Mark Reinhold
- * @since 1.2
+ * @param
- * import java.util.concurrent.atomic.AtomicInteger;
+ * 线程局部缓存：为线程缓存数据，数据独享
+ * 原理：
+ * 1. 每个线程由一个 ThreadLocalMap 属性，本质就是一个 map
+ * 2. map 里面存储的
- * ThreadLocal withInitial(Supplier supplier) {
}
/**
- * Creates a thread local variable.
+ * 构造 ThreadLocal 实例
+ *
* @see #withInitial(java.util.function.Supplier)
*/
public ThreadLocal() {
}
/**
- * Returns the value in the current thread's copy of this
- * thread-local variable. If the variable has no value for the
- * current thread, it is first initialized to the value returned
- * by an invocation of the {@link #initialValue} method.
+ * 返回当前 ThreadLocal 对象关联的值
*
- * @return the current thread's value of this thread-local
+ * @return
*/
public T get() {
+ // 返回当前 ThreadLocal 所在的线程
Thread t = Thread.currentThread();
+ // 从线程中拿到 ThreadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null) {
+ // 从 map 中拿到 entry
ThreadLocalMap.Entry e = map.getEntry(this);
+ // 如果不为空，读取当前 ThreadLocal 中保存的值
if (e != null) {
@SuppressWarnings("unchecked")
- T result = (T)e.value;
+ T result = (T) e.value;
return result;
}
}
+ // 若 map 为空，则对当前线程的 ThreadLocal 进行初始化，最后返回当前的 ThreadLocal 对象关联的初值，即 value
return setInitialValue();
}
/**
- * Variant of set() to establish initialValue. Used instead
- * of set() in case user has overridden the set() method.
+ * 初始化 ThreadLocalMap，并存储键值对