Thread类

所在包：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 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 。

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

 

 

 

嵌套类摘要
Modifier and TypeClass and Description
static class  Thread.State
线程状态。
static interface  Thread.UncaughtExceptionHandler
当Thread由于未捕获的异常而突然终止时，处理程序的 接口被调用。 

Field Summary字段汇总

Modifier and TypeField and Description
static int MAX_PRIORITY
线程可以拥有的最大优先级。
static int MIN_PRIORITY
线程可以拥有的最小优先级。
static int NORM_PRIORITY
分配给线程的默认优先级。 
构造方法摘要
Constructor and Description
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, String name)
分配一个新的 Thread对象。 
方法摘要
Modifier and TypeMethod and Description
static int activeCount()
返回当前线程的thread group及其子组中活动线程数的估计。
void checkAccess()
确定当前正在运行的线程是否有权限修改此线程。
protected Object clone()
将CloneNotSupportedException作为线程抛出无法有意义地克隆。
int countStackFrames()
已弃用
此呼叫的定义取决于suspend() ，它已被弃用。 此外，此呼叫的结果从未明确。
static Thread currentThread()
返回对当前正在执行的线程对象的引用。
void destroy()
已弃用
这种方法最初是为了销毁这个线程而没有任何清理。 它所持有的任何监视器都将保持锁定。 但是，该方法从未实现。 如果要实施，那么它将是suspend()的方式是僵死的 。 如果目标线程在销毁时保护关键系统资源的锁，则无法再次访问该资源。 如果另一个线程曾尝试锁定此资源，将导致死锁。 这种僵局通常表现为“冻结”过程。 有关详细信息，请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 。
static void dumpStack()
将当前线程的堆栈跟踪打印到标准错误流。
static int enumerate(Thread[] tarray)
将当前线程的线程组及其子组中的每个活动线程复制到指定的数组中。
static Map<Thread,StackTraceElement[]> getAllStackTraces()
返回所有活动线程的堆栈跟踪图。
ClassLoader getContextClassLoader()
返回此Thread的上下文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纳秒这个线程死亡。
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 ThreadDeath异常在堆栈中ThreadDeath的自然结果）。 如果先前受这些监视器保护的任何对象处于不一致的状态，则损坏的对象将变得对其他线程可见，可能导致任意行为。 stop许多用途应该被替换为只是修改一些变量以指示目标线程应该停止运行的代码。 目标线程应该定期检查此变量，如果变量表示要停止运行，则以有序方式从其运行方法返回。 如果目标线程长时间等待（例如，在interrupt变量上），则应该使用interrupt方法来中断等待。 有关详细信息，请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 。
void stop(Throwable obj)
已弃用
该方法最初设计为强制线程停止并抛出一个给定的Throwable作为例外。 它本质上是不安全的（有关详细信息，请参阅stop() ），此外还可用于生成目标线程未准备处理的异常。 有关详细信息，请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 。
void suspend()
已弃用
这种方法已被弃用，因为它本身就是死锁的。 如果目标线程在挂起时保护关键系统资源的监视器上的锁定，则在目标线程恢复之前，线程不能访问该资源。 如果要恢复目标线程的线程在调用resume之前尝试锁定此监视器， resume导致死锁。 这种僵局通常表现为“冻结”过程。 有关详细信息，请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 。
String toString()
返回此线程的字符串表示，包括线程的名称，优先级和线程组。
static void yield()
对调度程序的一个暗示，即当前线程愿意产生当前使用的处理器。 

Methods inherited from class java.lang.Object （以下方法继承自 java.lang.Object类）

equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

字段详细信息

  • MIN_PRIORITY

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

  • NORM_PRIORITY

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

  • NORM_PRIORITY

    public static final int NORM_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")权限调用，直接或间接地由覆盖getContextClassLoader或setContextClassLoader方法的子类的getContextClassLoader setContextClassLoader调用。

    新创建的线程的优先级设置为等于创建线程的优先级，即当前正在运行的线程。 可以使用方法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 

方法详细信息

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

  • start

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

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

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

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

  • run

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

    Thread的Thread应该覆盖此方法。

    Specified by:
    run在界面 Runnable
    另请参见：
    start() ， stop() ， Thread(ThreadGroup, Runnable, String)

  • stop

    @Deprecated
public final void stop()
    已弃用 这种方法本质上是不安全的。 使用Thread.stop停止线程可以解锁所有已锁定的监视器（由于未ThreadDeath ThreadDeath异常在堆栈中ThreadDeath的自然结果）。 如果先前受这些监视器保护的任何对象处于不一致的状态，则损坏的对象将变得对其他线程可见，可能导致任意行为。 stop许多用途应该被代替，只需修改一些变量来指示目标线程应该停止运行。 目标线程应该定期检查此变量，如果变量表示要停止运行，则以有序方式从其运行方法返回。 如果目标线程长时间等待（例如，在interrupt变量上），则应该使用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 。

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

  • interrupted

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

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

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

  • isInterrupted

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

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

    结果
    true如果这个线程已被中断; false否则。
    另请参见：
    interrupted()

  • destroy

    @Deprecated
public void destroy()
    已弃用 这种方法最初是为了销毁这个线程而没有任何清理。 它所持有的任何监视器都将保持锁定。 但是，该方法从未实现。 如果要实施，那么suspend()的方式会是僵死的 。 如果目标线程在销毁时保护关键系统资源的锁，则无法再次访问该资源。 如果另一个线程曾尝试锁定此资源，将导致死锁。 这种僵局通常表现为“冻结”过程。 有关更多信息，请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 。
    投掷NoSuchMethodError 。
    异常
    NoSuchMethodError - 永远  

  • isAlive

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

  • isAlive

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

  • suspend

    @Deprecated
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
public int countStackFrames()
    已弃用 此调用的定义取决于suspend() ，它被废弃了。 此外，此呼叫的结果从未明确。
    计算此线程中的堆栈帧数。 线程必须暂停。
    结果
    此线程中的堆栈帧数。
    异常
    IllegalThreadStateException - 如果此线程未挂起。 

  • join

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

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

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

  • join

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

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

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

  • join

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

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

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

  • dumpStack

    public static void dumpStack()
    将当前线程的堆栈跟踪打印到标准错误流。 此方法仅用于调试。
    另请参见：
    Throwable.printStackTrace()

  • 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()
    返回此线程的字符串表示，包括线程的名称，优先级和线程组。
    重写：
    toString在 Object
    结果
    这个线程的字符串表示形式。

  • getContextClassLoader

    public ClassLoader getContextClassLoader()
    返回此Thread的上下文ClassLoader。 上下文ClassLoader由线程的创建者提供，以便在加载类和资源时在此线程中运行的代码使用。 如果不是set ，默认是父线程的ClassLoader上下文。 原始线程的上下文ClassLoader通常设置为用于加载应用程序的类加载器。

    如果安全管理器存在，并且调用者的类加载器不是null ，并且与上下文类加载器的祖先不一样或者祖先，则该方法调用安全管理器的checkPermission方法，具有RuntimePermission ("getClassLoader")权限，以验证是否检索上下文类加载器是允许的。

    结果
    该线程的上下文ClassLoader，或 null指示系统类加载器（或者失败的是引导类加载器）
    异常
    SecurityException - 如果当前线程无法获取上下文ClassLoader
    从以下版本开始：
    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) ， RuntimePermission ， Throwable.getStackTrace()

  • getAllStackTraces

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

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

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

    结果
    一个 Map从 Thread到一个 StackTraceElement的数组， 代表相应线程的堆栈跟踪。
    异常
    SecurityException - 如果安全管理器存在，并且其 checkPermission方法不允许获取线程的堆栈跟踪。
    从以下版本开始：
    1.5
    另请参见：
    getStackTrace() ， SecurityManager.checkPermission(java.security.Permission) ， RuntimePermission ， Throwable.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)

  • 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)

  • 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)
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/LinQingYang/p/12431558.html