Thread (Java Platform SE 8 )

java.lang.Object
- java.lang.Thread

All Implemented Interfaces:

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争论这类构造函数或方法会导致一个NullPointerException被。
从以下版本开始：

JDK1.0

另请参见：

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

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Thread.State` 线程状态。
`static interface`	`Thread.UncaughtExceptionHandler` 处理程序时调用的 `Thread`突然终止由于未捕获的异常界面。

Field Summary

Fields
Modifier and Type	Field 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 Type	Method 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()` 返回所有活线程的堆栈跟踪Map。
`ClassLoader`	`getContextClassLoader()` 返回该线程的上下文类加载器。
`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)` 设置此线程上下文类加载器。
`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)` 过时的。这种方法的最初目的是迫使一个线程停止，扔给`Throwable`作为例外。它本质上是不安全的（见`stop()`详情），并可产生异常目标线程并没有准备好处理。更多信息，见Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?。
`void`	`suspend()` 过时的。此方法已被否决，因为它本质上是容易导致死锁。如果目标线程在暂停时保持监视器上的锁的锁，则没有线程可以访问该资源，直到恢复目标线程。如果线程，将恢复目标线程试图锁定监控呼叫`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

- Field Detail
  - 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
- Constructor Detail
  - Thread
```
public Thread()
```
    分配一个新的 Thread对象。此构造函数为 Thread (null, null, gname)具有相同的效果，在 gname是生成一个新的名字。自动生成的名称是形式 "Thread-"+nulln，哪里nulln是整数。
  - Thread
```
public Thread(Runnable target)
```
    分配一个新的 Thread对象。此构造函数为 Thread (null, target, gname)具有相同的效果，在 gname是生成一个新的名字。自动生成的名称是形式 "Thread-"+nulln，哪里nulln是整数。
    
    参数
    
    target -对象的方法被调用时，这个 run线程开始。如果 null，这类方法不 run。
  - Thread
```
public Thread(ThreadGroup group,
              Runnable target)
```
    分配一个新的 Thread对象。此构造函数为 Thread (group, target, gname)具有相同的效果，在 gname是生成一个新的名字。自动生成的名称是形式 "Thread-"+nulln，哪里nulln是整数。
    
    参数
    
    group的线程组。如果 null和存在安全管理器，该集团是由 SecurityManager.getThreadGroup()。如果没有一个安全经理或 SecurityManager.getThreadGroup()返回 null，组设置为当前线程的线程组。
    
    target -对象的方法被调用时，这个 run线程开始。如果 null，这个线程的运行方法调用。
    
    异常
    
    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，这个线程的运行方法调用。
    
    name -新线程的名称
  - Thread
```
public Thread(ThreadGroup group,
              Runnable target,
              String name)
