鸿蒙OS Thread

Thread

java.lang.Object

|—java.lang.Thread

public class Thread
extends Object
implements Runnable

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

每个线程都有一个优先级。具有较高优先级的线程优先于具有较低优先级的线程执行。每个线程可能会也可能不会被标记为守护进程。当在某个线程中运行的代码创建一个新的 Thread 对象时，新线程的优先级最初设置为等于创建线程的优先级，并且当且仅当创建线程是守护进程时，它才是守护线程。

当 Java 虚拟机启动时，通常有一个非守护线程（通常调用某个指定类的名为 main 的方法）。 Java 虚拟机继续执行线程，直到发生以下任一情况：

• 已调用 Runtime 类的退出方法，并且安全管理器已允许进行退出操作。
• 所有不是守护线程的线程都已经死亡，要么从调用 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 方法。 然后可以分配一个类的实例，在创建线程时作为参数传递，然后启动。 这种其他样式的相同示例如下所示：

     class PrimeRun implements 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();

 

每个线程都有一个用于识别目的的名称。 多个线程可能具有相同的名称。 如果在创建线程时未指定名称，则会为其生成一个新名称。

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

嵌套类摘要

字段摘要

构造函数摘要

方法总结

字段详细信息

MAX_PRIORITY

public static final int MAX_PRIORITY

线程可以拥有的最大优先级。

MIN_PRIORITY

public static final int MIN_PRIORITY

线程可以拥有的最低优先级。

NORM_PRIORITY

public static final int NORM_PRIORITY

分配给线程的默认优先级。

构造函数详细信息

Thread

public Thread()

分配一个新的 Thread 对象。 此构造函数与 Thread (null, null, gname) 的效果相同，其中 gname 是新生成的名称。 自动生成的名称格式为“Thread-”+n，其中 n 是整数。

Thread

public Thread(Runnable target)

分配一个新的 Thread 对象。 此构造函数与 Thread (null, target, gname) 的效果相同，其中 gname 是新生成的名称。 自动生成的名称格式为“Thread-”+n，其中 n 是整数。

参数：

Thread

public Thread(ThreadGroup group, Runnable target)

分配一个新的 Thread 对象。 此构造函数与 Thread (group, target, gname) 具有相同的效果，其中 gname 是新生成的名称。 自动生成的名称格式为“Thread-”+n，其中 n 是整数。

参数：

Throws:

Thread

public Thread(String name)

分配一个新的 Thread 对象。 此构造函数与 Thread (null, null, name) 具有相同的效果。

参数：

Thread

public Thread(ThreadGroup group, String name)

分配一个新的 Thread 对象。 此构造函数与 Thread (group, null, name) 具有相同的效果。

参数：

Throws:

Thread

public Thread(Runnable target, String name)

分配一个新的 Thread 对象。 此构造函数与 Thread (null, target, name) 具有相同的效果。

参数：

Thread

public Thread(ThreadGroup group, Runnable target, String name)

分配一个新的 Thread 对象，使其以 target 作为其运行对象，以指定的名称作为其名称，并属于 group 所引用的线程组。

如果有安全管理器，则使用 ThreadGroup 作为其参数调用其 SecurityManager#checkAccess(ThreadGroup) 方法。

此外，当覆盖 getContextClassLoader 或 setContextClassLoader 方法的子类的构造函数直接或间接调用时，它的 checkPermission 方法使用 RuntimePermission(“enableContextClassLoaderOverride”) 权限调用。

新创建线程的优先级设置为等于创建它的线程的优先级，即当前运行的线程。方法 setPriority 可用于将优先级更改为新值。

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

参数：

Throws:

Thread

public Thread(ThreadGroup group, Runnable target, String name, long stackSize)

分配一个新的 Thread 对象，使其以 target 作为其运行对象，以指定的名称作为其名称，并属于由 group 引用的线程组，并具有指定的堆栈大小。

此构造函数与 Thread(java.lang.ThreadGroup,java.lang.Runnable,java.lang.String) 相同，只是它允许指定线程堆栈大小。堆栈大小是虚拟机要为此线程堆栈分配的地址空间的近似字节数。 stackSize 参数的影响（如果有）高度依赖于平台。

在某些平台上，为 stackSize 参数指定更高的值可能允许线程在抛出 StackOverflowError 之前实现更大的递归深度。类似地，指定较低的值可能允许更多线程同时存在，而不会引发 OutOfMemoryError（或其他内部错误）。 stackSize 参数的值与最大递归深度和并发级别之间的关系细节取决于平台。在某些平台上，stackSize 参数的值可能没有任何影响。

