深入解析Java线程源码：从基础到并发控制的全面指南（一）

一：Java线程基础和源码解析

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.TimeUnit;
import java.util.concurrent.locks.LockSupport;

import jdk.internal.misc.TerminatingThreadLocal;
import jdk.internal.reflect.CallerSensitive;
import jdk.internal.reflect.Reflection;
import jdk.internal.vm.annotation.IntrinsicCandidate;
import sun.nio.ch.Interruptible;
import sun.security.util.SecurityConstants;

//Thread.java实现Runable接口，并且会实现该接口的run方法。
public class Thread implements Runnable {
    //本地方法，简单看看方法名，不做深入了解
    private static native void registerNatives();
    static {
        registerNatives();
    }
    //给线程的名字，需要自定义线程名字的时候使用
    private volatile String name;
    //优先级，定义线程优先级的时候使用
    private int priority;
    //是否守护线程
    private boolean daemon = false;
    //定义一个中断线程的标志位，已中断的
    private volatile boolean interrupted;
    /* Fields reserved for exclusive use by the JVM */
    //jvm专用，不是给应用程序使用的，用来标识线程是否从未启动成功，默认是false
    //防止线程多次启动用，当调用start()方法后，其值改为true，保证线程生命周期正确性的机制之一
    private boolean stillborn = false;
    //jvm专用字段，原文的意思提取：当线程启动时其值非零，当线程终止时其值被重置为零
    //至少他的值能明确对应的线程是死还是存活，大概作用是对存或者死的线程管理时会用到
    private volatile long eetop;

    /* What will be run. */
    //继承了Runable，又持有这样一个属性，为了实现某种目的，而做的这种设计
    private Runnable target;

    /* The group of this thread */
    //线程组，树形结构
    private ThreadGroup group;

    //加载线程的类加载器
    private ClassLoader contextClassLoader;

    //它表示当前线程继承的 访问控制上下文（AccessControlContext）。这个字段与 Java 安全性机制密            
    //切相关，主要用于处理线程执行时的权限控制。
    //这个注解表示未来版本会移除
    @SuppressWarnings("removal")
    private AccessControlContext inheritedAccessControlContext;

    //主要用于 自动编号匿名线程。匿名线程通常是没有显式名字的线程，JVM 为这些线程分配一个默认的名        
    //字，通常是通过一个编号来实现自动命名。
    private static synchronized int nextThreadNum() {
        return threadInitNumber++;
    }

    //与此线程相关的 ThreadLocal 值。这个映射由 ThreadLocal 类维护        
    ThreadLocal.ThreadLocalMap threadLocals = null;

    //与此线程相关的 inheritableThreadLocals 值。这个映射由 InheritableThreadLocal 类维护
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

    //初始化线程时可以指定栈的大小，web项目基本不考虑，服务器内存基本都是过剩的   
    //多数情况是嵌入式系统会用
    private final long stackSize;

    //线程id
    private final long tid;

    //线程ID
    private static long threadSeqNumber;
    //用来生成线程ID，例如Thread ID: 1，Thread ID: 2
    private static synchronized long nextThreadID() {
        return ++threadSeqNumber;
    }

    /*
     * Java thread status for tools, default indicates thread 'not yet started'
     */
    //用于java线程状态相关的工具，可能是监控工具或者其他，默认值表示还没启动
    private volatile int threadStatus;

    //jvm用的字段，简单了解即可
    volatile Object parkBlocker;

    //组塞器，记录一个阻塞当前线程的对象
    private volatile Interruptible blocker;
    //私有对象，配合同步关键字使用，实现安全同步的作用
    private final Object blockerLock = new Object();

    //这段代码和注释的意思是设置当前线程的 blocker 字段，
    //以记录当前线程被哪个 Interruptible 对象阻塞，用于在 I/O 操作中设置阻塞器
    static void blockedOn(Interruptible b) {
        Thread me = Thread.currentThread();
        synchronized (me.blockerLock) {
            me.blocker = b;
        }
    }

    //线程最小优先级
    public static final int MIN_PRIORITY = 1;

    //线程默认的优先级 为5
    public static final int NORM_PRIORITY = 5;

    //一个线程最大的优先级是10
    public static final int MAX_PRIORITY = 10;

    //本地方法来获取当前线程
    @IntrinsicCandidate
    public static native Thread currentThread();

    //本地方法，表示当前线程愿意放弃当前处理器的使用权
    //大多数时候不使用该方法
    public static native void yield();

    //是一个静态本地方法，用于使当前正在执行的线程暂停执行指定的毫秒数。
    public static native void sleep(long millis) throws InterruptedException;

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

        if (nanos > 0 && millis < Long.MAX_VALUE) {
            millis++;
        }

        sleep(millis);
    }

    //初始化一个线程
    @SuppressWarnings("removal")
    private Thread(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;

        Thread parent = currentThread();
        SecurityManager security = System.getSecurityManager();
        if (g == null) {
            /* Determine if it's an applet or not */

            /* If there is a security manager, ask the security manager
               what to do. */
            if (security != null) {
                g = security.getThreadGroup();
            }

            /* If the security manager doesn't have a strong opinion
               on the matter, use the parent thread group. */
            if (g == null) {
                g = parent.getThreadGroup();
            }
        }

        /* checkAccess regardless of whether or not threadgroup is
           explicitly passed in. */
        g.checkAccess();

        /*
         * Do we have the required permissions?
         */
        if (security != null) {
            if