Java-API简析_java.lang.Thread类（基于 Latest JDK）（浅析源码）

【版权声明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权）
https://blog.csdn.net/m0_69908381/article/details/131467981
出自【进步*于辰的博客】

注：依赖类：Object、ThreadGroup、 AccessControlContext、 ThreadLocal<T>、SecurityManager、ClassLoader。

1、概述

继承关系：

• java.lang.Object
  • java.lang.Thread

所有已实现的接口：
Runnable
已知直接子类：
ForkJoinWorkerThread

---

public class Thread extends Object implements Runnable

线程 是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

每个线程都有一个 优先级，高优先级线程的执行优先于低优先级线程。每个线程都可以或不可以标记为一个 守护程序。当某个线程中运行的代码创建一个新 Thread 对象时，该新线程的初始优先级被设定为创建线程的优先级，并且当且仅当创建线程是守护线程时，新线程才是守护程序。

当 Java 虚拟机启动时，通常都会有单个非守护线程（它通常会调用某个指定类的 main() 方法）。Java 虚拟机会继续执行线程，直到下列任一情况出现时为止：

• 调用了 Runtime 类的 exit() ，并且安全管理器允许退出操作发生。
• 非守护线程的所有线程都已停止运行，无论是通过从对 run() 方法的调用中返回，还是通过抛出一个传播到 run() 方法之外的异常。

创建新执行线程有两种方法。一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run() 。接下来可以分配并启动该子类的实例。例如，计算大于某一规定值的质数的线程可以写成：

class PrimeThread extends Thread {
    long minPrime;
    PrimeThread(long minPrime) {
        this.minPrime = minPrime;
    }

    public void run() {
        // compute primes larger than minPrime
         . . .
    }
}

然后，下列代码会创建并启动一个线程：

PrimeThread p = new PrimeThread(143);
p.start();

创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run() 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。采用这种风格的同一个例子如下所示：

class PrimeRunimplements Runnable {
    long minPrime;
    PrimeRun(long minPrime) {
        this.minPrime = minPrime;
    }

    public void run() {
        // compute primes larger than minPrime
         . . .
    }
}

然后，下列代码会创建并启动一个线程：

PrimeRun p = new PrimeRun(143);
new Thread(p).start();

每个线程都有一个标识名，多个线程可以同名。如果线程创建时没有指定标识名，就会为其生成一个新名称。

从以下版本开始：
JDK1.0
另请参见：
Runnable、Runtime.exit(int)、run()、 stop()

2、嵌套类摘要

2.1 static enum Thread.State

线程状态。

public enum State {
	NEW,
	RUNNABLE,
	BLOCKED,
	WAITING,
	TIMED_WAITING,
	TERMINATED;
{

线程状态虽只有6个，但状态信息与状态间转换细节很多，要想掌握，需系统性地梳理、学习，我将其移至博文《[Java]线程生命周期与线程通信》。

2.2 static interface Thread.UncaughtExceptionHandler

当 Thread 因未捕获的异常而突然终止时，调用处理程序的接口。（暂不知其用途）

3、构造方法摘要

主要属性说明：

private ThreadGroup group;// 所在线程组，若此线程已终止，为 null
private Runnable target;// 此线程目标
private volatile String name;
private long stackSize;// 为此线程申请的栈大小，默认为 0

private AccessControlContext inheritedAccessControlContext;// 此线程继承的上下文
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

次要属性说明：

private int            priority;
private Thread         threadQ;
private long           eetop;
private boolean     single_step;
private boolean     daemon = false;// 是否是守护线程
private boolean     stillborn = false;
private ClassLoader contextClassLoader;// 上下文类加载器
private static int threadInitNumber;// 匿名线程编号
private long nativeParkEventPointer;
private long tid;
private static long threadSeqNumber;
private volatile int threadStatus = 0;
volatile Object parkBlocker;
private volatile Interruptible blocker;
private final Object blockerLock = new Object();

3.1 null

分配新的 Thread 对象。

public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0);
}

3.2 Runnable target

分配新的 Thread 对象。

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

