参考网址
https://zhidao.baidu.com/question/117575083.html
https://www.cnblogs.com/kubidemanong/p/9520071.html
https://blog.csdn.net/liudaohonglk/article/details/78278368
https://www.cnblogs.com/baiqiantao/p/79bf1e7f0803557c9195acec7af1e244.html
这个类感觉非常的有难度，看过一遍，只能说有大概的印象，有许多的方法还是不能理解；特别是其中有些方法涉及到JVM对象的弱引用，线程之间的共享，线程的异常，线程是如何终止的还没有搞的很清楚，需要花更多的时间来理解。
package java.lang;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.security.AccessController;
import java.security.AccessControlContext;
import java.security.PrivilegedAction;
import java.util.Map;
import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.locks.LockSupport;
import sun.nio.ch.Interruptible;
import sun.reflect.CallerSensitive;
import sun.reflect.Reflection;
public class Thread implements Runnable {
// 本地方法，注册原生方法
private static native void registerNatives();
// 单列，注册一次原生方法
static {
registerNatives();
}
// volatile修饰的变量用于保持内存可见性和防止指令重排序。
// 线程的名字
private volatile String name;
// 线程的优先级， 可以通过setPriority()设置
private int priority;
private Thread threadQ;
private long eetop;
// 是否单步执行此线程
private boolean single_step;
// 该线程是否是守护程序线程， 默认为false,可以通过setDaemon(boolean)来设置！
private boolean daemon = false;
// jvm 的状态
private boolean stillborn = false;
// 将要执行的内容，run()方法，Runnable中只有一个run()方法，
private Runnable target;
// 这个线程的组
private ThreadGroup group;
// 此线程的上下文, 指的是加载的类？
// 此线程加载类的上下 文
private ClassLoader contextClassLoader;
// 此线程的继承访问控制上下文
private AccessControlContext inheritedAccessControlContext;
// 用于自动编号匿名线程。
private static int threadInitNumber;
// 当前线程编号的下一位
private static synchronized int nextThreadNum() {
return threadInitNumber++;
}
// 与此线程有关的ThreadLocal值。 此映射由ThreadLocal类维护
ThreadLocal.ThreadLocalMap threadLocals = null;
// 与此线程相关的InheritableThreadLocal值。 此映射由InheritableThreadLocal类维护。
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
// 栈的大小
private long stackSize;
// 只在这里定义了，但是没有使用，
// 本机线程终止后持久存在的JVM私有状态。
private long nativeParkEventPointer;
// 线程的id
private long tid;
// 用于生成线程ID
// 只在nextThreadID()方法中使用到，这里是基本数据类型long定义的默认为0
private static long threadSeqNumber;
// 标识线程状态，默认是线程未启动
// volatile修饰的变量用于保持内存可见性和防止指令重排序。
private volatile int threadStatus = 0;
// 获取下一个threadSeqNumber
private static synchronized long nextThreadID() {
return ++threadSeqNumber;
}
// 该参数提供给当前对java.util.concurrent.locks.LockSupport.park的调用。
volatile Object parkBlocker;
// 在可中断的I / O操作中阻塞此线程的对象。
private volatile Interruptible blocker;
// 中断的对象，用来接收Interruptible
private final Object blockerLock = new Object();
void blockedOn(Interruptible b) {
// 加锁同步
// synchronized 块是这样一个代码块，其中的代码必须获得对象 blockerLock的锁方能执行
synchronized (blockerLock) {
blocker = b;
}
}
// 线程可以拥有的最小优先级。
public final static int MIN_PRIORITY = 1;
// 给线程分配的默认的优先级
public final static int NORM_PRIORITY = 5;
// 线程可以拥有的最大优先级
public final static int MAX_PRIORITY = 10;
// 本地方法、返回对当前正在执行的线程对象的引用
public static native Thread currentThread();
// 本地方法、对调度程序的一个暗示，即当前线程愿意产生当前使用的处理器。
public static native void yield();
// 本地方法、使当前正在执行的线程暂停millis毫秒
public static native void sleep(long millis) throws InterruptedException;
// 使用当前的线程睡眠
// 睡眠时间有3种可能。1、millis; 2、millis+1; 3、1 millis
public static void sleep(long millis, int nanos)
throws InterruptedException {
// 校验传入的参数是否正常，是否抛异常
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
// 1ms = 10^(-6)ns
if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}
// 使当前正在执行的线程暂停millis毫秒
sleep(millis);
}
// 初始化方法
private void init(ThreadGroup g, Runnable target, String name,
long stackSize) {
init(g, target, name, stackSize, null, true);
}
// 初始化方法
//g是线程组，target被调用RUN方法的目标对象，name新线程的名字，stackSize用于新线程分配所需堆栈大小
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
// name 为空抛异常
if (name == null) {
throw new NullPointerException("name cannot be null");
}
// 为name赋传值
this.name = name;
// 获取当前的线程
Thread parent = currentThread();
// 安全管理器
SecurityManager security = System.getSecurityManager();
// 线程组是否为空，为空则给线程一个分个组
if (g == null) {
// 安全管理器不为空，将安全管理器的线程组分配给当前的线程
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();
// 设置此线程加载类的上下 文
if (security == null || isCCLOverridden(parent.getClass()))
this.contextClassLoader = parent.getContextClassLoader();
else
this.contextClassLoader = parent.contextClassLoader;
// 设置当前线程的控制上下文
this.inheritedAccessControlContext =
acc != null ? acc : AccessController.getContext();
// Runnable,用来执行run()方法
this.target = target;
// 设置当前线程的优先级
setPriority(priority);
//
if (inheritThreadLocals && parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
this.stackSize = stackSize;
// 设置当前线程的id, threadSeqNumber产生
tid = nextThreadID();
}
// 任何类的是Object的子类，clone是Object中的方法
@Override
protected Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
// 构造方法
// 分配一个新的Thread对象。 此构造具有相同的效果Thread (null, null, gname)。
// 自动生成的名称格式为"Thread-"+ n ，其中n为整数
public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}
// 构造方法
// 分配一个新的Thread对象。 该构造具有相同的效果Thread (null, target, gname)。
// 自动生成的名称格式为"Thread-"+ n ，其中n为整数
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
// 构造方法
Thread(Runnable target, AccessControlContext acc) {
init(null, target, "Thread-" + nextThreadNum(), 0, acc, false);
}
// 构造方法
// 分配一个新的Thread对象。 此构造具有相同的效果Thread (group, target, gname)。
// 自动生成的名称格式为"Thread-"+ n ，其中n为整数
public Thread(ThreadGroup group, Runnable target) {
init(group, target, "Thread-" + nextThreadNum(), 0);
}
// 构造方法
// 分配一个新的Thread对象。 此构造具有相同的效果Thread (null, null, name)
public Thread(String name) {
init(null, null, name, 0);
}
// 构造方法
// 分配一个新的Thread对象。 此构造具有相同的效果Thread (group, null, name) 。
public Thread(ThreadGroup group, String name) {
init(group, null, name, 0);
}
// 构造方法
// 分配一个新的Thread对象。 此构造具有相同的效果Thread (null, target, name) 。
public Thread(Runnable target, String name) {
init(null, target, name, 0);
}
// 构造方法
// 分配一个新的Thread对象，指定target为线程运行的内容，指定名字为name，指定线程的组为group
public Thread(ThreadGroup group, Runnable target, String name) {
init(group, target, name, 0);
}
// 构造方法
// 分配一个新的Thread对象，指定target为线程运行的内容，
// 指定名字为name，指定线程的组为group，指定堆栈大小为size
public Thread(ThreadGroup group, Runnable target, String name,
long stackSize) {
init(group, target, name, stackSize);
}
// 执行当前的线程
// 结果是两个线程同时运行：当前线程（从调用返回到start方法）和另一个线程（执行其run方法）。
public synchronized void start() {
// 状态判断，是否抛异常
if (threadStatus != 0)
throw new IllegalThreadStateException();
// 当前线程添加进入线程组里面
group.add(this);
// 线程开始执行的状态置为false
boolean started = false;
try {
// 调用本地的方法，开始执行线程
start0();
// 如果没有报错，将状态置为true
started = true;
} finally {
try {
// 若当前线程执行失败则将当前线程加入缓和组的执行失败的组中
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
// 本地方法，执行线程
private native void start0();
// 实现Runable中的run()方法
@Override
public void run() {
if (target != null) {
target.run();
}
}
// 私有方法， 退出线程？将线程中的对象置为空
private void exit() {
if (group != null) {
group.threadTerminated(this);
group = null;
}
target = null;
threadLocals = null;
inheritableThreadLocals = null;
inheritedAccessControlContext = null;
blocker = null;
uncaughtExceptionHandler = null;
}
// 已经过期
@Deprecated
public final void stop() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
checkAccess();
if (this != Thread.currentThread()) {
security.checkPermission(SecurityConstants.STOP_THREAD_PERMISSION);
}
}
if (threadStatus != 0) {
resume();
}
stop0(new ThreadDeath());
}
// 已经过期
@Deprecated
public final synchronized void stop(Throwable obj) {
throw new UnsupportedOperationException();
}
// 中断当前的线程
public void interrupt() {
if (this != Thread.currentThread())
// 确定当前正在运行的线程是否有权限修改此线程。
checkAccess();
// 不懂
synchronized (blockerLock) {
Interruptible b = blocker;
if (b != null) {
interrupt0();
b.interrupt(this);
return;
}
}
// 调用本地就去，中断当前的线程
interrupt0();
}
// 测试当前线程是否中断。 该方法可以清除线程的中断状态 。
// 注意这里的写法：interrupted()静态，isInterrupted(true)非静态
// 静态方法中，静态的类对象调用其中的非静态方法，
public static boolean interrupted() {
return currentThread().isInterrupted(true);
}
// 测试这个线程是否被中断。 线程的中断状态不受此方法的影响。
public boolean isInterrupted() {
return isInterrupted(false);
}
// 本地方法，测试当前的线程是否中断
private native boolean isInterrupted(boolean ClearInterrupted);
// 已经过期
@Deprecated
public void destroy() {
throw new NoSuchMethodError();
}
// 本地方法，测试这个线程是否活着。 如果一个线程已经启动并且尚未死亡，那么线程是活着的。
public final native boolean isAlive();
// 已经过期
@Deprecated
public final void suspend() {
checkAccess();
suspend0();
}
// 已经过期
@Deprecated
public final void resume() {
checkAccess();
resume0();
}
// 设置此线程的优先级
public final void setPriority(int newPriority) {
// 定义线程组
ThreadGroup g;
// 校验当前线程是否有权限更改线程的状态
checkAccess();
// 传入线程的优先级必须是在[1, 10]之间，否则抛异常
if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
throw new IllegalArgumentException();
}
// 判断当前的线程是否有组，有组就设置新的优先级
if((g = getThreadGroup()) != null) {
// 判断传入的优先级是否大于组最大的优先级，若大于就将最大的给它，
if (newPriority > g.getMaxPriority()) {
newPriority = g.getMaxPriority();
}
// 调用本地方法，将新的优先级给当前的线程
setPriority0(priority = newPriority);
}
}
// 获取当前线程的优先级
public final int getPriority() {
return priority;
}
// 给线程设置上名字
public final synchronized void setName(String name) {
// 当前线程是否有操作线程的权限
checkAccess();
if (name == null) {
throw new NullPointerException("name cannot be null");
}
// 将传入的参数给当前的线程设置上
this.name = name;
if (threadStatus != 0) {
setNativeName(name);
}
}
// 获取当前线程的名字
public final String getName() {
return name;
}
// 获取当前的线程组
public final ThreadGroup getThreadGroup() {
return group;
}
// 计算当前线程组存活线程的数量
public static int activeCount() {
return currentThread().getThreadGroup().activeCount();
}
// 将当前线程的线程组及其子组中的每个活动线程复制到指定的数组中。
// 该方法简单地调用当前线程的线程组的ThreadGroup.enumerate(Thread[])方法。
public static int enumerate(Thread tarray[]) {
return currentThread().getThreadGroup().enumerate(tarray);
}
// 已经过期
@Deprecated
public native int countStackFrames();
// 等待这个线程死亡的时间最多为millis毫秒。 0的超时意味着永远等待。
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
// 校验参数，是否异常
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
// millis为0，线程永远等待
if (millis == 0) {
// 当前线程存活, 通过while循环，调用wait使线程，一直等待
while (isAlive()) {
wait(0);
}
} else {
// 线程活着，让线程等待millis毫秒
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
// 让线程处于等待状态，
// 与sleep(millis, nanos)方法非常相似
public final synchronized void join(long millis, int nanos)
throws InterruptedException {
// 校验是否抛异常
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
// nanos 在[0, 999999]之间
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}
join(millis);
}
// 等待这个线程死亡
public final void join() throws InterruptedException {
join(0);
}
// 将当前线程的堆栈跟踪打印到标准错误流。 此方法仅用于调试。
public static void dumpStack() {
new Exception("Stack trace").printStackTrace();
}
// 将此线程标记为daemon线程或用户线程。 当运行的唯一线程都是守护进程线程时，Java虚拟机将退出。
// 线程启动前必须调用此方法。 参数为true, 将此线程设置为守护线程。
public final void setDaemon(boolean on) {
// 校验当前的线程是否有权限操作线程
checkAccess();
// 线程不能为存活的线程，否则抛异常
if (isAlive()) {
throw new IllegalThreadStateException();
}
// on为true, 将此线程设置为守护线程
daemon = on;
}
// 判定当前的线程是否是守护线程
public final boolean isDaemon() {
return daemon;
}
// 确定当前正在运行的线程是否有权限修改此线程。
public final void checkAccess() {
// 获取当前系统的安全管理器
SecurityManager security = System.getSecurityManager();
if (security != null) {
// 校验是否有权限
security.checkAccess(this);
}
}
// 将线程的信息转化为字符串，
public String toString() {
ThreadGroup group = getThreadGroup();
if (group != null) {
// 分别是线程的名字，线程的优先级，组的名字
return "Thread[" + getName() + "," + getPriority() + "," +
group.getName() + "]";
} else {
// 当前线程没有组
return "Thread[" + getName() + "," + getPriority() + "," +
"" + "]";
}
}
// 返回此Thread的上下文ClassLoader
@CallerSensitive
public ClassLoader getContextClassLoader() {
// 是否为空
if (contextClassLoader == null)
return null;
// 校验是否有权限
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
ClassLoader.checkClassLoaderPermission(contextClassLoader,
Reflection.getCallerClass());
}
return contextClassLoader;
}
// 设置此线程的上下文ClassLoader
public void setContextClassLoader(ClassLoader cl) {
// 校验是否有权限
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("setContextClassLoader"));
}
contextClassLoader = cl;
}
// 本地方法，该方法旨在允许程序断言当前线程已经保存指定的锁
// 测试锁拥有权的对象
public static native boolean holdsLock(Object obj);
// 定义一个空的堆栈跟踪元素
private static final StackTraceElement[] EMPTY_STACK_TRACE
= new StackTraceElement[0];
// 进行堆栈信息的跟踪
public StackTraceElement[] getStackTrace() {
// this是线程对象本身，而Thread.currentThread()是当前正在运行的线程对象。
// 但是不一定是同一个线程对象，因为this这个线程不一定正是当前正在运行的线程。
if (this != Thread.currentThread()) {
// 校验是否具有权限
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(
SecurityConstants.GET_STACK_TRACE_PERMISSION);
}
// 不会调用尚未启动或已终止的线程
if (!isAlive()) {
return EMPTY_STACK_TRACE;
}
StackTraceElement[][] stackTraceArray = dumpThreads(new Thread[] {this});
StackTraceElement[] stackTrace = stackTraceArray[0];
// 在之前的isAlive调用期间处于活动状态的线程可能已经终止，因此没有堆栈跟踪。
if (stackTrace == null) {
stackTrace = EMPTY_STACK_TRACE;
}
return stackTrace;
} else {
// Don't need JVM help for current thread
return (new Exception()).getStackTrace();
}
}
// 返回所有活动线程的堆栈跟踪信息
public static Map<Thread, StackTraceElement[]> getAllStackTraces() {
// 校验当前线程的权限
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(
SecurityConstants.GET_STACK_TRACE_PERMISSION);
security.checkPermission(
SecurityConstants.MODIFY_THREADGROUP_PERMISSION);
}
// 获取所有线程列表的信息
Thread[] threads = getThreads();
// 将所有的线程信息放入traces中
StackTraceElement[][] traces = dumpThreads(threads);
Map<Thread, StackTraceElement[]> m = new HashMap<>(threads.length);
// 遍历线程将数据放入map中
for (int i = 0; i < threads.length; i++) {
StackTraceElement[] stackTrace = traces[i];
if (stackTrace != null) {
m.put(threads[i], stackTrace);
}
}
return m;
}
// 运行时权限
private static final RuntimePermission SUBCLASS_IMPLEMENTATION_PERMISSION =
new RuntimePermission("enableContextClassLoaderOverride");
// 内部类，与JVM优化GC垃圾回收有关
private static class Caches {
// 子类审计,弱类引用，不太懂
// 定义一个Map用于存储当前线程有那些弱引用
static final ConcurrentMap<WeakClassKey,Boolean> subclassAudits =
new ConcurrentHashMap<>();
// 构造一个新的引用对象队列，用于存储当前当前线程引用的那些对象
static final ReferenceQueue<Class<?>> subclassAuditsQueue =
new ReferenceQueue<>();
}
// 验证可以在不违反安全性约束的情况下构造此（可能是子类）实例：
// 子类不能覆盖对安全性敏感的非最终方法，
// 否则将检查“enableContextClassLoaderOverride”RuntimePermission。
private static boolean isCCLOverridden(Class<?> cl) {
if (cl == Thread.class)
return false;
// 将当前线程的弱引用，引用的对象缓存起来
processQueue(Caches.subclassAuditsQueue, Caches.subclassAudits);
// 将新的对象cl,在缓存队列中进行注册
WeakClassKey key = new WeakClassKey(cl, Caches.subclassAuditsQueue);
// 获取对象在缓存中的boolean值
Boolean result = Caches.subclassAudits.get(key);
if (result == null) {
result = Boolean.valueOf(auditSubclass(cl));
Caches.subclassAudits.putIfAbsent(key, result);
}
return result.booleanValue();
}
// 对给定的子类执行反射检查，以验证它是否不会覆盖对安全性敏感的非最终方法。
// 如果子类重写任何方法，则返回true，否则返回false。
private static boolean auditSubclass(final Class<?> subcl) {
// 不是太懂下面代码的意思
Boolean result = AccessController.doPrivileged(
new PrivilegedAction<Boolean>() {
public Boolean run() {
for (Class<?> cl = subcl;
cl != Thread.class;
cl = cl.getSuperclass())
{
try {
cl.getDeclaredMethod("getContextClassLoader", new Class<?>[0]);
return Boolean.TRUE;
} catch (NoSuchMethodException ex) {
}
try {
Class<?>[] params = {ClassLoader.class};
cl.getDeclaredMethod("setContextClassLoader", params);
return Boolean.TRUE;
} catch (NoSuchMethodException ex) {
}
}
return Boolean.FALSE;
}
}
);
return result.booleanValue();
}
// 本地方法，进行堆栈信息的跟踪
private native static StackTraceElement[][] dumpThreads(Thread[] threads);
private native static Thread[] getThreads();
// 获取当前线程的id
public long getId() {
return tid;
}
// 当前线程的状态枚举
public enum State {
// 线程尚未启动的线程状态。
NEW,
// 可运行线程的线程状态。
RUNNABLE,
// 一个线程的线程状态阻塞等待监视器锁定
BLOCKED,
// 等待线程的线程状态
WAITING,
// 具有指定等待时间的等待线程的线程状态。
TIMED_WAITING,
// 终止线程的线程状态。
TERMINATED;
}
// 获取当前线程的状态
public State getState() {
return sun.misc.VM.toThreadState(threadStatus);
}
// 当Thread由于未捕获的异常而突然终止时，处理程序的接口被调用。
@FunctionalInterface
public interface UncaughtExceptionHandler {
// 定义接口中的方法
void uncaughtException(Thread t, Throwable e);
}
// 与线程异常处理有关
// 设置该线程由于未捕获到异常而突然终止时调用的处理程序
private volatile UncaughtExceptionHandler uncaughtExceptionHandler;
// 设置当线程由于未捕获到异常而突然终止，并且没有为该线程定义其他处理程序时所调用的默认处理程序。
private static volatile UncaughtExceptionHandler defaultUncaughtExceptionHandler;
// 上面两个变量的getterAndSetter方法
public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
//
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(
new RuntimePermission("setDefaultUncaughtExceptionHandler")
);
}
defaultUncaughtExceptionHandler = eh;
}
public static UncaughtExceptionHandler getDefaultUncaughtExceptionHandler(){
return defaultUncaughtExceptionHandler;
}
public UncaughtExceptionHandler getUncaughtExceptionHandler() {
return uncaughtExceptionHandler != null ?
uncaughtExceptionHandler : group;
}
public void setUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
checkAccess();
uncaughtExceptionHandler = eh;
}
// 不明白这里的意思是什么
private void dispatchUncaughtException(Throwable e) {
getUncaughtExceptionHandler().uncaughtException(this, e);
}
// 校验map中的queue是否有进一步可用，没有将其从map中删除(好像是这个意思)
static void processQueue(ReferenceQueue<Class<?>> queue,
ConcurrentMap<? extends
WeakReference<Class<?>>, ?> map)
{
// Reference参考对象的抽象基类。 该类定义了所有引用对象共同的操作
// ref用来接收query的轮询值
Reference<? extends Class<?>> ref;
// queue.poll()轮询此队列以查看引用对象是否可用。
// 如果没有进一步延迟可用，那么它将从队列中删除并返回。 否则，此方法立即返回null
while((ref = queue.poll()) != null) {
map.remove(ref);
}
}
// 内部类，
// 弱引用WeakReference的包装类，将创建的新对象在弱引用的队列中注册，并计算其hash值
static class WeakClassKey extends WeakReference<Class<?>> {
// hash值
private final int hash;
// 创建引用对象，并在队列中注册新的弱引用
WeakClassKey(Class<?> cl, ReferenceQueue<Class<?>> refQueue) {
super(cl, refQueue);
// 返回与默认方法hashCode()返回的给定对象相同的哈希码，无论给定对象的类是否覆盖了hashCode()。
// 空引用的哈希码为零。
hash = System.identityHashCode(cl);
}
// 获取hash
@Override
public int hashCode() {
return hash;
}
// 如果给定对象是这个相同的WeakClassKey实例，或者如果此对象的指示对象尚未被清除，则返回true，
// 如果给定对象是另一个WeakClassKey实例，其具有与此相同的非null引用对象。
@Override
public boolean equals(Object obj) {
// 判断传入的obj是不与当前对象相同，相同为true
if (obj == this)
return true;
// 传入的对象是其它的WeakClassKey对象，
if (obj instanceof WeakClassKey) {
// 返回引用的对象
Object referent = get();
// 引用的对象不为空，(??)且与传入对象的引用对象相同则返回true
return (referent != null) &&
(referent == ((WeakClassKey) obj).get());
} else {
return false;
}
}
}
// 暂时不懂
// sun.misc.Contended避免伪共享(false sharing)
@sun.misc.Contended("tlr")
long threadLocalRandomSeed;
@sun.misc.Contended("tlr")
int threadLocalRandomProbe;
@sun.misc.Contended("tlr")
int threadLocalRandomSecondarySeed;
//
private native void setPriority0(int newPriority);
private native void stop0(Object o);
private native void suspend0();
private native void resume0();
private native void interrupt0();
private native void setNativeName(String name);
}
390
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