虚拟机可以自由地将 stackSize 参数视为建议。如果平台的指定值过低，虚拟机可能会使用一些特定于平台的最小值；如果指定的值过高，则虚拟机可能会改为使用某些特定于平台的最大值。同样，虚拟机可以随意向上或向下舍入指定的值（或完全忽略它）。

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

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

实现说明：鼓励 Java 平台实现者记录其实现与 stackSize 参数相关的行为。

参数：

Throws:

方法详情

currentThread

public static Thread currentThread()

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

返回:

当前正在执行的线程。

yield

public static void yield()

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

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

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

sleep

public static void sleep(long millis) throws InterruptedException

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

参数：

Throws:

sleep

public static void sleep(long millis, int nanos) throws InterruptedException

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

参数：

Throws:

clone

protected Object clone() throws CloneNotSupportedException

抛出 CloneNotSupportedException，因为 Thread 不能被有意义地克隆。 而是构建一个新线程。

覆盖：

在类 Object 中克隆

返回:

此实例的克隆。

Throws:

start

public void start()

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

结果是两个线程同时运行：当前线程（从对 start 方法的调用返回）和另一个线程（执行其 run 方法）。

多次启动一个线程是不合法的。 特别是，线程一旦完成执行就可能不会重新启动。

抛出：

run

public void run()

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

Thread 的子类应覆盖此方法。

指定者：

在接口 Runnable 中运行

stop

@Deprecated public final void stop()

已弃用。这种方法本质上是不安全的。使用 Thread.stop 停止线程会导致它解锁所有已锁定的监视器（这是未经检查的 ThreadDeath 异常沿堆栈传播的自然结果）。如果以前受这些监视器保护的任何对象处于不一致状态，则损坏的对象将对其他线程可见，从而可能导致任意行为。停止的许多用法应该由简单地修改一些变量以指示目标线程应该停止运行的代码替换。目标线程应该定期检查这个变量，如果变量指示它要停止运行，则以有序的方式从它的run方法返回。如果目标线程等待很长时间（例如在条件变量上），则应使用中断方法来中断等待。

强制线程停止执行。

如果安装了安全管理器，则调用其 checkAccess 方法，并将 this 作为其参数。这可能会导致引发 SecurityException（在当前线程中）。

如果此线程与当前线程不同（即当前线程试图停止除自身之外的线程），则另外调用安全管理器的 checkPermission 方法（带有 RuntimePermission(“stopThread”) 参数）。同样，这可能会导致抛出 SecurityException（在当前线程中）。

这个线程所代表的线程被强制停止它正在做的任何异常，并抛出一个新创建的 ThreadDeath 对象作为异常。

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

应用程序通常不应该尝试捕获 ThreadDeath，除非它必须执行一些特别的清理操作（请注意，抛出 ThreadDeath 会导致 try 语句的 finally 子句在线程正式终止之前执行）。如果一个 catch 子句捕获了一个 ThreadDeath 对象，那么重新抛出该对象以使线程真正终止是很重要的。

如果未捕获的异常是 ThreadDeath 的实例，则对其他未捕获的异常做出反应的顶级错误处理程序不会打印出消息或以其他方式通知应用程序。

Throws:

stop

@Deprecated public final void stop(Throwable obj)

已弃用。 此方法最初旨在强制线程停止并将给定的 Throwable 作为异常抛出。 它本质上是不安全的（有关详细信息，请参阅 stop()），此外，它还可用于生成目标线程未准备好处理的异常。

引发 UnsupportedOperationException。

参数：

interrupt

public void interrupt()

中断这个线程。

除非当前线程正在中断自己，这总是允许的，否则会调用该线程的 checkAccess 方法，这可能会导致抛出 SecurityException。

如果此线程在调用 Object 类的 Object#wait()、Object#wait(long) 或 Object#wait(long, int) 方法或 join()、join(long) 方法时被阻塞， join(long,int)、sleep(long) 或 sleep(long,int) 方法，则其中断状态将被清除并收到 InterruptedException。

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

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

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

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

Throws:

interrupted

public static boolean interrupted()

测试当前线程是否被中断。 通过该方法清除线程的中断状态。 换句话说，如果这个方法被连续调用两次，第二次调用将返回 false（除非当前线程再次被中断，在第一次调用清除其中断状态之后，第二次调用检查它之前）。

由于在中断时线程不活动而被忽略的线程中断将通过此方法返回 false 来反映。

返回:

如果当前线程已被中断，则为 true； 否则为false。

isInterrupted

public boolean isInterrupted()

测试此线程是否已被中断。 线程的中断状态不受此方法的影响。

由于在中断时线程不活动而被忽略的线程中断将通过此方法返回 false 来反映。