3.3 Runnable target, String name

分配新的 Thread 对象。

public Thread(Runnable target, String name) {
    init(null, target, name, 0);
}

3.4 String name

分配新的 Thread 对象。

public Thread(String name) {
    init(null, null, name, 0);
}

3.5 ThreadGroup group, Runnable target

分配新的 Thread 对象。

public Thread(ThreadGroup group, Runnable target) {
    init(group, target, "Thread-" + nextThreadNum(), 0);
}

3.6 ThreadGroup group, Runnable target, String name

分配新的 Thread 对象，以便将 target 作为其运行对象，将指定的 name 作为其名称，并作为 group 所引用的线程组的一员。

public Thread(ThreadGroup group, Runnable target, String name) {
    init(group, target, name, 0);
}

3.7 ThreadGroup group, Runnable target, String name, long stackSize

分配新的 Thread 对象，以便将 target 作为其运行对象，将指定的 name 作为其名称，作为 group 所引用的线程组的一员，并具有指定的堆栈尺寸。

public Thread(ThreadGroup group, Runnable target, String name,
              long stackSize) {
    init(group, target, name, stackSize);
}

3.8 ThreadGroup group, String name

分配新的 Thread 对象。

public Thread(ThreadGroup group, String name) {
    init(group, null, name, 0);
}

说明

8个构造方法都通过调用第5.1项初始化线程。

4、方法摘要

4.1 static int activeCount()

返回当前线程的线程组中活动线程的数目。

public static int activeCount() {
    return currentThread().getThreadGroup().activeCount();// 递归
}

返回当前线程的线程组及其子组中活动线程数的估计值。在当前线程的线程组中的所有子组上递归迭代。

返回的值只是一个估计值，因为当此方法遍历内部数据结构时，线程数量可能会动态变化，并且可能会受到某些系统线程的影响。此方法主要用于调试和监视目的。

后续解析。

4.2 void checkAccess()

判定当前运行的线程是否有权修改该线程。

public finalvoid checkAccess() {
    SecurityManager security = System.getSecurityManager();
    if (security != null) {
        security.checkAccess(this);
    }
}

4.3 int countStackFrames()

已过时。 该调用的定义依赖于 suspend()，但它遭到了反对。此外，该调用的结果从来都不是意义明确的。

4.4 static native Thread currentThread()

返回对当前正在执行的线程对象的引用（实例）。

4.5 void destroy()

已过时。 该方法最初用于销毁该线程，但不作任何清除。它所保持的任何监视器都会保持锁定状态。不过，该方法决不会被实现。即使要实现，它也极有可能以 suspend() 方式被死锁。如果目标线程被销毁时保持一个保护关键系统资源的锁，则任何线程在任何时候都无法再次访问该资源。如果另一个线程曾试图锁定该资源，则会出现死锁。这类死锁通常会证明它们自己是“冻结”的进程。有关更多信息，见文末【参考阅读】。

4.6 static void dumpStack()

打印当前线程的堆栈跟踪。

4.7 static int enumerate(Thread[] tarray)

将当前线程的线程组及其子组中的每一个活动线程复制到指定的数组中。

4.8 static Map<Thread, StackTraceElement[]> getAllStackTraces()

返回所有活动线程的堆栈跟踪的一个映射。

4.9 ClassLoader getContextClassLoader()

返回该线程的上下文 ClassLoader。

public ClassLoader getContextClassLoader() {
    if (contextClassLoader == null)
        return null;
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        // 若当前类的类加载器不是当前线程上下文类加载器的“祖类加载器”时，确认调用线程是否有权获取类加载器
        ClassLoader.checkClassLoaderPermission(contextClassLoader,
                                               Reflection.getCallerClass());
    }
    return contextClassLoader;
}

关于checkClassLoaderPermission()，见类加载器类的第4.3项。

4.10 static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler()

返回线程由于未捕获到异常而突然终止时调用的默认处理程序。

4.11 long getId()

返回该线程的标识符。

4.12 String getName()

返回该线程的名称。

4.13 int getPriority()

返回线程的优先级。