```
    分配一个新的 Thread对象具有 target为经营对象，具有指定的 name正如其名，属于线程组被 group。
    如果存在安全管理器，它的checkAccess方法与可以作为参数调用。
    
    此外，其checkPermission方法被调用时调用的RuntimePermission("enableContextClassLoaderOverride")许可直接或间接通过子类覆盖getContextClassLoader setContextClassLoader方法或构造函数。
    
    新创建的线程的优先级设置等于创建它的线程的优先级，也就是当前正在运行的线程。方法setPriority可以用来改变优先为新值。
    
    新创建的线程最初被标记为守护线程的当且仅当线程创建目前标记为守护线程。方法setDaemon可以用来改变线程是否是一个守护进程。
    
    参数
    
    group的线程组。如果 null和存在安全管理器，该集团是由 SecurityManager.getThreadGroup()。如果没有一个安全经理或 SecurityManager.getThreadGroup()返回 null，组设置为当前线程的线程组。
    
    target -对象的方法被调用时，这个 run线程开始。如果 null，这个线程的运行方法调用。
    
    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实现其中一个应用程序的运行。
    
    实现注意：java平台鼓励实施者相对于stackSize参数实施行为的文件。
    
    参数
    
    group的线程组。如果 null和存在安全管理器，该集团是由 SecurityManager.getThreadGroup()。如果没有一个安全经理或 SecurityManager.getThreadGroup()返回 null，组设置为当前线程的线程组。
    
    target -对象的方法被调用时，这个 run线程开始。如果 null，这个线程的运行方法调用。
    
    name -新线程的名称
    
    stackSize -新线程所需的堆栈大小，或零，表明此参数被忽略。
    
    异常
    
    SecurityException -如果当前线程不能创建指定的线程组的线程
    
    从以下版本开始：
    
    一点四
- 方法详细信息
  - currentThread
```
public static Thread currentThread()
```
    返回当前正在执行的线程对象的引用。
    
    结果
    
    当前执行线程。
  - yield
```
public static void yield()
```
    给调度程序的一个提示，当前线程愿意得到它当前的处理器的使用。调度程序可以自由地忽略这个提示。
    产量是一个启发式的尝试，以改善线程之间的相对进展，否则将过度使用一个中央处理器。它的使用应结合详细的分析和基准，以确保它实际上有所需的效果。
    
    使用这种方法是不恰当的。它可能是有用的调试或测试的目的，它可能有助于重现由于种族条件的错误。这也可能是有用的在设计并发控制结构如在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 -如果任何线程中断了当前线程。当前线程的空中断状态被清除时，抛出该异常。
  - 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
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原因try陈述是在线程执行正式死finally条款）。如果一个catch子句捕获一个ThreadDeath对象，重要的是抛出的对象，线程真的死了。
    
    顶级的错误处理，否则未捕获的异常反应不打印出消息或通知应用程序如果未捕获的异常是ThreadDeath实例。
    
    异常
    
    SecurityException -如果当前线程不能修改这个线程。
    
    另请参见：
    
    interrupt()， checkAccess()， run()， start()， ThreadDeath， ThreadGroup.uncaughtException(Thread,Throwable)， SecurityManager.checkAccess(Thread)， SecurityManager.checkPermission(java.security.Permission)
  - stop
```
@Deprecated
public final void stop(Throwable obj)
```
    过时的。这种方法的最初目的是迫使一个线程停止，扔给Throwable作为例外。它本质上是不安全的（见stop()详情），并可产生异常目标线程并没有准备好处理。更多信息，见Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?。
    
    把 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。
    
    如果该线程被阻塞在I/O操作在一个InterruptibleChannel然后通道将被关闭，该线程的中断状态将被设置，并且线程将获得ClosedByInterruptException。
    
    如果该线程是在一个Selector然后该线程的中断状态将被设置，它会立即从选择操作回流受阻，可能是一个非零的值，就像选择器的wakeup方法调用。
    
    如果前面的条件没有保持，那么这个线程的中断状态将被设置。
    
    中断一个不活的线程不需要任何效果。
    
    异常
    
    SecurityException -如果当前线程不能修改这个线程
  - interrupted
```
public static boolean interrupted()
```
    测试当前线程是否已被中断。螺纹的空中断状态是通过这种方法。换句话说，如果这个方法被连续调用两次，第二个调用将返回错误（除非当前的线程再次被中断，在第一次调用已经清除了它的中断状态，在第二次调用之前检查它）。
    一个线程中断被忽略，因为一个线程不活在中断的时间将反映这个方法返回假。
    
    结果
    
    true如果当前线程被中断； false否则。
    
    另请参见：
    
    isInterrupted()
  - isInterrupted
```
public boolean isInterrupted()
```
    测试此线程是否已被中断。螺纹的空中断状态不受本法。
    一个线程中断被忽略，因为一个线程不活在中断的时间将反映这个方法返回假。
    
    结果
    
    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否则活着。
  - suspend
```
@Deprecated
public final void suspend()
```
    过时的。此方法已被否决，因为它本质上是容易导致死锁。如果目标线程在暂停时保持监视器上的锁的锁，则没有线程可以访问该资源，直到恢复目标线程。如果线程，将恢复目标线程试图锁定监控呼叫resume之前，僵局的结果。这种死锁通常表现为“冻结”的过程。更多信息，见Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?。
    
    挂起线程。
    首先，这个线程的checkAccess方法不带参数调用。这可能会导致在扔一个SecurityException （在当前线程）。
    
    如果线程是活着的，它被暂停，并没有取得进一步的进展，除非和直到它被恢复。
    
    异常
    
    SecurityException -如果当前线程不能修改这个线程。
    
    另请参见：
    
    checkAccess()
  - resume
```
@Deprecated
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()
```
    返回此线程所属的线程组。此方法返回无效，如果这个线程已经死了（被停止）。
    
    结果
    
    该线程组。
  - 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.isAlive this.wait条件。作为一个线程终止this.notifyAll方法被调用。建议的应用程序不使用wait，notify，或notifyAll在Thread实例。
    
    参数
    
    millis -等待的时间以毫秒为单位
    
    异常
    
    IllegalArgumentException -如果 millis值为负
    
    InterruptedException -如果任何线程中断了当前线程。当前线程的空中断状态被清除时，抛出该异常。
  - join
```
public final void join(long millis,
                       int nanos)
                throws InterruptedException
```
    在等待最 millis毫秒加 nanos纳秒这个线程的死。
    该实现使用循环条件this.isAlive this.wait电话。作为一个线程终止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()
```
    将当前线程的堆栈跟踪打印到标准错误流中。此方法仅用于调试。
    
    另请参见：
    
    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()
```
    返回该线程的上下文类加载器。上下文类加载器通过线程的创建者提供使用的代码在这个线程运行时加载的类和资源。如果不 set，默认是父线程上下文的类加载器。的原始线程上下文类加载器通常设置为用于加载应用程序的类加载器。
    如果安全管理器，和调用的类装载器是不null不相同或祖先的上下文类加载器，那么这个方法调用安全经理的checkPermission方法与RuntimePermission("getClassLoader")权限验证检索上下文类加载器允许。
    
    结果
    
    这个线程的上下文类加载器，或 null指示系统类加载器（或者，如果失败，引导类加载器）
    
    异常
    
    SecurityException -如果当前线程的上下文类加载器不能
    
    从以下版本开始：
    
    一点二
  - setContextClassLoader
```
public void setContextClassLoader(ClassLoader cl)
```
    设置此线程上下文类加载器。上下文类加载器可以设置当一个线程被创建，并允许该线程的创作者提供合适的类装载器，通过 getContextClassLoader，代码在线程运行时加载的类和资源。
    如果安全管理器，它的checkPermission方法与RuntimePermission("setContextClassLoader")权限是否设置上下文类加载器允许调用。
    
    参数
    
    cl -这个线程的上下文类加载器，或空指示系统类加载器（或者，如果失败，引导类加载器）
    
    异常
    
    SecurityException -如果当前线程的上下文类加载器无法设置
    
    从以下版本开始：
    
    一点二
  - holdsLock
```
public static boolean holdsLock(Object obj)
```
    返回 true如果当前线程拥有指定对象上的锁的监控。
    该方法的目的是允许一个程序断言当前线程已经拥有一个指定的锁：
```
维护线程。holdslock（obj）；
```
    参数
    
    obj -以测试锁的所有权客体
    
    结果
    
    true如果当前线程持有指定对象上的锁的监控。
    
    异常
    
    NullPointerException如果obj是 null
    
    从以下版本开始：
    
    一点四
  - getStackTrace
```
public StackTraceElement[] getStackTrace()
```
    返回表示此线程的堆栈转储的堆栈跟踪元素的数组。此方法将返回一零个长度数组，如果这个线程还没有启动，已经启动，但尚未计划运行的系统，或已终止。如果返回的数组是非零的长度，那么数组的第一个元素代表堆栈的顶部，这是序列中最新的方法调用。数组的最后一个元素表示堆栈的底部，这是序列中的最近的方法调用。
    如果存在安全管理器，这个线程不是当前线程，然后安全经理的checkPermission方法称为一个RuntimePermission("getStackTrace")许可是否可以获取堆栈跟踪。
    
    某些虚拟机可能在某些情况下，从堆栈跟踪中省略一个或多个堆栈帧。在极端情况下，一个没有关于此线程的堆栈跟踪信息的虚拟机被允许返回从该方法中返回的一零个长度数组。
    
    结果
    
    对 StackTraceElement数组，每个代表一个栈帧。
    
    异常
    
    SecurityException -如果存在一个安全管理及其 checkPermission方法不允许获得线程的堆栈跟踪。
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    SecurityManager.checkPermission(java.security.Permission)， RuntimePermission， Throwable.getStackTrace()
  - getAllStackTraces
```
public static Map<Thread,StackTraceElement[]> getAllStackTraces()
```
    返回所有活线程的堆栈跟踪Map。Map键线程和每个Map的价值是 StackTraceElement表示相应的 Thread堆栈转储数组。返回栈中的 getStackTrace方法指定的格式。
    当这种方法被调用时，线程可能正在执行。每个线程的堆栈跟踪只代表一个快照，每个堆栈跟踪可以在不同的时间获得。如果虚拟机没有关于线程的堆栈跟踪信息，则将在Map值中返回一零个长度的数组。
    
    如果存在安全管理器，那么安全经理的checkPermission方法称为一个RuntimePermission("getStackTrace")许可以及RuntimePermission("modifyThreadGroup")许可是否可以得到所有线程的堆栈跟踪。
    
    结果
    
    一个 Map从 Thread到 StackTraceElement表示相应的线程的堆栈跟踪阵列。
    
    异常
    
    SecurityException -如果存在一个安全管理及其 checkPermission方法不允许获得线程的堆栈跟踪。
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    getStackTrace()， SecurityManager.checkPermission(java.security.Permission)， RuntimePermission， Throwable.getStackTrace()
  - getId
```
public long getId()
```
    返回此线程的标识符。线程ID是一个积极的 long数时产生的线程创建。线程标识是唯一的，在它的生命周期中保持不变。当一个线程被终止时，这个线程的身份证可以被重用。
    
    结果
    
    这个线程的身份证。
    
    从以下版本开始：
    
    一点五
  - getState
```
public Thread.State getState()
```
    返回此线程的状态。这种方法被设计用于监视系统状态，而不是用于同步控制。
    
    结果
    
    该线程的状态。
    
    从以下版本开始：
    
    一点五
  - setDefaultUncaughtExceptionHandler
```
public static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)
```
    设置默认处理程序时调用的线程突然终止由于未捕获的异常，并没有其他的处理一直是该线程的定义。
    未捕获的异常处理是通过线程控制，然后通过线程的ThreadGroup对象，最后由默认未捕获的异常处理程序。如果线程没有一个明确的未捕获的异常处理程序集，和线程的线程组（包括父线程组）没有专门的uncaughtException方法，则默认处理程序的uncaughtException方法将被调用。
    
    通过设置默认未捕获的异常处理程序，应用程序可以改变，未捕获的异常处理方式（如日志记录到一个特定的设备或文件）的线程已经不管“违约”行为的系统提供的接受。
    
    注意默认的捕获的异常处理程序通常不应该按照线程的ThreadGroup对象，如可能导致无限递归。
    
    参数
    
    eh -使用默认的捕获的异常处理程序对象。如果 null然后没有默认处理程序。
    
    异常
    
    SecurityException -如果一个安全管理存在，它否认 RuntimePermission ("setDefaultUncaughtExceptionHandler")
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    setUncaughtExceptionHandler(java.lang.Thread.UncaughtExceptionHandler)， getUncaughtExceptionHandler()， ThreadGroup.uncaughtException(java.lang.Thread, java.lang.Throwable)
  - getDefaultUncaughtExceptionHandler
```
public static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler()
```
    返回默认处理程序时调用的线程突然终止由于未捕获的异常。如果返回值是 null，没有默认。
    
    结果
    
    默认未捕获的异常处理程序的所有线程
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    setDefaultUncaughtExceptionHandler(java.lang.Thread.UncaughtExceptionHandler)
  - getUncaughtExceptionHandler
```
public Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()
```
    返回的句柄调用时，该线程突然终止，由于未捕获的异常。如果线程没有捕获的异常处理程序显式设置然后这个线程的 ThreadGroup对象返回，除非这个线程已经终止，在这种情况下， null返回。
    
    结果
    
    这个线程捕获的异常处理程序
    
    从以下版本开始：
    
    一点五
  - setUncaughtExceptionHandler
```
public void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)
```
    设置处理程序调用时，该线程突然终止，由于未捕获的异常。
    一个线程可以如何回应未捕获的异常在捕获的异常处理程序显式设置完全控制。如果没有这样的处理是将线程的ThreadGroup对象作为其处理程序。
    
    参数
    
    eh -使用这个线程的未捕获的异常处理程序对象。如果 null然后这个线程没有显式的处理程序。
    
    异常
    
    SecurityException -如果当前线程不允许修改该线程。
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    setDefaultUncaughtExceptionHandler(java.lang.Thread.UncaughtExceptionHandler)， ThreadGroup.uncaughtException(java.lang.Thread, java.lang.Throwable)

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class Thread

Nested Class Summary

Field Summary

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Field Detail

MIN_PRIORITY

NORM_PRIORITY

MAX_PRIORITY

Constructor Detail

Thread

Thread

Thread

Thread

Thread

Thread

Thread

Thread

方法详细信息

currentThread

yield

sleep

sleep

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