返回:

如果此线程已被中断，则为 true； 否则为 false。

destroy

@Deprecated public void destroy()

已弃用。 此方法最初设计用于在不进行任何清理的情况下销毁此线程。 它持有的任何监视器都将保持锁定状态。 但是，该方法从未实施。 如果要实现的话，它会像suspend()那样容易死锁。 如果目标线程在关键系统资源被销毁时持有保护它的锁，则没有线程可以再次访问该资源。 如果另一个线程曾经试图锁定这个资源，就会导致死锁。 这种死锁通常表现为“冻结”进程。

引发 NoSuchMethodError。

Throws:

isAlive

public final boolean isAlive()

测试此线程是否存在。 如果线程已启动且尚未死亡，则该线程处于活动状态。

返回:

如果该线程还活着，则为 true； 否则为false。

suspend

@Deprecated public final void suspend()

已弃用。 此方法已被弃用，因为它本质上容易死锁。 如果目标线程在暂停时对保护关键系统资源的监视器持有锁，则在目标线程恢复之前没有线程可以访问该资源。 如果将恢复目标线程的线程在调用 resume 之前尝试锁定此监视器，则会导致死锁。 这种死锁通常表现为“冻结”进程。

暂停此线程。

首先，调用该线程的 checkAccess 方法时不带任何参数。 这可能会导致抛出 SecurityException（在当前线程中）。

如果线程是活动的，它会被挂起并且不会继续前进，除非它被恢复。

Throws:

resume

@Deprecated public final void resume()

已弃用。 此方法仅用于与suspend() 一起使用，该方法已被弃用，因为它容易发生死锁。

恢复挂起的线程。

首先，调用该线程的 checkAccess 方法时不带任何参数。 这可能会导致抛出 SecurityException（在当前线程中）。

如果线程处于活动状态但被挂起，它会被恢复并被允许在其执行中取得进展。

Throws:

setPriority

public final void setPriority(int newPriority)

更改此线程的优先级。

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

否则，此线程的优先级设置为指定的 newPriority 和线程的线程组的最大允许优先级中的较小者。

参数：

Throws:

getPriority

public final int getPriority()

返回此线程的优先级。

返回:

这个线程的优先级。

setName

public final void setName(String name)

将此线程的名称更改为等于参数名称。

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

参数：

Throws:

getName

public final String getName()

返回此线程的名称。

返回:

此线程的名称。

getThreadGroup

public final ThreadGroup getThreadGroup()

返回该线程所属的线程组。 如果此线程已终止（已停止），则此方法返回 null。

返回:

此线程的线程组。

activeCount

public static int activeCount()

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

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

返回:

当前线程的线程组和以当前线程的线程组为祖先的任何其他线程组中的活动线程数的估计

enumerate

public static int enumerate(Thread[] tarray)

将当前线程的线程组及其子组中的每个活动线程复制到指定的数组中。 该方法只是调用当前线程的线程组的 [ThreadGroup.enumerate(Thread]) 方法。

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

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

参数：

返回:

放入数组的线程数

Throws:

countStackFrames

@Deprecated public int countStackFrames()

已弃用。 此调用的定义取决于已弃用的suspend()。 此外，此调用的结果从未明确定义。

计算此线程中的堆栈帧数。 线程必须暂停。

返回:

此线程中的堆栈帧数。

Throws:

join

public final void join(long millis) throws InterruptedException

最多等待几毫秒让该线程终止。 超时 0 意味着永远等待。

此实现使用以 this.isAlive 为条件的 this.wait 调用循环。 当线程终止时，将调用 this.notifyAll 方法。 建议应用程序不要在 Thread 实例上使用 wait、notify 或 notifyAll。

参数：

Throws:

join

public final void join(long millis, int nanos) throws InterruptedException

最多等待毫秒毫秒加上纳秒纳秒以使该线程终止。

此实现使用以 this.isAlive 为条件的 this.wait 调用循环。 当线程终止时，将调用 this.notifyAll 方法。 建议应用程序不要在 Thread 实例上使用 wait、notify 或 notifyAll。

参数：

Throws:

join

public final void join() throws InterruptedException

等待这个线程死掉。

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

join(0)

Throws:

dumpStack

public static void dumpStack()

将当前线程的堆栈跟踪打印到标准错误流。 此方法仅用于调试。

setDaemon

public final void setDaemon(boolean on)

将此线程标记为守护线程或用户线程。 当唯一运行的线程都是守护线程时，Java 虚拟机退出。

此方法必须在线程启动之前调用。

参数：

Throws:

isDaemon

public final boolean isDaemon()

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

返回:

如果此线程是守护线程，则为 true； 否则为假。

