模块 java.base
 java.lang

类 Thread

java.lang.Object
java.lang.Thread
所有已实现的接口:
Runnable
已知子类:
ForkJoinWorkerThread

public class Thread extends Object implements Runnable
A 线是程序中的执行线程。 Java 虚拟机允许应用程序同时运行多个执行线程。

Thread 定义构造函数和一个 Thread.Builder PREVIEW 创建线程。 开始 一个线程安排它执行它的 run 方法。新启动的线程与导致它启动的线程并发执行。

A 线程terminates如果它的 run 方法正常完成,或者它的 run 方法突然完成并且适当的 未捕获的异常处理程序 正常或突然完成。由于没有剩余代码可运行,线程已完成执行。 join 方法可用于等待线程终止。

线程有一个唯一的 identifier 和一个 name 。标识符是在创建 Thread 时生成的,不能更改。线程名称可以在创建线程时指定,也可以在以后指定为变了

线程支持 ThreadLocal 变量。这些变量是线程的本地变量,这意味着一个线程可以拥有一个变量的副本,该副本设置为一个独立于其他线程设置的值的值。 Thread 还支持 InheritableThreadLocal 变量,这些变量是在线程创建时从父线程继承的线程局部变量。 Thread 支持线程 上下文类加载器 的特殊可继承线程本地。

平台线程

Thread支持创建平台线程通常按 1:1 映射到操作系统调度的内核线程。平台线程通常会有一个很大的堆栈和其他由操作系统维护的资源。平台线程适用于执行所有类型的任务,但可能是一种有限的资源。

默认情况下,平台线程会获得一个自动生成的线程名称。

指定平台线程daemon或者non-daemon线程。当Java 虚拟机启动时,通常有一个非守护线程(通常调用应用程序的main 方法的线程)。 关机顺序 在所有启动的非守护线程终止时开始。未启动的非守护线程不会阻止关闭序列的开始。

除了守护程序状态之外,平台线程还有一个 线程优先级 并且是 线程组 的成员。

虚拟线程

Thread也支持创建虚拟线程.虚拟线程通常是用户态线程由 Java 运行时而非操作系统调度。虚拟线程通常需要很少的资源,单个 Java 虚拟机可能支持数百万个虚拟线程。虚拟线程适用于执行大部分时间处于阻塞状态的任务,经常等待 I/O 操作完成。虚拟线程不适用于长时间运行的 CPU 密集型操作。

虚拟线程通常使用一小组用作 carrier threads 的平台线程。锁定和 I/O 操作是其中可以将载体线程从一个虚拟线程重新调度到另一个虚拟线程的操作示例。在虚拟线程中执行的代码不知道底层的载体线程。 currentThread() 方法,用于获取对当前线程将始终返回虚拟线程的 Thread 对象。

默认情况下,虚拟线程没有线程名称。如果未设置线程名称,getName 方法将返回空字符串。

虚拟线程是守护线程,因此不会阻止 关机顺序 开始。虚拟线程有一个固定的线程优先级,无法更改。

创建和启动线程

Thread 定义了用于创建平台线程的公共构造函数和 start 方法来安排线程执行。 Thread 可以出于自定义和其他高级原因而扩展,尽管大多数应用程序应该很少需要这样做。

Thread 定义了一个 Thread.Builder PREVIEW 用于创建和启动平台和虚拟线程的 API。以下是使用构建器的示例:

 Runnable runnable = ...

 // Start a daemon thread to run a task
 Thread thread = Thread.ofPlatform().daemon().start(runnable);

 // Create an unstarted thread with name "duke", its start() method
 // must be invoked to schedule it to execute.
 Thread thread = Thread.ofPlatform().name("duke").unstarted(runnable);

 // A ThreadFactory that creates daemon threads named "worker-0", "worker-1", ...
 ThreadFactory factory = Thread.ofPlatform().daemon().name("worker-", 0).factory();

 // Start a virtual thread to run a task
 Thread thread = Thread.ofVirtual().start(runnable);

 // A ThreadFactory that creates virtual threads
 ThreadFactory factory = Thread.ofVirtual().factory();
 

创建线程时的继承

Thread 在创建子 Thread 时从父线程值继承其 可继承线程本地 变量(包括上下文类加载器)的初始值。 5 参数 构造器 可用于创建不从构造线程继承其初始值的线程。使用 Thread.Builder 时,inheritInheritableThreadLocals PREVIEW 方法可用于选择是否继承初始值。

平台线程继承守护进程状态、线程优先级以及未提供(或未被安全管理器选择)时的线程组。

创建平台线程 捕获 调用者上下文 以限制新线程在执行执行 特权行动 的代码时的 permissions。捕获的调用者上下文是新线程的“Inherited AccessControlContext ”。创建虚拟线程不会捕获调用者上下文;执行执行特权操作的代码时,虚拟线程没有权限。

除非另有说明,否则将 null 参数传递给此类中的构造函数或方法将导致抛出 NullPointerException

