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

另请参见：

Runnable ， Runtime.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` ，如果`inheritThreadLocals`为`true` ，则继承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()`	对调度程序的一个暗示，即当前线程愿意产生当前使用的处理器。

Methods inherited from class 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
  - 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")时通过将覆盖一个子类的构造直接或间接调用许可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
  - Thread
```
public Thread(ThreadGroup group,
              Runnable target,
              String name,
              long stackSize,
              boolean inheritThreadLocals)
```
    分配一个新的Thread对象，使其具有target作为其运行对象，具有指定的name作为其名称，属于由group引用的线程组，具有指定的stackSize ，并且如果inheritThreadLocals为true ，则继承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
  - clone
```
protected Object clone()
                throws CloneNotSupportedException
```
    将CloneNotSupportedException作为线程抛出无法有意义地克隆。构造一个新的线程。
    
    重写：
    
    clone在类 Object
    
    结果
    
    这个实例的一个克隆。
    
    异常
    
    CloneNotSupportedException - 永远
    
    另请参见：
    
    Cloneable
  - 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() ， ThreadDeath ， ThreadGroup.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 - 忽略
  - 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方法一样。
    
    如果以前的条件都不成立，则该线程的中断状态将被设置。
    
    中断不存在的线程不需要任何效果。
    
    异常
    
    SecurityException - 如果当前线程不能修改此线程
  - 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()
  - resume
```
@Deprecated(since="1.2")
public final void resume()
```
    已过时。此方法仅适用于suspend() ，由于它是死锁倾向，因此已被弃用。有关详细信息，请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 。
    
    恢复挂起的线程。
    首先，这个线程的checkAccess方法被调用没有参数。这可能会导致抛出一个SecurityException （在当前线程中）。
    
    如果线程存活但被暂停，则它被恢复并被允许在其执行中取得进展。
    
    异常
    
    SecurityException - 如果当前线程不能修改此线程。
    
    另请参见：
    
    checkAccess() ， suspend()
  - setPriority
```
public final void setPriority(int newPriority)
```
    更改此线程的优先级。
    首先，这个线程的checkAccess方法被调用没有参数。这可能会导致抛出SecurityException 。
    
    否则，该线程的优先级设置为指定的newPriority较小的线程和线程组的最大允许优先级。
    
    参数
    
    newPriority - 设置此线程的优先级
    
    异常
    
    IllegalArgumentException - 如果优先级不在 MIN_PRIORITY到 MAX_PRIORITY范围内。
    
    SecurityException - 如果当前线程不能修改此线程。
    
    另请参见：
    
    getPriority() ， checkAccess() ， getThreadGroup() ， MAX_PRIORITY ， MIN_PRIORITY ， ThreadGroup.getMaxPriority()
  - 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方法。建议应用程序不使用wait ， notify ，或notifyAll上Thread实例。
    
    参数
    
    millis - 以毫秒为单位等待的时间
    
    异常
    
    IllegalArgumentException - 如果值为 millis为负数
    
    InterruptedException - 如果任何线程中断当前线程。当抛出此异常时，当前线程的中断状态将被清除。
  - join
```
public final void join(long millis,
                       int nanos)
                throws InterruptedException
```
    等待最多millis毫秒加上这个线程死亡的nanos纳秒。
    这个实现使用了一个this.wait调用的循环，条件是this.isAlive 。当线程终止时，将调用this.notifyAll方法。建议应用程序不使用wait ， notify ，或notifyAll上Thread实例。
    
    参数
    
    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()
```
    返回此线程的字符串表示，包括线程的名称，优先级和线程组。
    
    重写：
    
    toString在 Object
    
    结果
    
    这个线程的字符串表示形式。
  - 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) ， 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)
  - getDefaultUncaughtExceptionHandler
```
public static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler()
```
    返回当线程由于未捕获异常突然终止而调用的默认处理程序。如果返回值为null ，则没有默认值。
    
    结果
    
    所有线程的默认未捕获的异常处理程序
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    setDefaultUncaughtExceptionHandler(java.lang.Thread.UncaughtExceptionHandler)
  - getUncaughtExceptionHandler
```
public Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()
```
    返回由于未捕获的异常，此线程突然终止时调用的处理程序。如果此线程没有明确设置未捕获的异常处理程序，则返回此线程的ThreadGroup对象，除非此线程已终止，否则返回null 。
    
    结果
    
    该线程的未捕获的异常处理程序
    
    从以下版本开始：
    
    1.5
  - setUncaughtExceptionHandler
```
public void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)
```
    设置当该线程由于未捕获的异常而突然终止时调用的处理程序。
    线程可以完全控制如何通过明确设置其未捕获的异常处理来响应未捕获的异常。如果没有设置这样的处理程序，那么线程的ThreadGroup对象就会作为它的处理程序。
    
    参数
    
    eh - 用作此线程未捕获的异常处理程序的对象。如果null那么这个线程没有明确的处理程序。
    
    异常
    
    SecurityException - 如果当前线程不允许修改此线程。
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    setDefaultUncaughtExceptionHandler(java.lang.Thread.UncaughtExceptionHandler) ， ThreadGroup.uncaughtException(java.lang.Thread, java.lang.Throwable)

Class Thread

Nested Class Summary

Field Summary

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

字段详细信息

MIN_PRIORITY

NORM_PRIORITY

MAX_PRIORITY

构造方法详细信息

Thread

Thread

Thread

Thread

Thread

Thread

Thread

Thread

Thread

方法详细信息

currentThread

yield

sleep

sleep

onSpinWait

clone

start

run

stop

stop

interrupt

interrupted

isInterrupted

destroy

isAlive

suspend

resume

setPriority

getPriority

setName

getName

getThreadGroup

activeCount

enumerate

countStackFrames

join

join

join

dumpStack

setDaemon

isDaemon

checkAccess

toString

getContextClassLoader

setContextClassLoader

holdsLock

getStackTrace

getAllStackTraces

getId

getState

setDefaultUncaughtExceptionHandler

getDefaultUncaughtExceptionHandler

getUncaughtExceptionHandler

setUncaughtExceptionHandler