4.14 StackTraceElement[] getStackTrace()

返回一个表示该线程堆栈转储的堆栈跟踪元素数组。

4.15 Thread.State getState()

返回该线程的状态。

4.16 ThreadGroup getThreadGroup()

返回该线程所属的线程组。

4.17 Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()

返回该线程由于未捕获到异常而突然终止时调用的处理程序。

4.18 static boolean holdsLock(Object obj)

当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。

4.19 void interrupt()

中断线程。

public void interrupt() {
    if (this != Thread.currentThread())
        checkAccess();

    synchronized (blockerLock) {
        Interruptible b = blocker;
        if (b != null) {
            interrupt0();           // Just to set the interrupt flag
            b.interrupt(this);
            return;
        }
    }
    interrupt0();
}

后续解析。

除非当前线程正在中断自身（这总是允许的），否则会调用此线程的checkAccess()，这可能会导致引发SecurityException。

如果此线程正在调用Object类的wait()、wait(long)或wait(long, int)，或者此类的join()、join(long)、join(long, int)、sleep(long)或sleep(long, int)，中断状态将被清除并抛出 InterruptedException。

如果该线程在 InterruptbleChannel 上的I/O操作中被阻塞，那么该通道将被关闭，该线程的中断状态将被重置，并且该线程将接收 java.nio.channels.ClosedByInterruptException。

如果这个线程在java.nio.channels中被阻塞，那么线程的中断状态将被重置，它将立即从选择操作返回，可能具有非零值，就像调用了选择器的唤醒方法一样。

如果之前的任何条件都不成立，那么将重置此线程的中断状态。

中断不活动的线程不需要有任何效果。

4.20 static boolean interrupted()

测试当前线程是否已经中断。

public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}

4.21 native boolean isAlive()

测试线程是否处于活动状态（已启动且未终止）。

4.22 boolean isDaemon()

测试该线程是否为守护线程。

4.23 native boolean isInterrupted()

测试线程是否已经中断。

中断状态是否根据传递的ClearInterrupted值重置。

4.24 void join()

等待该线程终止。

public final void join() throws InterruptedException {
    join(0);
}

调用下1项。指定线程终止时间为0毫秒。

4.25 void join(long millis)

等待该线程终止的时间最长为 millis 毫秒。

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

    if (millis == 0) {
        while (isAlive()) {
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);// 令当前线程（主线程）等待(被唤醒)，见 Object 类第3.10项
            now = System.currentTimeMillis() - base;
        }
        /*
        * 从逻辑分析，以上循环等同于 wait(millis)，那为何还需循环？
        * 因为 wait() 的功能是使当前线程（主线程）等待(被唤醒)，让子线程先执行，
        * 若子线程因某种原因终止了，主线程自然无需继续等待，故需判断子线程的活动状态
        */
    }
}

4.26 void join(long millis, int nanos)

等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。

public final synchronized void join(long millis, int nanos) throws InterruptedException {
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }
	
	// timeout 的单位是“毫秒”，nanos 的单位是“纳秒”，转换量级是 10 的 6 次方
    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }
    
    if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
        millis++;
    }
    
    join(millis);// 调用上1项
}

4.27 void resume()

已过时。 该方法只与 suspend() 一起使用，但 suspend() 已经遭到反对，因为它具有死锁倾向。有关更多信息，见文末【参考阅读】。

4.28 void run()

如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。

4.29 void setContextClassLoader(ClassLoader cl)

设置该线程的上下文 ClassLoader。

public void setContextClassLoader(ClassLoader cl) {
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        sm.checkPermission(new RuntimePermission("setContextClassLoader"));
    }
    contextClassLoader = cl;
}

关于checkPermission()，见安全管理器类的第4.18项。

4.30 void setDaemon(boolean on)

将该线程标记为守护线程或用户线程。

4.31 static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)

设置当线程由于未捕获到异常而突然终止，并且没有为该线程定义其他处理程序时所调用的默认处理程序。

4.32 void setName(String name)

改变线程名称，使之与参数 name 相同。

4.33 void setPriority(int newPriority)

更改线程的优先级。

4.34 void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)

设置该线程由于未捕获到异常而突然终止时调用的处理程序。

4.35 static native void sleep(long millis)

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。

根据系统计时器和调度程序的精度和准确性，使当前执行的线程休眠（暂时停止执行）指定的毫秒数。线程不会失去任何监视器的所有权。

4.36 static void sleep(long millis, int nanos)

在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行）。

public static void sleep(long millis, int nanos) throws InterruptedException {
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

	// timeout 的单位是“毫秒”，nanos 的单位是“纳秒”，转换量级是 10 的 6 次方
    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }

    if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
        millis++;
    }

    sleep(millis);// 调用上1项
}

4.37 void start()

使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

4.38 void stop()

已过时。 该方法具有固有的不安全性。用 Thread.stop() 来终止线程将释放它已经锁定的所有监视器（这是未检查的 ThreadDeath 异常在堆栈中传播的自然结果）。如果以前受这些监视器保护的任何对象都处于一种不一致的状态，则“损坏”的对象（指破坏数据完整性）将对其他线程可见，这有可能导致任意的行为。stop() 的许多使用都应由只修改某些变量以指示目标线程应该停止运行的代码来取代。目标线程应定期检查该变量，并且如果该变量指示它要停止运行，则以有序的方式从其运行方法返回。如果目标线程等待很长时间（例如基于一个条件变量），则应使用 interrupt() 来中断该等待。有关更多信息，见文末【参考阅读】。

允许停止尚未启动的线程。如果线程最终启动，它会立即终止。

4.39 void stop(Throwable obj)

已过时。 该方法具有固有的不安全性。请参阅 stop() 以获得详细信息。该方法的附加危险是它可用于生成目标线程未准备处理的异常（包括若没有该方法该线程不太可能抛出的已检查的异常）。有关更多信息，见文末【参考阅读】。

4.40 void suspend()

已过时。 该方法已经遭到反对，因为它具有固有的死锁倾向。如果目标线程挂起时在保护关键系统资源的监视器上保持有锁，则在目标线程重新开始以前任何线程都不能访问该资源。如果重新开始目标线程的线程想在调用 resume() 之前锁定该监视器，则会发生死锁。这类死锁通常会证明自己是“冻结”的进程。有关更多信息，见文末【参考阅读】。

4.41 String toString()

返回该线程的字符串表示形式，包括线程名称、优先级和线程组。

4.42 static native void yield()

暂停当前正在执行的线程对象，并执行其他线程。

向调度程序提示当前线程愿意放弃其对处理器的当前使用。调度程序可以忽略此提示。

Yield是一种启发式尝试，旨在改善线程之间的相对进度，否则线程将过度使用CPU。它的使用应该与详细的分析和基准测试相结合，以确保它确实具有预期的效果。

使用这种方法很少是合适的。它可能有助于调试或测试目的，有助于重现由于竞争条件而产生的错误。在设计并发控制结构（如java.util.concurrent.locks包中的结构）时，它也可能很有用。

5、方法摘要（不开放）

5.1 private void init(ThreadGroup g, Runnable target, String name, long stackSize)

线程初始化。

private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize) {
    init(g, target, name, stackSize, null, true);
}

调用下1项。

5.2 private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc, boolean inheritThreadLocals)

线程初始化。

private void init(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) {
        if (security != null) {
            g = security.getThreadGroup();// 当前线程（主线程）所在线程组，见第 4.39项
        }
        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();
    this.target = target;
    setPriority(priority);
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    /* Stash the specified stack size in case the VM cares */
    this.stackSize = stackSize;

    /* Set thread ID */
    tid = nextThreadID();
}

后续补充解析。

5.3 private static synchronized int nextThreadNum()

返回当前线程的匿名线程编号。

最后

如果大家需要Java-API文档，我上传了《Java-API文档-包含5/8/11三个版本》。

参考阅读：《Java面向对象编程》导读-Thread类的被废弃的suspend()、resume()和stop()方法（转发）。

---

本文暂缓更新。