实现的所有接口

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 。
从以下版本开始：

1.0

另请参见：

Runnable ， Runtime.exit(int) ， run() ， stop()

嵌套类汇总

嵌套类
变量和类型	类	描述
`static class`	`Thread.State`	线程状态。
`static interface`	`Thread.UncaughtExceptionHandler`	当 `Thread`由于未捕获的异常而突然终止时调用的处理程序接口。

字段汇总

字段
变量和类型	字段	描述
`static int`	`MAX_PRIORITY`	线程可以拥有的最大优先级。
`static int`	`MIN_PRIORITY`	线程可以拥有的最低优先级。
`static int`	`NORM_PRIORITY`	分配给线程的默认优先级。

构造方法摘要

构造方法
构造器	描述
`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`对象。

方法摘要

所有方法静态方法实例方法具体的方法弃用的方法
变量和类型	方法	描述
`static int`	`activeCount()`	返回当前线程thread group及其子组中活动线程数的估计值。
`void`	`checkAccess()`	确定当前运行的线程是否具有修改此线程的权限。
`protected Object`	`clone()`	抛出CloneNotSupportedException，因为无法有意义地克隆线程。
`int`	`countStackFrames()`	不推荐使用，要删除：此API元素将在以后的版本中删除。此调用的定义取决于`suspend()` ，已弃用。
`static Thread`	`currentThread()`	返回对当前正在执行的线程对象的引用。
`static void`	`dumpStack()`	将当前线程的堆栈跟踪打印到标准错误流。
`static int`	`enumerate(Thread[] tarray)`	将当前线程的线程组及其子组中的每个活动线程复制到指定的数组中。
`static Map<Thread,StackTraceElement[]>`	`getAllStackTraces()`	返回所有活动线程的堆栈跟踪映射。
`ClassLoader`	`getContextClassLoader()`	返回此线程的上下文 `ClassLoader` 。
`static Thread.UncaughtExceptionHandler`	`getDefaultUncaughtExceptionHandler()`	返回由于未捕获的异常而导致线程突然终止时调用的默认处理程序。
`long`	`getId()`	返回此Thread的标识符。
`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()` ，由于它易于死锁，因此已被弃用。
`void`	`run()`	如果此线程是使用单独的`Runnable`运行对象构造的，则调用该`Runnable`对象的`run`方法; 否则，此方法不执行任何操作并返回。
`void`	`setContextClassLoader(ClassLoader cl)`	为此Thread设置上下文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()`	已过时。这种方法本质上是不安全的。
`void`	`suspend()`	已过时。此方法已被弃用，因为它本身就容易出现死锁。
`String`	`toString()`	返回此线程的字符串表示形式，包括线程的名称，优先级和线程组。
`static void`	`yield()`	向调度程序提示当前线程是否愿意产生其当前使用的处理器。

声明方法的类 java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- 字段详细信息
  - MIN_PRIORITY
```
public static final int MIN_PRIORITY
```
    线程可以拥有的最低优先级。
    
    另请参见：
    
    常数字段值
  - NORM_PRIORITY
```
public static final int NORM_PRIORITY
```
    分配给线程的默认优先级。
    
    另请参见：
    
    常数字段值
  - MAX_PRIORITY
```
public static final int MAX_PRIORITY
```
    线程可以拥有的最大优先级。
    
    另请参见：
    
    常数字段值
- 构造方法详细信息
  - 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方法。
    
    此外，当由子类的构造函数直接或间接调用时，将使用RuntimePermission("enableContextClassLoaderOverride")权限调用其checkPermission方法，该子类将覆盖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)相同，并且具有抑制或不禁止从构造线程继承可继承线程局部变量的初始值的能力。这允许对可继承的线程局部变量进行更精细的控制。为inheritThreadLocals传递值false时必须小心，因为如果新线程执行期望继承特定线程局部值的代码，则可能会导致意外行为。
    
    为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()
```
    向调度程序提示当前线程是否愿意产生其当前使用的处理器。调度程序可以忽略此提示。
    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没有调用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()
```
    Deprecated.
    This method is inherently unsafe. Stopping a thread with Thread.stop causes it to unlock all of the monitors that it has locked (as a natural consequence of the unchecked ThreadDeath exception propagating up the stack). If any of the objects previously protected by these monitors were in an inconsistent state, the damaged objects become visible to other threads, potentially resulting in arbitrary behavior. Many uses of stop should be replaced by code that simply modifies some variable to indicate that the target thread should stop running. The target thread should check this variable regularly, and return from its run method in an orderly fashion if the variable indicates that it is to stop running. If the target thread waits for long periods (on a condition variable, for example), the interrupt method should be used to interrupt the wait. For more information, see Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?.
    
    强制线程停止执行。
    如果安装了安全管理器， checkAccess this作为参数调用其checkAccess方法。这可能导致引发SecurityException （在当前线程中）。
    
    如果此线程与当前线程不同（即，当前线程正在尝试停止除自身之外的线程），则RuntimePermission("stopThread")调用安全管理器的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)
  - 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()
  - isAlive
```
public final boolean isAlive()
```
    测试此线程是否存活。如果一个线程已经启动并且还没有死亡，它就是活着的。
    
    结果
    
    true如果此线程true活动状态; 否则为false 。
  - suspend
```
@Deprecated(since="1.2")
public final void suspend()
```
    Deprecated.
    This method has been deprecated, as it is inherently deadlock-prone. If the target thread holds a lock on the monitor protecting a critical system resource when it is suspended, no thread can access this resource until the target thread is resumed. If the thread that would resume the target thread attempts to lock this monitor prior to calling resume, deadlock results. Such deadlocks typically manifest themselves as "frozen" processes. For more information, see Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?.
    
    暂停这个帖子。
    首先，调用此线程的checkAccess方法，不带参数。这可能导致抛出SecurityException （在当前线程中）。
    
    如果线程处于活动状态，它将被暂停并且不会继续进行，除非并且直到它恢复。
    
    异常
    
    SecurityException - 如果当前线程无法修改此线程。
    
    另请参见：
    
    checkAccess()
  - resume
```
@Deprecated(since="1.2")
public final void resume()
```
    Deprecated.
    This method exists solely for use with suspend(), which has been deprecated because it is deadlock-prone. For more information, see 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()
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    The definition of this call depends on suspend(), which is deprecated. Further, the results of this call were never well-defined. This method is subject to removal in a future version of 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)
```
    为此Thread设置上下文ClassLoader。可以在创建线程时设置上下文ClassLoader，并允许线程的创建者在加载类和资源时通过getContextClassLoader向线程中运行的代码提供适当的类加载器。
    如果存在安全管理器，则以 RuntimePermission ("setContextClassLoader")权限调用其checkPermission方法，以查看是否允许设置上下文ClassLoader。
    
    参数
    
    cl - 此Thread的上下文ClassLoader，或null表示系统类加载器（或者，失败，引导类加载器）
    
    异常
    
    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()
```
    返回此Thread的标识符。线程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线程的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

嵌套类汇总

字段汇总

构造方法摘要

方法摘要

声明方法的类 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

interrupt

interrupted

isInterrupted

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