实现注意事项:
在 JDK 参考实现中,虚拟线程调度程序可以配置以下系统属性:
系统属性
系统属性 Description
jdk.virtualThreadScheduler.parallelism 可用于调度虚拟线程的平台线程数。它默认为可用处理器的数量。
jdk.virtualThreadScheduler.maxPoolSize 调度程序可用的最大平台线程数。它默认为 256。
自从:
1.0
  • 内部类总结

    内部类
    修饰符和类型
    描述
    static interface 
    预览。
    Thread ThreadFactory 对象的生成器。
    static enum 
    线程状态。
    static interface 
    Thread 由于未捕获的异常而突然终止时调用的处理程序接口。
  • 字段摘要

    字段
    修饰符和类型
    Field
    描述
    static final int
    线程可以拥有的最大优先级。
    static final int
    线程可以具有的最小优先级。
    static final int
    分配给线程的默认优先级。
  • 构造方法总结

    构造方法
    构造方法
    描述
    初始化新平台 Thread
    初始化新平台 Thread
    Thread(Runnable task, String name)
    初始化新平台 Thread
    Thread(String name)
    初始化新平台 Thread
    Thread(ThreadGroup group, Runnable task)
    初始化新平台 Thread
    Thread(ThreadGroup group, Runnable task, String name)
    初始化新平台 Thread,使其运行对象为 task,名称为指定的 name,并且属于 group 引用的线程组。
    Thread(ThreadGroup group, Runnable task, String name, long stackSize)
    初始化一个新的平台 Thread,使其具有 task 作为其运行对象,具有指定的 name 作为其名称,并且属于 group 引用的线程组,并且具有指定的堆栈大小.
    Thread(ThreadGroup group, Runnable task, String name, long stackSize, boolean inheritInheritableThreadLocals)
    初始化一个新平台 Thread,使其具有 task 作为其运行对象,具有指定的 name 作为其名称,属于 group 引用的线程组,具有指定的 stackSize,并且如果 inheritThreadLocalstrue 则继承 可继承线程本地 变量的初始值。
    Thread(ThreadGroup group, String name)
    初始化新平台 Thread
  • 方法总结

    修饰符和类型
    方法
    描述
    static int
    返回当前线程的线程组及其子组中 居住 平台线程数的估计值。
    final void
    已弃用,将被删除:此 API 元素可能会在未来版本中删除。
    此方法仅与 安全管理器 结合使用,已弃用并在未来版本中删除。
    protected Object
    抛出 CloneNotSupportedException 作为线程无法有意义地克隆。
    int
    已弃用,将被删除:此 API 元素可能会在未来版本中删除。
    此方法最初设计用于计算堆栈帧的数量,但结果从未明确定义,并且它依赖于线程挂起。
    static Thread
    返回当前线程的 Thread 对象。
    static void
    将当前线程的堆栈跟踪打印到标准错误流。
    static int
    enumerate(Thread[] tarray)
    将当前线程的线程组及其子组中的每个 居住 平台线程复制到指定数组中。
    返回所有实时平台线程的堆栈跟踪映射。
    返回此线程的上下文 ClassLoader
    返回当线程由于未捕获的异常而突然终止时调用的默认处理程序。
    long
    已弃用。
    此方法不是最终方法,可能会被重写以返回一个不是线程 ID 的值。
    final String
    返回此线程的名称。
    final int
    返回此线程的优先级。
    返回表示此线程的堆栈转储的堆栈跟踪元素数组。
    返回此线程的状态。
    如果线程已终止,则返回线程的线程组或 null
    返回当此线程由于未捕获的异常而突然终止时调用的处理程序。
    static boolean
    当且仅当当前线程持有指定对象上的监视器锁时,才返回 true
    void
    中断此线程。
    static boolean
    测试当前线程是否被中断。
    final boolean
    测试此线程是否存活。
    final boolean
    测试此线程是否是守护线程。
    boolean
    测试此线程是否已被中断。
    final boolean
    预览。
    如果此线程是虚拟线程,则返回 true
    final void
    join()
    等待此线程终止。
    final void
    join(long millis)
    此线程终止最多等待 millis 毫秒。
    final void
    join(long millis, int nanos)
    最多等待 millis 毫秒加上 nanos 纳秒,以便此线程终止。
    final boolean
    join(Duration duration)
    等待此线程终止直至给定的等待持续时间。
    预览。
    返回用于创建平台线程的构建器 ThreadThreadFactory
    预览。
    返回用于创建创建虚拟线程的虚拟 ThreadThreadFactory 的构建器。
    static void
    指示调用者暂时无法进行,直到其他活动的一个或多个操作发生为止。
    final void
    已弃用,将被删除:此 API 元素可能会在未来版本中删除。
    此方法最初指定用于恢复使用 suspend() 挂起的线程。
    void
    run()
    该方法在执行时由线程运行。
    void
    为此线程设置上下文 ClassLoader
    final void
    setDaemon(boolean on)
    将此线程标记为daemon或者non-daemon线。
    static void
    设置当线程由于未捕获的异常而突然终止时调用的默认处理程序,并且没有为该线程定义其他处理程序。
    final void
    setName(String name)
    将此线程的名称更改为等于参数 name
    final void
    setPriority(int newPriority)
    更改此线程的优先级。
    void
    设置此线程由于未捕获的异常而突然终止时调用的处理程序。
    static void
    sleep(long millis)
    使当前正在执行的线程休眠(暂时停止执行)指定的毫秒数,具体取决于系统计时器和调度程序的精度和准确性。
    static void
    sleep(long millis, int nanos)
    使当前正在执行的线程休眠(暂时停止执行)指定的毫秒数加上指定的纳秒数,这取决于系统计时器和调度程序的精度和准确性。
    static void
    sleep(Duration duration)
    根据系统计时器和调度程序的精度和准确性,使当前正在执行的线程在指定的持续时间内休眠(暂时停止执行)。
    void
    安排此线程开始执行。
    static Thread
    预览。
    创建一个虚拟线程来执行任务并安排它执行。
    final void
    stop()
    已弃用,将被删除:此 API 元素可能会在未来版本中删除。
    此方法最初指定为通过使受害线程抛出 ThreadDeath 来“停止”受害线程。
    final void
    已弃用,将被删除:此 API 元素可能会在未来版本中删除。
    该方法最初指定用于挂起线程。
    final long
    返回此线程的标识符。
    返回此线程的字符串表示形式。
    static void
    向调度程序提示当前线程愿意放弃其当前对处理器的使用。

    在类 java.lang.Object 中声明的方法

    equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
  • 字段详细信息

    • MIN_PRIORITY

      public static final int MIN_PRIORITY
      线程可以具有的最小优先级。
      参见:
    • NORM_PRIORITY

      public static final int NORM_PRIORITY
      分配给线程的默认优先级。
      参见:
    • MAX_PRIORITY

      public static final int MAX_PRIORITY
      线程可以拥有的最大优先级。
      参见:
  • 构造方法详细信息

    • 线

      public Thread()
      初始化新平台 Thread 。此构造函数与 Thread (null, null, gname) 具有相同的效果,其中 gname 是新生成的名称。自动生成的名称的格式为 "Thread-"+n, 在哪里n是一个整数。

      此构造函数仅在扩展 Thread 以覆盖 run() 方法时有用。

      参见:
    • 线

      public Thread(Runnable  task)
      初始化新平台 Thread 。此构造函数与 Thread (null, task, gname) 具有相同的效果,其中 gname 是新生成的名称。自动生成的名称的格式为 "Thread-"+n, 在哪里n是一个整数。

      对于非空任务,直接调用此构造函数等同于:

      Thread.ofPlatform().unstarted(task);  
      参数:
      task - 启动此线程时调用其 run 方法的对象。如果是 null ,这个类 run 方法什么都不做。
      参见:
    • Thread

      public Thread(ThreadGroup  group, Runnable  task)
      初始化新平台 Thread 。此构造函数与 Thread (group, task, gname) 具有相同的效果,其中 gname 是新生成的名称。自动生成的名称的格式为 "Thread-"+n, 在哪里n是一个整数。

      对于非空组和任务,直接调用此构造函数等同于:

      Thread.ofPlatform().group(group).unstarted(task);  
      参数:
      group - 线程组。如果 null 并且有安全管理器,则该组由 SecurityManager.getThreadGroup() 确定。如果没有安全管理器或 SecurityManager.getThreadGroup() 返回 null ,则组设置为当前线程的线程组。
      task - 启动此线程时调用其 run 方法的对象。如果为 null ,则调用此线程的运行方法。
      抛出:
      SecurityException - 如果当前线程不能在指定的线程组中创建线程
      参见:
    • Thread

      public Thread(String  name)
      初始化新平台 Thread 。此构造函数与 Thread (null, null, name) 具有相同的效果。

      此构造函数仅在扩展 Thread 以覆盖 run() 方法时有用。

      参数:
      name - 新线程的名称
      参见:
    • Thread

      public Thread(ThreadGroup  group, String  name)
      初始化新平台 Thread 。此构造函数与 Thread (group, null, name) 具有相同的效果。

      此构造函数仅在扩展 Thread 以覆盖 run() 方法时有用。

      参数:
      group - 线程组。如果 null 并且有安全管理器,则该组由 SecurityManager.getThreadGroup() 确定。如果没有安全管理器或 SecurityManager.getThreadGroup() 返回 null ,则组设置为当前线程的线程组。
      name - 新线程的名称
      抛出:
      SecurityException - 如果当前线程不能在指定的线程组中创建线程
      参见:
    • Thread

      public Thread(Runnable  task, String  name)
      初始化新平台 Thread 。此构造函数与 Thread (null, task, name) 具有相同的效果。

      对于非空任务和名称,直接调用此构造函数等同于:

      Thread.ofPlatform().name(name).unstarted(task);  
      参数:
      task - 启动此线程时调用其 run 方法的对象。如果为 null ,则调用此线程的运行方法。
      name - 新线程的名称
      参见:
    • Thread

      public Thread(ThreadGroup  group, Runnable  task, String  name)
      初始化新平台 Thread,使其运行对象为 task,名称为指定的 name,并且属于 group 引用的线程组。

      如果有安全管理器,它的 checkAccess 方法将以线程组作为参数调用。

      此外,当由覆盖 getContextClassLoadersetContextClassLoader 方法的子类的构造函数直接或间接调用时,其 checkPermission 方法将以 RuntimePermission("enableContextClassLoaderOverride") 权限调用。

      新创建的线程的优先级是创建它的线程的优先级和线程组允许的最大优先级中较小的一个。 setPriority 方法可用于将优先级更改为新值。

      新创建的线程最初被标记为守护线程当且仅当创建它的线程当前被标记为守护线程。 setDaemon 方法可用于更改线程是否为守护进程。

      对于非空组、任务和名称,直接调用此构造函数等同于:

      Thread.ofPlatform().group(group).name(name).unstarted(task);  
      参数:
      group - 线程组。如果 null 并且有安全管理器,则该组由 SecurityManager.getThreadGroup() 确定。如果没有安全管理器或 SecurityManager.getThreadGroup() 返回 null ,则组设置为当前线程的线程组。
      task - 启动此线程时调用其 run 方法的对象。如果为 null ,则调用此线程的运行方法。
      name - 新线程的名称
      抛出:
      SecurityException - 如果当前线程无法在指定的线程组中创建线程或无法覆盖上下文类加载器方法。
      参见:
    • Thread

      public Thread(ThreadGroup  group, Runnable  task, String  name, long stackSize)
      初始化一个新的平台 Thread,使其具有 task 作为其运行对象,具有指定的 name 作为其名称,并且属于 group 引用的线程组,并且具有指定的堆栈大小.

      此构造函数与 Thread(ThreadGroup,Runnable,String) 相同,但它允许指定线程堆栈大小。堆栈大小是虚拟机分配给该线程堆栈的地址空间的近似字节数。stackSize 参数的效果(如果有的话)高度依赖于平台。

      在某些平台上,为 stackSize 参数指定更高的值可能允许线程在抛出 StackOverflowError 之前实现更大的递归深度。类似地,指定一个较低的值可能允许更多的线程并发存在而不会抛出 OutOfMemoryError (或其他内部错误)。 stackSize 参数的值与最大递归深度和并发级别之间关系的详细信息取决于平台。在某些平台上,stackSize 参数的值可能没有任何效果。

      虚拟机可以随意将 stackSize 参数视为建议。如果指定的值对于平台来说过低,虚拟机可能会使用一些特定于平台的最小值;如果指定的值过高,虚拟机可能会使用一些特定于平台的最大值。同样,虚拟机可以根据需要随意向上或向下舍入指定值(或完全忽略它)。

      stackSize 参数指定零值将导致此构造函数的行为与 Thread(ThreadGroup, Runnable, String) 构造函数完全相同。

      由于此构造函数的行为具有平台相关性,因此在使用时应格外小心。执行给定计算所需的线程堆栈大小可能因 JRE 实现而异。鉴于这种变化,可能需要仔细调整堆栈大小参数,并且可能需要对要运行应用程序的每个 JRE 实现重复调整。

      实施注意事项:鼓励 Java 平台实施者记录其关于 stackSize 参数的实施行为。

      对于非空组、任务和名称,直接调用此构造函数等同于:

      Thread.ofPlatform().group(group).name(name).stackSize(stackSize).unstarted(task);  
      参数:
      group - 线程组。如果 null 并且有安全管理器,则该组由 SecurityManager.getThreadGroup() 确定。如果没有安全管理器或 SecurityManager.getThreadGroup() 返回 null ,则组设置为当前线程的线程组。
      task - 启动此线程时调用其 run 方法的对象。如果为 null ,则调用此线程的运行方法。
      name - 新线程的名称
      stackSize - 新线程所需的堆栈大小,或者为零以指示要忽略此参数。
      抛出:
      SecurityException - 如果当前线程不能在指定的线程组中创建线程
      自从:
      1.4
      参见:
    • Thread

      public Thread(ThreadGroup  group, Runnable  task, String  name, long stackSize, boolean inheritInheritableThreadLocals)
      初始化一个新平台 Thread,使其具有 task 作为其运行对象,具有指定的 name 作为其名称,属于 group 引用的线程组,具有指定的 stackSize,并且如果 inheritThreadLocalstrue 则继承 可继承线程本地 变量的初始值。

      此构造函数与 Thread(ThreadGroup,Runnable,String,long) 相同,但增加了抑制或不抑制从构造线程继承可继承线程局部变量初始值的能力。这允许对可继承的线程局部变量进行更精细的控制。为 inheritThreadLocals 传递 false 的值时必须小心,因为如果新线程执行期望继承特定线程局部值的代码,它可能会导致意外行为。

      inheritThreadLocals 参数指定值 true 将导致此构造函数的行为与 Thread(ThreadGroup, Runnable, String, long) 构造函数完全相同。

      对于非空组、任务和名称,直接调用此构造函数等同于:

      Thread.ofPlatform()
         .group(group)
         .name(name)
         .stackSize(stackSize)
         .inheritInheritableThreadLocals(inheritInheritableThreadLocals)
         .unstarted(task);  
      参数:
      group - 线程组。如果 null 并且有安全管理器,则该组由 SecurityManager.getThreadGroup() 确定。如果没有安全管理器或 SecurityManager.getThreadGroup() 返回 null ,则组设置为当前线程的线程组。
      task - 启动此线程时调用其 run 方法的对象。如果为 null ,则调用此线程的运行方法。
      name - 新线程的名称
      stackSize - 新线程所需的堆栈大小,或零以指示要忽略此参数
      inheritInheritableThreadLocals - 如果 true ,则从构造线程继承可继承线程局部变量的初始值,否则不继承初始值
      抛出:
      SecurityException - 如果当前线程不能在指定的线程组中创建线程
      自从:
      9
      参见:
  • 方法详情

    • currentThread

      public static Thread  currentThread()
      返回当前线程的 Thread 对象。
      返回:
      当前线程
    • yield

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

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

      使用这种方法很少是合适的。它可能对调试或测试有用,因为它可能有助于重现由于竞争条件导致的错误。在设计并发控制结构(如 java.util.concurrent.locks 包中的结构)时,它也可能很有用。

    • sleep

      public static void sleep(long millis) throws InterruptedException
      使当前正在执行的线程休眠(暂时停止执行)指定的毫秒数,具体取决于系统计时器和调度程序的精度和准确性。该线程不会失去任何监视器的所有权。
      参数:
      millis - 以毫秒为单位的休眠时间长度
      抛出:
      IllegalArgumentException - 如果 millis 的值为负
      InterruptedException - 如果有任何线程中断了当前线程。这中断状态抛出此异常时清除当前线程的。
    • sleep

      public static void sleep(long millis, int nanos) throws InterruptedException
      使当前正在执行的线程休眠(暂时停止执行)指定的毫秒数加上指定的纳秒数,这取决于系统计时器和调度程序的精度和准确性。该线程不会失去任何监视器的所有权。
      参数:
      millis - 以毫秒为单位的休眠时间长度
      nanos - 0-999999 额外的纳秒睡眠时间
      抛出:
      IllegalArgumentException - 如果 millis 的值为负数,或者 nanos 的值不在 0-999999 范围内
      InterruptedException - 如果有任何线程中断了当前线程。这中断状态抛出此异常时清除当前线程的。
    • sleep

      public static void sleep(Duration  duration) throws InterruptedException
      根据系统计时器和调度程序的精度和准确性,使当前正在执行的线程在指定的持续时间内休眠(暂时停止执行)。如果持续时间为 消极的,则此方法为空操作。
      参数:
      duration - 睡眠持续时间
      抛出:
      InterruptedException - 如果当前线程在休眠时被中断。这中断状态抛出此异常时清除当前线程的。
      自从:
      19
    • onSpinWait

      public static void onSpinWait()
      指示调用者暂时无法进行,直到其他活动的一个或多个操作发生为止。通过在自旋等待循环构造的每次迭代中调用此方法,调用线程向运行时指示它正在忙等待。运行时可能会采取措施来提高调用自旋等待循环构造的性能。
      API 注意:
      作为一个例子,考虑一个类中的方法,它在一个循环中旋转,直到在该方法之外设置了一些标志。对 onSpinWait 方法的调用应该放在自旋循环内。
        class EventHandler {
          volatile boolean eventNotificationNotReceived;
          void waitForEventAndHandleIt() {
            while ( eventNotificationNotReceived ) {
              Thread.onSpinWait();
            }
            readAndProcessEvent();
          }
      
          void readAndProcessEvent() {
            // Read event from some source and process it
             . . .
          }
        }
       

      即使根本没有调用 onSpinWait 方法,上面的代码也会保持正确。然而,在某些架构上,Java 虚拟机可能会发出处理器指令,以更有利的方式处理此类代码模式。

      自从:
      9
    • ofPlatform

      public static Thread.Builder.OfPlatform PREVIEW  ofPlatform()
      ofPlatform 是 Java 平台的预览 API。
      程序只能在启用预览功能时使用 ofPlatform
      预览功能可能会在未来的版本中删除,或升级为 Java 平台的永久功能。
      返回用于创建平台线程的构建器 ThreadThreadFactory

      创建平台线程时与安全管理器的交互

      在设置了安全管理器时创建平台线程将使用线程的线程组调用安全管理器的 checkAccess(ThreadGroup) 方法。如果线程组没有设置OfPlatform.group PREVIEW 方法然后将首先调用安全管理器的getThreadGroup 方法来选择线程组。如果安全管理器 getThreadGroup 方法返回 null 则使用构造线程的线程组。

      API 注意:
      以下是使用构建器的示例:
       // Start a daemon thread to run a task
       Thread thread = Thread.ofPlatform().daemon().start(runnable);
      
       // Create an unstarted thread with name "duke", its start() method
       // must be invoked to schedule it to execute.
       Thread thread = Thread.ofPlatform().name("duke").unstarted(runnable);
      
       // A ThreadFactory that creates daemon threads named "worker-0", "worker-1", ...
       ThreadFactory factory = Thread.ofPlatform().daemon().name("worker-", 0).factory();
       
      返回:
      用于创建 ThreadThreadFactory 对象的生成器。
      自从:
      19
    • ofVirtual

      public static Thread.Builder.OfVirtual PREVIEW  ofVirtual()
      ofVirtual 是 Java 平台的预览 API。
      程序只能在启用预览功能时使用 ofVirtual
      预览功能可能会在未来的版本中删除,或升级为 Java 平台的永久功能。
      返回用于创建创建虚拟线程的虚拟 ThreadThreadFactory 的构建器。
      API 注意:
      以下是使用构建器的示例:
       // Start a virtual thread to run a task.
       Thread thread = Thread.ofVirtual().start(runnable);
      
       // A ThreadFactory that creates virtual threads
       ThreadFactory factory = Thread.ofVirtual().factory();
       
      返回:
      用于创建 ThreadThreadFactory 对象的生成器。
      抛出:
      UnsupportedOperationException - 如果未启用预览功能
      自从:
      19
    • clone

      protected Object  clone() throws CloneNotSupportedException
      抛出 CloneNotSupportedException 作为线程无法有意义地克隆。而是构造一个新线程。
      重写:
      clone 在类 Object
      返回:
      此实例的克隆。
      抛出:
      CloneNotSupportedException - 总是
      参见:
    • startVirtualThread

      public static Thread  startVirtualThread(Runnable  task)
      startVirtualThread 是 Java 平台的预览 API。
      程序只能在启用预览功能时使用 startVirtualThread
      预览功能可能会在未来的版本中删除,或升级为 Java 平台的永久功能。
      创建一个虚拟线程来执行任务并安排它执行。

      此方法等效于:

      Thread.ofVirtual().start(task);  
      参数:
      task - 线程执行时要运行的对象
      返回:
      一个新的、已启动的虚拟线程
      抛出:
      UnsupportedOperationException - 如果未启用预览功能
      自从:
      19
      参见:
    • isVirtual

      public final boolean isVirtual()
      isVirtual 是 Java 平台的预览 API。
      程序只能在启用预览功能时使用 isVirtual
      预览功能可能会在未来的版本中删除,或升级为 Java 平台的永久功能。
      如果此线程是虚拟线程,则返回 true。虚拟线程是由 Java 虚拟机而不是操作系统来调度的。
      返回:
      true 如果这个线程是虚拟线程
      自从:
      19
    • start

      public void start()
      安排此线程开始执行。该线程将独立于当前线程执行。

      一个线程最多可以启动一次。特别是,线程在终止后不能重新启动。

      抛出:
      IllegalThreadStateException - 如果线程已经启动
    • run

      public void run()
      该方法在执行时由线程运行。 Thread 的子类可能会覆盖此方法。

      此方法不应直接调用。如果此线程是使用 Runnable 任务创建的平台线程,则调用此方法将调用任务的 run 方法。如果这个线程是一个虚拟线程,那么直接调用这个方法什么都不做。

      指定者:
      run 在接口 Runnable
      实现要求:
      默认实现执行创建 ThreadRunnable 任务。如果线程是在没有任务的情况下创建的,则此方法不执行任何操作。
    • stop

      @Deprecated (since ="1.2", forRemoval =true) public final void stop()
      已弃用,将被删除:此 API 元素可能会在未来版本中删除。
      此方法最初指定为通过使受害线程抛出 ThreadDeath 来“停止”受害线程。它本质上是不安全的。停止线程会导致它解锁所有已锁定的监视器(作为 ThreadDeath 异常向上传播堆栈的自然结果)。如果之前受这些监视器保护的任何对象处于不一致状态,则损坏的对象对其他线程可见,可能导致任意行为。 stop 的用法应替换为仅修改某些变量以指示目标线程应停止运行的代码。目标线程应该定期检查这个变量,如果变量指示它要停止运行,则从它的 run 方法有序地返回。如果目标线程等待很长时间(例如,在条件变量上),则应使用 interrupt 方法来中断等待。有关详细信息,请参阅 为什么不推荐使用Thread.stop 、 Thread.suspend和Thread.resume ?
      抛出 UnsupportedOperationException
      抛出:
      UnsupportedOperationException - 总是
    • interrupt

      public void interrupt()
      中断此线程。

      除非当前线程正在中断自身(这始终是允许的),否则将调用此线程的 checkAccess 方法,这可能会导致抛出 SecurityException

      如果此线程在调用 wait() wait(long) wait(long, int) Object 类的方法或 join() join(long) join(long, int) sleep(long) sleep(long, int) 的方法时被阻塞这个类的方法,然后它的中断状态将被清除,它会收到 InterruptedException

      如果此线程在 InterruptibleChannel 上的 I/O 操作中被阻塞,则通道将关闭,线程的中断状态将被设置,线程将收到 ClosedByInterruptException

      如果此线程在 Selector 中被阻塞,则将设置线程的中断状态,并且它将立即从选择操作返回,可能返回非零值,就像调用选择器的 wakeup 方法一样。

      如果前面的条件都不成立,那么将设置该线程的中断状态。

      中断一个不活动的线程不需要有任何影响。

      实现注意事项:
      在 JDK Reference Implementation 中,非活动线程的中断仍然记录中断请求已发出,并将通过 interruptedisInterrupted() 报告。
      抛出:
      SecurityException - 如果当前线程不能修改这个线程
    • interrupted

      public static boolean interrupted()
      测试当前线程是否被中断。这中断状态通过此方法清除线程的。换句话说,如果连续调用此方法两次,则第二次调用将返回 false(除非当前线程再次被中断,在第一次调用清除其中断状态之后,第二次调用检查它之前)。
      返回:
      true如果当前线程已经被中断; false否则。
      参见:
    • isInterrupted

      public boolean isInterrupted()
      测试此线程是否已被中断。这中断状态线程不受此方法的影响。
      返回:
      true 如果此线程已被中断; false否则。
      参见:
    • isAlive

      public final boolean isAlive()
      测试此线程是否存活。如果线程已启动且尚未终止,则该线程处于活动状态。
      返回:
      true 如果这个线程还活着; false否则。
    • suspend

      @Deprecated (since ="1.2", forRemoval =true) public final void suspend()
      已弃用,将被删除:此 API 元素可能会在未来版本中删除。
      该方法最初指定用于挂起线程。它本质上很容易出现死锁。如果目标线程在挂起时锁定保护关键系统资源的监视器,则在目标线程恢复之前,任何线程都无法访问该资源。如果打算恢复目标线程的线程在调用 resume 之前尝试锁定监视器,则会导致死锁。这种死锁通常表现为“冻结”进程。有关详细信息,请参阅 为什么不推荐使用Thread.stop 、 Thread.suspend和Thread.resume ?
      抛出 UnsupportedOperationException
      抛出:
      UnsupportedOperationException - 总是
    • resume

      @Deprecated (since ="1.2", forRemoval =true) public final void resume()
      已弃用,将被删除:此 API 元素可能会在未来版本中删除。
      此方法最初指定用于恢复使用 suspend() 挂起的线程。挂起线程本质上很容易发生死锁。有关详细信息,请参阅 为什么不推荐使用Thread.stop 、 Thread.suspend和Thread.resume ?
      抛出 UnsupportedOperationException
      抛出:
      UnsupportedOperationException - 总是
    • setPriority

      public final void setPriority(int newPriority)
      更改此线程的优先级。对于平台线程,优先级设置为指定的 newPriority 和线程的 线程组 的最大允许优先级中的较小者。虚拟线程的优先级始终是 NORM_PRIORITY 并且 newPriority 被忽略。
      参数:
      newPriority - 新线程优先级
      抛出:
      IllegalArgumentException - 如果优先级不在 MIN_PRIORITYMAX_PRIORITY 范围内。
      SecurityException - 如果checkAccess() 确定当前线程不能修改这个线程
      参见:
    • getPriority

      public final int getPriority()
      返回此线程的优先级。

      虚拟线程的优先级始终是 NORM_PRIORITY

      返回:
      这个线程的优先级。
      参见:
    • setName

      public final void setName(String  name)
      将此线程的名称更改为等于参数 name

      首先调用此线程的 checkAccess 方法,不带参数。这可能会导致抛出 SecurityException

      实现注意事项:
      在 JDK 参考实现中,如果此线程是当前线程,并且是未附加到具有 Java 本机接口 AttachCurrentThread 函数的 VM 的平台线程,则此方法将设置操作系统线程名称。这可能对调试和故障排除很有用。
      参数:
      name - 此线程的新名称。
      抛出:
      SecurityException - 如果当前线程无法修改此线程。
      参见:
    • getName

      public final String  getName()
      返回此线程的名称。
      返回:
      这个线程的名称。
      参见:
    • getThreadGroup

      public final ThreadGroup  getThreadGroup()
      如果线程已终止,则返回线程的线程组或 null

      为虚拟线程返回的线程组是特殊的 ThreadGroup for virtual threads

      返回:
      此线程的线程组或 null
    • activeCount

      public static int activeCount()
      返回当前线程的线程组及其子组中 居住 平台线程数的估计值。估计中不包括虚拟线程。

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

      返回:
      当前线程的线程组和以当前线程的线程组为祖先的任何其他线程组中实时平台线程数的估计
    • enumerate

      public static int enumerate(Thread [] tarray)
      将当前线程的线程组及其子组中的每个 居住 平台线程复制到指定数组中。此方法只是调用当前线程的线程组的ThreadGroup.enumerate(Thread[]) 方法。此方法不枚举虚拟线程。

      然而,应用程序可能会使用 activeCount 方法来估计数组的大小如果数组太短无法容纳所有线程,则多余的线程将被忽略。如果获取当前线程的线程组及其子组中的每个活动线程至关重要,则调用程序应验证返回的 int 值是否严格小于 tarray 的长度。

      由于此方法中固有的竞争条件,建议仅将此方法用于调试和监视目的。

      参数:
      tarray - 用于放置线程列表的数组
      返回:
      放入数组的线程数
      抛出:
      SecurityException - 如果 ThreadGroup.checkAccess() 确定当前线程无法访问其线程组
    • countStackFrames

      @Deprecated (since ="1.2", forRemoval =true) public int countStackFrames()
      已弃用,将被删除:此 API 元素可能会在未来版本中删除。
      此方法最初设计用于计算堆栈帧的数量,但结果从未明确定义,并且它依赖于线程挂起。此方法在 Java SE 的未来版本中可能会被删除。
      抛出 UnsupportedOperationException
      返回:
      没有什么
      参见:
    • join

      public final void join(long millis) throws InterruptedException
      此线程终止最多等待 millis 毫秒。 0 的超时意味着永远等待。如果线程尚未 started ,则此方法立即返回,无需等待。
      实现注意事项:
      对于平台线程,实现使用以 this.isAlive 为条件的 this.wait 调用循环。当线程终止时,将调用 this.notifyAll 方法。建议应用程序不要在 Thread 实例上使用 waitnotifynotifyAll
      参数:
      millis - 以毫秒为单位的等待时间
      抛出:
      IllegalArgumentException - 如果 millis 的值为负
      InterruptedException - 如果有任何线程中断了当前线程。这中断状态抛出此异常时清除当前线程的。
    • join

      public final void join(long millis, int nanos) throws InterruptedException
      最多等待 millis 毫秒加上 nanos 纳秒,以便此线程终止。如果两个参数都是 0 ,则意味着永远等待。如果线程尚未 started ,则此方法立即返回,无需等待。
      实现注意事项:
      对于平台线程,实现使用以 this.isAlive 为条件的 this.wait 调用循环。当线程终止时,将调用 this.notifyAll 方法。建议应用程序不要在 Thread 实例上使用 waitnotifynotifyAll
      参数:
      millis - 以毫秒为单位的等待时间
      nanos - 0-999999 等待的额外纳秒
      抛出:
      IllegalArgumentException - 如果 millis 的值为负数,或者 nanos 的值不在 0-999999 范围内
      InterruptedException - 如果有任何线程中断了当前线程。这中断状态抛出此异常时清除当前线程的。
    • join

      public final void join() throws InterruptedException
      等待此线程终止。

      此方法的调用与调用的行为完全相同

      join (0)
      抛出:
      InterruptedException - 如果有任何线程中断了当前线程。这中断状态抛出此异常时清除当前线程的。
    • join

      public final boolean join(Duration  duration) throws InterruptedException
      等待此线程终止直至给定的等待持续时间。

      如果等待持续时间小于或等于零,则此方法不会等待。在这种情况下,该方法仅测试线程是否已终止。

      参数:
      duration - 最长等待时间
      返回:
      true 如果线程已终止,false 如果线程尚未终止
      抛出:
      InterruptedException - 如果当前线程在等待时被中断。这中断状态抛出此异常时清除当前线程的。
      IllegalThreadStateException - 如果此线程尚未启动。
      自从:
      19
    • dumpStack

      public static void dumpStack()
      将当前线程的堆栈跟踪打印到标准错误流。此方法对调试很有用。
    • setDaemon

      public final void setDaemon(boolean on)
      将此线程标记为daemon或者non-daemon线。 关机顺序 在所有启动的非守护线程终止时开始。

      虚拟线程的守护进程状态始终为 true 并且不能通过此方法更改为 false

      必须在线程启动之前调用此方法。未指定线程终止时此方法的行为。

      参数:
      on - 如果是 true ,则将此线程标记为守护线程
      抛出:
      IllegalArgumentException - 如果这是一个虚拟线程并且 on 为假
      IllegalThreadStateException - 如果这个线程是
      SecurityException - 如果checkAccess() 确定当前线程不能修改这个线程
    • isDaemon

      public final boolean isDaemon()
      测试此线程是否是守护线程。虚拟线程的守护进程状态始终为 true
      返回:
      true 如果这个线程是守护线程; false否则。
      参见:
    • checkAccess

      @Deprecated (since ="17", forRemoval =true) public final void checkAccess()
      已弃用,将被删除:此 API 元素可能会在未来版本中删除。
      此方法仅与 安全管理器 结合使用,已弃用并在未来版本中删除。因此,此方法也已弃用并可能被删除。安全管理器或此方法没有替代品。
      确定当前运行的线程是否有权修改此线程。

      如果有一个安全管理器,它的 checkAccess 方法被调用,这个线程作为它的参数。这可能会导致抛出 SecurityException

      抛出:
      SecurityException - 如果不允许当前线程访问该线程。
      参见:
    • toString

      public String  toString()
      返回此线程的字符串表示形式。字符串表示通常包括线程的 identifier 和名称。平台线程的默认实现包括线程的标识符、名称、优先级和线程组的名称。
      重写:
      toString 在类 Object
      返回:
      此线程的字符串表示形式。
    • getContextClassLoader

      public ClassLoader  getContextClassLoader()
      返回此线程的上下文 ClassLoader。上下文 ClassLoader 可以由线程的创建者设置,供在加载类和资源时在此线程中运行的代码使用。如果不是 set ,默认是从父线程继承上下文类加载器。

      原始线程的上下文ClassLoader 通常设置为用于加载应用程序的类加载器。

      返回:
      此线程的上下文 ClassLoader,或指示系统类加载器的 null(或者,如果失败,引导类加载器)
      抛出:
      SecurityException - 如果存在安全管理器,并且调用者的类加载器不是 null 并且与上下文类加载器不同或不是其祖先,并且调用者没有 RuntimePermission ("getClassLoader")
      自从:
      1.2
    • setContextClassLoader

      public void setContextClassLoader(ClassLoader  cl)
      为此线程设置上下文 ClassLoader

      上下文 ClassLoader 可以由线程的创建者设置,供在加载类和资源时在此线程中运行的代码使用。

      当线程为 不允许 时无法设置上下文 ClassLoaderPREVIEW 拥有自己的线程局部变量副本。

      如果存在安全管理器,则使用 RuntimePermission ("setContextClassLoader") 权限调用其 checkPermission 方法,以查看是否允许设置上下文 ClassLoader。

      参数:
      cl - 此线程的上下文类加载器,或 null 表示系统类加载器(或者,如果失败,引导类加载器)
      抛出:
      UnsupportedOperationException - 如果不允许此线程为其线程局部变量副本设置值
      SecurityException - 如果当前线程无法设置上下文 ClassLoader
      自从:
      1.2
    • holdsLock

      public static boolean holdsLock(Object  obj)
      当且仅当当前线程持有指定对象上的监视器锁时,才返回 true

      此方法旨在允许程序断言当前线程已持有指定的锁:

         assert Thread.holdsLock(obj);
       
      参数:
      obj - 测试锁所有权的对象
      返回:
      true 如果当前线程持有指定对象上的监视器锁。
      自从:
      1.4
    • getStackTrace

      public StackTraceElement [] getStackTrace()
      返回表示此线程的堆栈转储的堆栈跟踪元素数组。如果此线程尚未启动、已启动但尚未被系统安排运行或已终止,则此方法将返回一个零长度数组。如果返回的数组长度不为零,则数组的第一个元素表示堆栈的顶部,这是序列中最近的方法调用。数组的最后一个元素代表堆栈的底部,这是序列中最近最少的方法调用。

      如果有安全管理器,并且该线程不是当前线程,则以RuntimePermission("getStackTrace")权限调用安全管理器的checkPermission方法以查看是否可以获取堆栈跟踪。

      在某些情况下,某些虚拟机可能会从堆栈跟踪中省略一个或多个堆栈帧。在极端情况下,没有关于此线程的堆栈跟踪信息的虚拟机被允许从此方法返回零长度数组。

      返回:
      StackTraceElement 的数组,每个代表一个堆栈帧。
      抛出:
      SecurityException - 如果安全管理器存在且其 checkPermission 方法不允许获取线程的堆栈跟踪。
      自从:
      1.5
      参见:
    • getAllStackTraces

      public static Map <Thread ,StackTraceElement []> getAllStackTraces()
      返回所有实时平台线程的堆栈跟踪映射。该map不包括虚拟线程。映射键是线程,每个映射值是一个 StackTraceElement 数组,表示相应 Thread 的堆栈转储。返回的堆栈跟踪采用为 getStackTrace 方法指定的格式。

      调用此方法时线程可能正在执行。每个线程的stack trace只代表一个快照,每个stack trace可以在不同的时间获得。如果虚拟机没有关于线程的堆栈跟踪信息,则映射值中将返回一个零长度数组。

      如果有安全管理器,则使用RuntimePermission("getStackTrace")权限以及RuntimePermission("modifyThreadGroup")权限调用安全管理器的checkPermission方法,以查看是否可以获取所有线程的堆栈跟踪。

      返回:
      MapThreadStackTraceElement 的数组,表示相应线程的堆栈跟踪。
      抛出:
      SecurityException - 如果安全管理器存在且其 checkPermission 方法不允许获取线程的堆栈跟踪。
      自从:
      1.5
      参见:
    • getId

      @Deprecated (since ="19") public long getId()
      已弃用。
      此方法不是最终方法,可能会被重写以返回一个不是线程 ID 的值。请改用 threadId()
      返回此线程的标识符。线程 ID 是创建此线程时生成的正数 long。线程 ID 是唯一的,并且在其生命周期内保持不变。
      返回:
      这个线程的ID
      自从:
      1.5
    • threadId

      public final long threadId()
      返回此线程的标识符。线程 ID 是创建此线程时生成的正数 long。线程 ID 是唯一的,并且在其生命周期内保持不变。
      返回:
      这个线程的ID
      自从:
      19
    • getState

      public Thread.State  getState()
      返回此线程的状态。此方法设计用于监视系统状态,而不用于同步控制。
      返回:
      这个线程的状态。
      自从:
      1.5
    • setDefaultUncaughtExceptionHandler

      public static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler  ueh)
      设置当线程由于未捕获的异常而突然终止时调用的默认处理程序,并且没有为该线程定义其他处理程序。

      未捕获的异常处理首先由线程控制,然后由线程的 ThreadGroup 对象控制,最后由默认的未捕获异常处理程序控制。如果线程没有显式设置未捕获的异常处理程序,并且线程的线程组(包括父线程组)未专门化其 uncaughtException 方法,则将调用默认处理程序的 uncaughtException 方法。

      已经接受系统提供的任何“默认”行为的线程更改未捕获异常的处理方式(例如记录到特定设备或文件)。

      请注意,默认的未捕获异常处理程序通常不应遵循线程的 ThreadGroup 对象,因为这可能导致无限递归。

      参数:
      ueh - 用作默认未捕获异常处理程序的对象。如果 null 则没有默认处理程序。
      抛出:
      SecurityException - 如果安全管理器存在并且它拒绝 RuntimePermission ("setDefaultUncaughtExceptionHandler")
      自从:
      1.5
      参见:
    • getDefaultUncaughtExceptionHandler

      public static Thread.UncaughtExceptionHandler  getDefaultUncaughtExceptionHandler()
      返回当线程由于未捕获的异常而突然终止时调用的默认处理程序。如果返回值为 null ,则没有默认值。
      返回:
      所有线程的默认未捕获异常处理程序
      自从:
      1.5
      参见:
    • getUncaughtExceptionHandler

      public Thread.UncaughtExceptionHandler  getUncaughtExceptionHandler()
      返回当此线程由于未捕获的异常而突然终止时调用的处理程序。如果该线程没有显式设置未捕获的异常处理程序,则返回该线程的 ThreadGroup 对象,除非该线程已终止,在这种情况下返回 null
      返回:
      此线程的未捕获异常处理程序
      自从:
      1.5
    • setUncaughtExceptionHandler

      public void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler  ueh)
      设置此线程由于未捕获的异常而突然终止时调用的处理程序。

      通过显式设置未捕获的异常处理程序,线程可以完全控制它如何响应未捕获的异常。如果没有设置这样的处理程序,则线程的 ThreadGroup 对象充当其处理程序。

      参数:
      ueh - 用作此线程的未捕获异常处理程序的对象。如果为 null,则此线程没有显式处理程序。
      抛出:
      SecurityException - 如果当前线程不允许修改此线程。
      自从:
      1.5
      参见: