Module  java.base
软件包  java.lang

Class Thread

  • All Implemented Interfaces:
    Runnable
    已知直接子类:
    ForkJoinWorkerThread


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

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

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

    • exit类的方法Runtime已经被调用并且安全管理器允许退出操作发生。
    • 不是守护进程线程的所有线程都已经死亡,无论是从调用返回到run方法还是抛出异常,传播超出了run方法。

    创建一个新的执行线程有两种方法。 一个是将一个类声明为一个Thread的子类。 这个子类应该重写run类的方法Thread 然后可以分配并启动子类的实例。 例如,计算大于规定值的素数的线程可以写成如下:


         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 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参数传递给null中的构造函数或方法将导致抛出NullPointerException

    从以下版本开始:
    1.0
    另请参见:
    RunnableRuntime.exit(int)run()stop()
    • Nested Class Summary

      Nested Classes  
      Modifier and Type Class 描述
      static class  Thread.State
      线程状态。
      static interface  Thread.UncaughtExceptionHandler
      当由于未捕获的异常而导致 Thread突然终止时,处理程序的接口被调用。
    • Field Summary

      Fields  
      Modifier and Type Field 描述
      static int MAX_PRIORITY
      线程可以拥有的最大优先级。
      static int MIN_PRIORITY
      线程可以拥有的最小优先级。
      static int NORM_PRIORITY
      分配给线程的默认优先级。
    • 构造方法摘要

      构造方法  
      Constructor 描述
      Thread​()
      分配一个新的 Thread对象。
      Thread​(Runnable target)
      分配一个新的 Thread对象。
      Thread​(Runnable target, String name)
      分配一个新的 Thread对象。
      Thread​(String name)
      分配一个新的 Thread对象。
      Thread​(ThreadGroup group, Runnable target)
      分配一个新的 Thread对象。
      Thread​(ThreadGroup group, Runnable target, String name)
      分配一个新的 Thread对象,使其具有 target作为其运行对象,具有指定的 name作为其名称,属于 group引用的线程组。
      Thread​(ThreadGroup group, Runnable target, String name, long stackSize)
      分配一个新的 Thread对象,使其具有 target作为其运行对象,具有指定的 name作为其名称,并且属于 group引用的线程组,并具有指定的 堆栈大小
      Thread​(ThreadGroup group, Runnable target, String name, long stackSize, boolean inheritThreadLocals)
      分配一个新的Thread对象,使其具有target作为其运行对象,具有指定的name作为其名称,属于group引用的线程组,具有指定的stackSize ,如果inheritThreadLocalstrue ,则继承inheritable thread-local变量的初始值。
      Thread​(ThreadGroup group, String name)
      分配一个新的 Thread对象。
    • 方法摘要

      所有方法  静态方法  接口方法  具体的方法  弃用的方法 
      Modifier and Type 方法 描述
      static int activeCount​()
      返回当前线程的thread group及其子组中活动线程数的估计。
      void checkAccess​()
      确定当前正在运行的线程是否有权限修改此线程。
      protected Object clone​()
      将CloneNotSupportedException作为线程抛出无法有意义地克隆。
      int countStackFrames​()
      不推荐用于删除:此API元素将在以后的版本中被删除。
      此呼叫的定义取决于suspend() ,该消息已被弃用。 此外,此呼叫的结果从未明确。 此方法在将来的Java SE版本中可能会被删除。
      static Thread currentThread​()
      返回对当前正在执行的线程对象的引用。
      void destroy​()
      不推荐用于删除:此API元素将在以后的版本中被删除。
      这种方法最初是为了销毁这个线程而没有任何清理。 它所持有的任何监视器都将保持锁定。 但是,该方法从未实现。 如果要实施,这将是suspend()的方式是非常容易死锁的。 如果目标线程在销毁时保护关键系统资源的锁,则无法再次访问该资源。 如果另一个线程曾尝试锁定此资源,将导致死锁。 这种僵局通常表现为“冻结”过程。 有关详细信息,请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 此方法在将来的Java SE版本中可能会被删除。
      static void dumpStack​()
      将当前线程的堆栈跟踪打印到标准错误流。
      static int enumerate​(Thread[] tarray)
      将当前线程的线程组及其子组中的每个活动线程复制到指定的数组中。
      static Map<Thread,StackTraceElement[]> getAllStackTraces​()
      返回所有活动线程的堆栈跟踪图。
      ClassLoader getContextClassLoader​()
      返回此线程的上下文 ClassLoader
      static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler​()
      返回当线程由于未捕获异常突然终止而调用的默认处理程序。
      long getId​()
      返回此线程的标识符。
      String getName​()
      返回此线程的名称。
      int getPriority​()
      返回此线程的优先级。
      StackTraceElement[] getStackTrace​()
      返回表示此线程的堆栈转储的堆栈跟踪元素数组。
      Thread.State getState​()
      返回此线程的状态。
      ThreadGroup getThreadGroup​()
      返回此线程所属的线程组。
      Thread.UncaughtExceptionHandler getUncaughtExceptionHandler​()
      返回由于未捕获的异常,此线程突然终止时调用的处理程序。
      static boolean holdsLock​(Object obj)
      当且仅当当前线程持有指定对象上的监视器锁时,才返回 true
      void interrupt​()
      中断这个线程。
      static boolean interrupted​()
      测试当前线程是否已中断。
      boolean isAlive​()
      测试这个线程是否活着。
      boolean isDaemon​()
      测试这个线程是否是守护线程。
      boolean isInterrupted​()
      测试这个线程是否被中断。
      void join​()
      等待这个线程死亡。
      void join​(long millis)
      等待这个线程死亡 millis毫秒。
      void join​(long millis, int nanos)
      等待最多 millis毫秒加上这个线程死亡的 nanos纳秒。
      static void onSpinWait​()
      表示呼叫方暂时无法进行,直到发生其他活动的一个或多个动作。
      void resume​()
      已过时。
      该方法仅适用于suspend() ,由于它是死锁倾向,因此已被弃用。 有关详细信息,请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?
      void run​()
      如果这个线程是使用单独的Runnable运行对象构造的,那么这个Runnable对象的run方法被调用; 否则,此方法不执行任何操作并返回。
      void setContextClassLoader​(ClassLoader cl)
      设置此线程的上下文ClassLoader。
      void setDaemon​(boolean on)
      将此线程标记为 daemon线程或用户线程。
      static void setDefaultUncaughtExceptionHandler​(Thread.UncaughtExceptionHandler eh)
      设置当线程由于未捕获的异常突然终止而调用的默认处理程序,并且没有为该线程定义其他处理程序。
      void setName​(String name)
      将此线程的名称更改为等于参数 name
      void setPriority​(int newPriority)
      更改此线程的优先级。
      void setUncaughtExceptionHandler​(Thread.UncaughtExceptionHandler eh)
      设置当该线程由于未捕获的异常而突然终止时调用的处理程序。
      static void sleep​(long millis)
      使当前正在执行的线程停留(暂停执行)指定的毫秒数,这取决于系统定时器和调度程序的精度和准确性。
      static void sleep​(long millis, int nanos)
      导致正在执行的线程以指定的毫秒数加上指定的纳秒数来暂停(临时停止执行),这取决于系统定时器和调度器的精度和准确性。
      void start​()
      导致此线程开始执行; Java虚拟机调用此线程的run方法。
      void stop​()
      已过时。
      这种方法本质上是不安全的。 使用Thread.stop停止线程可以解锁所有已锁定的监视器(由于未检查的ThreadDeath异常在堆栈中传播的自然结果)。 如果先前受这些监视器保护的任何对象处于不一致的状态,则损坏的对象将变得对其他线程可见,可能导致任意行为。 stop许多用途应该被替换为只是修改一些变量以指示目标线程应该停止运行的代码。 目标线程应该定期检查此变量,如果变量表示要停止运行,则以有序方式从其运行方法返回。 如果目标线程长时间等待(例如,在条件变量上),则应使用interrupt方法来中断等待。 有关详细信息,请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?
      void stop​(Throwable obj)
      不推荐用于删除:此API元素将在以后的版本中被删除。
      此方法最初设计为强制线程停止并抛出给定的Throwable作为例外。 它本质上是不安全的(有关详细信息,请参阅stop() ),此外还可用于生成目标线程未准备处理的异常。 有关详细信息,请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 此方法在将来的Java SE版本中可能会被删除。
      void suspend​()
      已过时。
      这种方法已被弃用,因为它本身就是死锁的。 如果目标线程在挂起时保护关键系统资源的监视器上的锁定,则在目标线程恢复之前,线程不能访问该资源。 如果要恢复目标线程的线程尝试在调用resume之前锁定此监视器, resume导致死锁。 这种僵局通常表现为“冻结”过程。 有关详细信息,请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?
      String toString​()
      返回此线程的字符串表示,包括线程的名称,优先级和线程组。
      static void yield​()
      对调度程序的一个暗示,即当前线程愿意产生当前使用的处理器。
    • 字段详细信息

      • MIN_PRIORITY

        public static final int MIN_PRIORITY
        线程可以拥有的最小优先级。
        另请参见:
        Constant Field Values
      • NORM_PRIORITY

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

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

      • 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是整数。
        参数
        target - 启动此线程时调用其run方法的对象。 如果null ,这个类run方法什么也没做。
      • Thread

        public Thread​(ThreadGroup group,
                      Runnable target)
        分配一个新的Thread对象。 此构造函数具有与Thread (group, target, gname)相同的效果,其中, gname是新生成的名称。 自动生成的名称的格式为"Thread-"+ n ,其中n是整数。
        参数
        group - 线程组。 如果是null并且有一个安全管理员,该组由SecurityManager.getThreadGroup()决定。 如果没有安全管理员或SecurityManager.getThreadGroup()返回null ,该组将设置为当前线程的线程组。
        target - 启动此线程时调用其run方法的对象。 如果是null ,这个线程的run方法被调用。
        异常
        SecurityException - 如果当前线程无法在指定的线程组中创建线程
      • Thread

        public Thread​(String name)
        分配一个新的Thread对象。 此构造函数与Thread (null, null, name)具有相同的效果。
        参数
        name - 新线程的名称
      • Thread

        public Thread​(ThreadGroup group,
                      String name)
        分配一个新的Thread对象。 该构造函数与Thread (group, null, name)具有相同的效果。
        参数
        group - 线程组。 如果是null ,还有一个安全管理员,该组由SecurityManager.getThreadGroup()决定。 如果没有安全管理员或SecurityManager.getThreadGroup()返回null ,该组将设置为当前线程的线程组。
        name - 新线程的名称
        异常
        SecurityException - 如果当前线程无法在指定的线程组中创建线程
      • Thread

        public Thread​(Runnable target,
                      String name)
        分配一个新的Thread对象。 该构造函数与Thread (null, target, name)具有相同的效果。
        参数
        target - 启动此线程时调用其run方法的对象。 如果是null ,这个线程的run方法被调用。
        name - 新线程的名称
      • Thread

        public Thread​(ThreadGroup group,
                      Runnable target,
                      String name)
        分配新的Thread对象,使其具有target作为其运行对象,具有指定的name作为其名称,属于group引用的线程组。

        如果有安全管理器,则使用ThreadGroup作为参数调用其checkAccess方法。

        此外,其checkPermission方法被调用与RuntimePermission("enableContextClassLoaderOverride")时通过将覆盖一个子类的构造直接或间接调用许可getContextClassLoadersetContextClassLoader方法。

        新创建的线程的优先级设置为等于创建线程的优先级,即当前正在运行的线程。 方法setPriority可以用于将优先级改变为新值。

        当且仅当创建它的线程当前被标记为守护线程时,新创建的线程才被初始化为守护线程。 方法setDaemon可以用于改变线程是否是守护进程。

        参数
        group - 线程组。 如果是null并且有一个安全管理器,该组由SecurityManager.getThreadGroup()决定。 如果没有安全管理员或SecurityManager.getThreadGroup()返回null ,则该组将设置为当前线程的线程组。
        target - 启动此线程时调用其run方法的对象。 如果是null ,则调用此线程的run方法。
        name - 新线程的名称
        异常
        SecurityException - 如果当前线程不能在指定的线程组中创建线程,或者不能覆盖上下文类加载器方法。
      • Thread

        public Thread​(ThreadGroup group,
                      Runnable target,
                      String name,
                      long stackSize)
        分配一个新的Thread对象,使其具有target作为其运行对象,具有指定的name作为其名称,属于由group引用的线程组,并具有指定的堆栈大小

        该构造函数与Thread(ThreadGroup,Runnable,String)相同,除了允许指定线程堆栈大小的事实之外。 堆栈大小是虚拟机为该线程的堆栈分配的大致的地址空间字节数。 stackSize参数的影响(如果有的话)与平台有关。

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

        虚拟机可以自由地将stackSize参数视为建议。 如果平台的指定值不合理地低,则虚拟机可能会改为使用一些平台特定的最小值; 如果指定的值不合理地高,虚拟机可能会使用一些平台特定的最大值。 同样,虚拟机可以自由地按照合适的方式向上或向下舍入指定的值(或完全忽略它)。

        stackSize参数指定一个值将导致此构造函数的行为完全像Thread(ThreadGroup, Runnable, String)构造函数。

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

        实现说明:鼓励Java平台实现者记录其对stackSize参数的实现行为。

        参数
        group - 线程组。 如果是null并且有一个安全管理员,该组由SecurityManager.getThreadGroup()决定。 如果没有安全管理员或SecurityManager.getThreadGroup()返回null ,该组将设置为当前线程的线程组。
        target - 启动此线程时调用其run方法的对象。 如果是null ,这个线程的run方法被调用。
        name - 新线程的名称
        stackSize - 新线程所需的堆栈大小,或为零表示此参数将被忽略。
        异常
        SecurityException - 如果当前线程无法在指定的线程组中创建线程
        从以下版本开始:
        1.4
      • Thread

        public Thread​(ThreadGroup group,
                      Runnable target,
                      String name,
                      long stackSize,
                      boolean inheritThreadLocals)
        分配一个新的Thread对象,使其具有target作为其运行对象,具有指定的name作为其名称,属于由group引用的线程组,具有指定的stackSize ,并且如果inheritThreadLocalstrue ,则继承inheritable thread-local变量的初始值。

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

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

        参数
        group - 线程组。 如果是null ,还有一个安全管理员,该组由SecurityManager.getThreadGroup()决定。 如果没有安全管理员或SecurityManager.getThreadGroup()返回null ,则该组将设置为当前线程的线程组。
        target - 启动此线程时调用其run方法的对象。 如果是null ,这个线程的run方法被调用。
        name - 新线程的名称
        stackSize - 新线程所需的堆栈大小,或零表示此参数将被忽略
        inheritThreadLocals - 如果 true从构造线程继承可继承的线程 true初始值,否则不继承初始值
        异常
        SecurityException - 如果当前线程无法在指定的线程组中创建线程
        从以下版本开始:
        9
    • 方法详细信息

      • currentThread

        public static Thread currentThread​()
        返回对当前正在执行的线程对象的引用。
        结果
        当前正在执行的线程。
      • yield

        public static void 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 - 如果任何线程中断了当前线程。 当抛出此异常时,当前线程的中断状态将被清除。
      • onSpinWait

        public static void onSpinWait​()
        表示呼叫方暂时无法进行,直到发生其他活动的一个或多个动作。 通过在自旋等待循环结构的每次迭代中调用此方法,调用线程向运行时指示它正在忙等待。 运行时可能采取措施来提高调用自旋等待循环结构的性能。

        API Note:
        作为一个例子,考虑一个类中的一个方法,旋转一个循环,直到某个标志设置在该方法之外。 应该在旋转循环内部调用onSpinWait方法。
           class EventHandler { volatile boolean eventNotificationNotReceived; void waitForEventAndHandleIt() { while ( eventNotificationNotReceived ) { java.lang.Thread.onSpinWait(); } readAndProcessEvent(); } void readAndProcessEvent() { // Read event from some source and process it . . . } }  

        上面的代码将保持正确,即使没有调用onSpinWait方法。 然而,在某些架构上,Java虚拟机可能会以更有益的方式发布处理器指令来解决这些代码模式。

        从以下版本开始:
        9
      • start

        public void start​()
        导致此线程开始执行; Java虚拟机调用此线程的run方法。

        结果是两个线程同时运行:当前线程(从调用返回到start方法)和另一个线程(执行其run方法)。

        不止一次启动线程是不合法的。 特别地,一旦线程完成执行,可能不会重启线程。

        异常
        IllegalThreadStateException - 如果线程已经启动。
        另请参见:
        run()stop()
      • run

        public void run​()
        如果这个线程使用单独的Runnable运行对象构造,那么这个Runnable对象的run方法被调用; 否则,此方法不执行任何操作并返回。

        Thread子类应该覆盖此方法。

        Specified by:
        run在接口 Runnable
        另请参见:
        start()stop()Thread(ThreadGroup, Runnable, String)
      • stop

        @Deprecated(since="1.2")
        public final void stop​()
        已过时。 这种方法本质上是不安全的。 使用Thread.stop停止线程会使其解锁所有已锁定的监视器(由于未检查的ThreadDeath异常在堆栈中传播的自然结果)。 如果先前受这些监视器保护的任何对象处于不一致的状态,则损坏的对象将变得对其他线程可见,可能导致任意行为。 stop许多用途应该被代码简单地修改一些变量来表示目标线程应该停止运行。 目标线程应该定期检查此变量,如果变量表示要停止运行,则以有序方式从其运行方法返回。 如果目标线程等待很长时间(例如,在条件变量上),则应该使用interrupt方法来中断等待。 有关详细信息,请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?
        强制线程停止执行。

        如果安装了一个安全管理器,它的checkAccess方法将以this作为参数来调用。 这可能会导致一个SecurityException被提升(在当前线程中)。

        如果此线程与当前线程不同(即当前线程正试图停止除本身线程之外的线程),则另外还会调用安全管理器的checkPermission方法(带有RuntimePermission("stopThread")参数)。 再次,这可能会导致抛出一个SecurityException (在当前线程中)。

        此线程代表的线程都被迫停止不管它是异常做,并抛出一个新创建ThreadDeath对象,作为异常。

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

        应用程序通常不应试图捕获ThreadDeath ,除非它必须做一些特殊的清理操作(注意,投掷ThreadDeath原因finally的条款try要执行的语句在线程正式死亡之前)。 如果一个catch子句捕获一个ThreadDeath对象,重要的是重新抛出该对象,使线程实际上死亡。

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

        异常
        SecurityException - 如果当前线程不能修改此线程。
        另请参见:
        interrupt()checkAccess()run()start()ThreadDeathThreadGroup.uncaughtException(Thread,Throwable)SecurityManager.checkAccess(Thread)SecurityManager.checkPermission(java.security.Permission)
      • stop

        @Deprecated(since="1.2",
                    forRemoval=true)
        public final void stop​(Throwable obj)
        不推荐用于删除:此API元素将在以后的版本中被删除。 该方法最初设计为强制线程停止并抛出给定的Throwable作为例外。 它本质上是不安全的(有关详细信息,请参阅stop() ),此外还可用于生成目标线程未准备处理的异常。 有关详细信息,请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 此方法在将来的Java SE版本中可能会被删除。
        抛出 UnsupportedOperationException
        参数
        obj - 忽略
      • interrupted

        public static boolean interrupted​()
        测试当前线程是否已中断。 该方法可以清除线程的中断状态 换句话说,如果这个方法被连续调用两次,那么第二个调用将返回false(除非当前线程再次中断,在第一个调用已经清除其中断状态之后,在第二个调用之前已经检查过)。

        忽略线程中断,因为线程在中断时不存在将被该方法返回false所反映。

        结果
        true如果当前线程已被中断; 否则为false
        另请参见:
        isInterrupted()
      • isInterrupted

        public boolean isInterrupted​()
        测试这个线程是否被中断。 线程的中断状态不受此方法的影响。

        忽略线程中断,因为线程在中断时不存在将被该方法返回false所反映。

        结果
        true如果这个线程已被中断; 否则为false
        另请参见:
        interrupted()
      • destroy

        @Deprecated(since="1.5",
                    forRemoval=true)
        public void destroy​()
        不推荐用于删除:此API元素将在以后的版本中被删除。 这种方法最初是为了销毁这个线程而没有任何清理。 它所持有的任何监视器都将保持锁定。 但是,该方法从未实现。 如果要实施,这将是suspend()的方式是死锁的 如果目标线程在销毁时保护关键系统资源的锁,则无法再次访问该资源。 如果另一个线程曾尝试锁定此资源,将导致死锁。 这种僵局通常表现为“冻结”过程。 有关详细信息,请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 此方法在将来的Java SE版本中可能会被删除。
        投掷NoSuchMethodError
        异常
        NoSuchMethodError - 永远
      • isAlive

        public final boolean isAlive​()
        测试这个线程是否活着。 如果一个线程已经启动并且尚未死亡,那么线程是活着的。
        结果
        true如果这个线程还活着; 否则为false
      • suspend

        @Deprecated(since="1.2")
        public final void suspend​()
        已过时。 这种方法已被弃用,因为它本身就是死锁的。 如果目标线程在挂起时保护关键系统资源的监视器上的锁定,则在目标线程恢复之前,线程不能访问该资源。 如果要恢复目标线程的线程在调用resume之前尝试锁定此监视器, resume导致死锁。 这种僵局通常表现为“冻结”过程。 有关详细信息,请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?
        暂停这个线程。

        首先,这个线程的checkAccess方法被调用,没有参数。 这可能会导致抛出一个SecurityException (在当前线程中)。

        如果线程活着,它将被暂停,并且不会进一步进行,除非和直到恢复。

        异常
        SecurityException - 如果当前线程不能修改此线程。
        另请参见:
        checkAccess()
      • getPriority

        public final int getPriority​()
        返回此线程的优先级。
        结果
        这个线程的优先级。
        另请参见:
        setPriority(int)
      • setName

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

        首先,这个线程的checkAccess方法被调用没有参数。 这可能会导致抛出一个SecurityException

        参数
        name - 这个线程的新名称。
        异常
        SecurityException - 如果当前线程不能修改此线程。
        另请参见:
        getName()checkAccess()
      • getName

        public final String getName​()
        返回此线程的名称。
        结果
        这个线程的名字。
        另请参见:
        setName(String)
      • getThreadGroup

        public final ThreadGroup getThreadGroup​()
        返回此线程所属的线程组。 如果线程已经死机(停止),此方法返回null。
        结果
        这个线程的线程组。
      • activeCount

        public static int activeCount​()
        返回当前线程的thread group及其子组中活动线程数的估计。 递归地遍历当前线程的线程组中的所有子组。

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

        结果
        对当前线程的线程组和任何其他线程组中当前线程的线程组作为祖先的活动线程数的估计
      • 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元素将在以后的版本中被删除。 此呼叫的定义取决于suspend() ,已被弃用。 此外,此呼叫的结果从未明确。 此方法在将来的Java SE版本中可能会被删除。
        计算此线程中的堆栈帧数。 线程必须暂停。
        结果
        此线程中的堆栈帧数。
        异常
        IllegalThreadStateException - 如果此线程未挂起。
        另请参见:
        StackWalker
      • join

        public final void join​(long millis)
                        throws InterruptedException
        等待这个线程死亡最多millis毫秒。 超时时间为0意味着永远等待。

        这个实现使用一个this.wait调用的循环,条件是this.isAlive 当线程终止时,将调用this.notifyAll方法。 建议应用程序不使用waitnotify ,或notifyAllThread实例。

        参数
        millis - 以毫秒为单位等待的时间
        异常
        IllegalArgumentException - 如果值为 millis为负数
        InterruptedException - 如果任何线程中断当前线程。 当抛出此异常时,当前线程的中断状态将被清除。
      • join

        public final void join​(long millis,
                               int nanos)
                        throws InterruptedException
        等待最多millis毫秒加上这个线程死亡的nanos纳秒。

        这个实现使用了一个this.wait调用的循环,条件是this.isAlive 当线程终止时,将调用this.notifyAll方法。 建议应用程序不使用waitnotify ,或notifyAllThread实例。

        参数
        millis - 以毫秒为单位等待的时间
        nanos - 0-999999等待的额外纳秒
        异常
        IllegalArgumentException -如果值 millis是否定的,或的值 nanos不在范围 0-999999
        InterruptedException - 如果任何线程中断当前线程。 当抛出此异常时,当前线程的中断状态将被清除。
      • join

        public final void join​()
                        throws InterruptedException
        等待这个线程死亡。

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

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

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

        public final void setDaemon​(boolean on)
        将此线程标记为daemon线程或用户线程。 当运行的唯一线程都是守护进程线程时,Java虚拟机将退出。

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

        参数
        on - 如果是 true ,将此线程标记为守护线程
        异常
        IllegalThreadStateException - 如果这个线程是 alive
        SecurityException - 如果 checkAccess()确定当前线程不能修改此线程
      • isDaemon

        public final boolean isDaemon​()
        测试这个线程是否是守护线程。
        结果
        true如果这个线程是一个守护线程; 否则为false
        另请参见:
        setDaemon(boolean)
      • checkAccess

        public final void checkAccess​()
        确定当前正在运行的线程是否有权限修改此线程。

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

        异常
        SecurityException - 如果当前线程不允许访问此线程。
        另请参见:
        SecurityManager.checkAccess(Thread)
      • toString

        public String toString​()
        返回此线程的字符串表示,包括线程的名称,优先级和线程组。
        重写:
        toStringObject
        结果
        这个线程的字符串表示形式。
      • getContextClassLoader

        public ClassLoader getContextClassLoader​()
        返回此线程的上下文ClassLoader 上下文ClassLoader由加载类和资源的在线程中运行的代码使用的线程的创建者提供。 如果不是set ,默认是父线程的ClassLoader上下文。 原始线程的上下文ClassLoader通常设置为用于加载应用程序的类加载器。
        结果
        该线程的上下文为 ClassLoader ,或 null指示系统类加载器(或者,失败的是引导类加载器)
        异常
        SecurityException - 如果存在安全管理员,并且调用者的类加载器不是null并且与上下文类加载器的祖先不相同或不存在,并且主叫方不具有RuntimePermission ("getClassLoader")
        从以下版本开始:
        1.2
      • setContextClassLoader

        public void setContextClassLoader​(ClassLoader cl)
        设置此线程的上下文ClassLoader。 当创建线程时,可以设置上下文ClassLoader,并允许线程的创建者通过getContextClassLoader提供适当的类加载器,以便在加载类和资源时在线程中运行的代码。

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

        参数
        cl - 此线程的上下文ClassLoader,或指示系统类加载器的空值(或者,失败的是引导类加载器)
        异常
        SecurityException - 如果当前线程不能设置上下文ClassLoader
        从以下版本开始:
        1.2
      • holdsLock

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

        该方法旨在允许程序断言当前线程已经保存指定的锁:

          assert Thread.holdsLock(obj); 
        参数
        obj - 测试锁拥有权的对象
        结果
        true如果当前线程保持指定对象上的监视器锁定。
        异常
        NullPointerException - 如果obj是 null
        从以下版本开始:
        1.4
      • getStackTrace

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

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

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

        结果
        一个 StackTraceElement的数组,每个代表一个堆栈帧。
        异常
        SecurityException - 如果安全管理器存在,并且其 checkPermission方法不允许获取线程的堆栈跟踪。
        从以下版本开始:
        1.5
        另请参见:
        SecurityManager.checkPermission(java.security.Permission)RuntimePermissionThrowable.getStackTrace()
      • getAllStackTraces

        public static Map<Thread,StackTraceElement[]> getAllStackTraces​()
        返回所有活动线程的堆栈跟踪图。 映射键是线程,每个映射值是一个StackTraceElement的数组,表示相应的Thread的堆栈转储。 返回的堆栈跟踪的格式为getStackTrace方法指定的格式。

        线程可能正在执行,而此方法被调用。 每个线程的堆栈跟踪仅表示快照,并且可以在不同时间获取每个堆栈跟踪。 如果虚拟机没有关于线程的堆栈跟踪信息,则将在地图值中返回零长度的数组。

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

        结果
        一个 MapThread到阵列 StackTraceElement表示相应线程的堆栈跟踪。
        异常
        SecurityException - 如果安全管理器存在,并且其 checkPermission方法不允许获取线程的堆栈跟踪。
        从以下版本开始:
        1.5
        另请参见:
        getStackTrace()SecurityManager.checkPermission(java.security.Permission)RuntimePermissionThrowable.getStackTrace()
      • getId

        public long getId​()
        返回此线程的标识符。 线程ID是创建此线程时生成的正数long号。 线程ID是唯一的,并且在其生命周期内保持不变。 当线程被终止时,该线程ID可以被重用。
        结果
        这个线程的ID。
        从以下版本开始:
        1.5
      • getState

        public Thread.State getState​()
        返回此线程的状态。 该方法设计用于监视系统状态,不用于同步控制。
        结果
        这个线程的状态。
        从以下版本开始:
        1.5
      • setDefaultUncaughtExceptionHandler

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

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

        通过设置默认未捕获的异常处理程序,应用程序可以更改未被捕获的异常处理方式(如日志记录到特定设备或文件),这些线程将已经接受了系统提供的任何“默认”行为。

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

        参数
        eh - 用作默认未捕获异常处理程序的对象。 如果null那么没有默认处理程序。
        异常
        SecurityException - 如果安全管理员存在并且它拒绝RuntimePermission ("setDefaultUncaughtExceptionHandler")
        从以下版本开始:
        1.5
        另请参见:
        setUncaughtExceptionHandler(java.lang.Thread.UncaughtExceptionHandler)getUncaughtExceptionHandler()ThreadGroup.uncaughtException(java.lang.Thread, java.lang.Throwable)
      • getUncaughtExceptionHandler

        public Thread.UncaughtExceptionHandler getUncaughtExceptionHandler​()
        返回由于未捕获的异常,此线程突然终止时调用的处理程序。 如果此线程没有明确设置未捕获的异常处理程序,则返回此线程的ThreadGroup对象,除非此线程已终止,否则返回null
        结果
        该线程的未捕获的异常处理程序
        从以下版本开始:
        1.5