checkAccess

public final void checkAccess()

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

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

Throws:

toString

public String toString()

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

覆盖：

类 Object 中的 toString

返回:

此线程的字符串表示形式。

getContextClassLoader

public ClassLoader getContextClassLoader()

返回此线程的上下文 ClassLoader。 上下文 ClassLoader 由线程的创建者提供，供在该线程中运行的代码在加载类和资源时使用。 如果未设置，则默认为父线程的 ClassLoader 上下文。 原始线程的上下文 ClassLoader 通常设置为用于加载应用程序的类加载器。

如果存在安全管理器，并且调用者的类加载器不为 null 并且与上下文类加载器的祖先不同，则此方法调用安全管理器的 SecurityManager#checkPermission(java.security.Permission) 方法 RuntimePermission (“getClassLoader”) 权限，用于验证是否允许检索上下文类加载器。

返回:

此线程的上下文 ClassLoader，或 null 指示系统类加载器（或者，如果失败，则为引导类加载器）

Throws:

setContextClassLoader

public void setContextClassLoader(ClassLoader cl)

设置此线程的上下文 ClassLoader。 上下文类加载器可以在创建线程时设置，并允许线程的创建者在加载类和资源时通过getContextClassLoader为线程中运行的代码提供合适的类加载器。

如果存在安全管理器，则使用 RuntimePermission (“setContextClassLoader”) 权限调用其 SecurityManager#checkPermission(java.security.Permission) 方法，以查看是否允许设置上下文 ClassLoader。

参数：

Throws:

holdsLock

public static boolean holdsLock(Object obj)

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

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

     assert Thread.holdsLock(obj); 

参数:

返回:

如果当前线程持有指定对象的监视器锁，则为 true。

Throws:

getStackTrace

public StackTraceElement[] getStackTrace()

返回表示此线程的堆栈转储的堆栈跟踪元素数组。如果此线程尚未启动、已启动但尚未被系统调度运行或已终止，则此方法将返回一个长度为零的数组。如果返回的数组长度非零，则数组的第一个元素表示堆栈的顶部，这是序列中最近的方法调用。数组的最后一个元素表示堆栈的底部，它是序列中最近的方法调用。

如果有一个安全管理器，并且这个线程不是当前线程，那么使用一个 RuntimePermission(“getStackTrace”) 权限调用安全管理器的 checkPermission 方法，看看是否可以获取堆栈跟踪。

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

返回：

StackTraceElement 数组，每个代表一个堆栈帧。

Throws:

getAllStackTraces

public static MapThread,StackTraceElement[] getAllStackTraces()

返回所有活动线程的堆栈跟踪映射。 映射键是线程，每个映射值是一个 StackTraceElement 数组，表示相应线程的堆栈转储。 返回的堆栈跟踪采用为 getStackTrace 方法指定的格式。

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

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

返回:

从 Thread 到 StackTraceElement 数组的 Map，表示相应线程的堆栈跟踪。

Throws:

getId

public long getId()

返回此线程的标识符。 线程 ID 是创建此线程时生成的正长整数。 线程 ID 是唯一的，并且在其生命周期内保持不变。 当一个线程被终止时，这个线程 ID 可以被重用。

返回:

此线程的 ID。

getState

public Thread.State getState()

返回此线程的状态。 此方法设计用于监控系统状态，而不是用于同步控制。

返回:

这个线程的状态。

setDefaultUncaughtExceptionHandler

public static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)

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

未捕获的异常处理首先由线程控制，然后由线程的 ThreadGroup 对象控制，最后由默认的未捕获异常处理程序控制。 如果线程没有明确的未捕获异常处理程序集，并且线程的线程组（包括父线程组）没有专门化其 uncaughtException 方法，则将调用默认处理程序的 uncaughtException 方法。

通过设置默认的未捕获异常处理程序，应用程序可以更改那些已经接受系统提供的任何“默认”行为的线程处理未捕获异常的方式（例如记录到特定设备或文件）。

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

参数：

Throws:

getDefaultUncaughtExceptionHandler

public static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler()

返回当线程由于未捕获的异常而突然终止时调用的默认处理程序。 如果返回值为 null，则没有默认值。

返回:

所有线程的默认未捕获异常处理程序

getUncaughtExceptionHandler

public Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()

返回当此线程由于未捕获的异常而突然终止时调用的处理程序。 如果该线程没有显式设置未捕获的异常处理程序，则返回该线程的 ThreadGroup 对象，除非该线程已终止，在这种情况下返回 null。

返回:

此线程的未捕获异常处理程序

setUncaughtExceptionHandler

public void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)

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

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

参数：

Throws: