java多线程之Thread类

淡淡的烟草味﹌ 2021-09-18 14:52 385阅读 0赞

## Class Thread ##

java.lang.Object
         java.lang.Thread

实现接口：`Runnable`  
直接被继承的子类：`ForkJoinWorkerThread`

--------------------

public class Thread
    extends Object
    implements Runnable

*thread*是程序中的执行线程，Java虚拟机允许应用程序同时运行多个执行线程。

每个线程都有一个优先级，优先级较高的线程优先于优先级较低的线程执行，每个线程都可能被标记为一个守护线程。当在某个线程中运行的代码创建一个新的线程对象时，新线程的优先级初始设置为创建它的线程的优先级，并且当且仅当创建它的线程是一个守护线程时，它是一个守护线程。

当Java虚拟机启动时，通常只有一个非守护线程（通常称为某些指定类的`main`方法），Java虚拟机继续执行线程，直到发生以下任何一种情况:

*  类的`exit`方法在运行时被调用，并且安全管理器允许`exit`操作发生。
 *  所有非守护线程都已死亡，要么从调用`run`方法那里返回，要么抛出一个传播到`run`方法之外的异常。

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

class PrimeThread extends Thread {
        PrimeThread(long minPrime) {
            this.minPrime = minPrime;
        }
    
        public void run() {
            // compute primes larger than minPrime
              . . .
        }
    }

下面的代码将创建一个线程并启动运行:

PrimeThread p = new PrimeThread(143);
    p.start();

另一种创建线程的方法是声明实现`Runnable`接口的类，该类实现`run`方法，然后可以分配类的一个实例，在创建线程时作为参数传递，并启动。另一种风格中的相同示例如下:

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()`

### 内嵌类汇总 ###

`static class Thread.State`

*  线程的状态

`static interface Thread.UncaughtExceptionHandler`

*  当线程因未捕获异常而突然终止时调用的处理程序的接口

### 字段汇总 ###

`static int MAX_PRIORITY`

*  线程可以拥有的最大优先级

`static int MIN_PRIORITY`

*  线程可以拥有的最小优先级

`static int NORM_PRIORITY`

*  分配给线程的默认优先级

### 构造函数汇总 ###

`Thread()`

*  分配一个新的线程对象

`Thread(Runnable target)`

*  分配一个新的线程对象，使其具有*target*作为其运行对象

`Thread(Runnable target, String name)`

*  分配一个新的线程对象，使其具有*target*作为其运行对象，并具有指定的*name*作为其名称

`Thread(String name)`

*  分配一个新的线程对象，具有指定的*name*作为其名称

`Thread(ThreadGroup group, Runnable target)`

*  分配一个新的线程对象，使其具有*target*作为其运行对象，并且属于*group*引用的线程组

`Thread(ThreadGroup group, Runnable target, String name)`

*  分配一个新的线程对象，使其具有*target*作为其运行对象，具有指定的*name*作为其名称，并且属于*group*引用的线程组

`Thread(ThreadGroup group, Runnable target, String name, long stackSize)`

*  分配一个新的线程对象，使其具有*target*作为其运行对象，具有指定的*name*作为其名称，并且属于由*group*引用的线程组，并具有指定的堆栈大小。

`Thread(ThreadGroup group, String name)`

*  分配一个新的线程对象，具有指定的*name*作为其名称，并且属于由*group*引用的线程组

### 方法汇总 ###

`static int activeCount()`

*  返回当前线程组及其子组中活动线程的数量的估算

`void checkAccess()`

*  确定当前运行的线程是否具有修改该线程的权限

`protected Object clone()`

*  一个线程被没有意义的克隆将抛出*CloneNotSupportedException*

`int countStackFrames()`

*  **已废弃**。这个调用的定义依赖于`suspend()`，它已被废弃，此外，这个调用的结果从来没有明确的定义

`static Thread currentThread()`

*  返回对当前执行的线程对象的引用

`void destroy()`

*  **已废弃**。此方法最初设计为在不进行任何清理的情况下销毁此线程，它所持有的任何监视器都将保持锁定状态，然而，该方法从未实现，如果要实现的话，它很可能会像`suspend()`那样出现死锁。如果目标线程在被销毁时持有保护关键系统资源的锁，则没有线程可以再次访问该资源，如果另一个线程试图锁定该资源，则会导致死锁。这种死锁通常表现为“冻结”进程。

`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()`，因为它容易死锁，所以已被弃用。

`void run()`

*  如果这个线程是使用一个单独的Runnable run对象构造的，那么将调用该Runnable对象的run方法，否则，此方法将不执行任何操作并返回。

`void setContextClassLoader(ClassLoader cl)`

*  设置此线程的上下文类加载器

`void setDaemon(boolean on)`

*  将此线程标记为守护线程或用户线程

`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*的许多用法。目标线程应该定期检查这个变量，如果该变量表明它将停止运行，则以有序的方式从它的*run*方法返回。如果目标线程等待很长时间(例如，在条件变量上)，则应该使用中断方法来中断等待。

`void stop(Throwable obj)`

*  **已废弃**。这种方法最初的目的是迫使线程停止并抛出一个给定的可抛出的异常，它本质上是不安全的(参见stop())，而且还可以用于生成目标线程不准备处理的异常。

`void suspend()`

*  **已废弃**。这个方法已经被弃用，因为它天生就容易死锁。如果目标线程在监视器上持有锁，以保护挂起的关键系统资源，则在目标线程恢复之前，没有线程可以访问该资源。如果要恢复目标线程的线程试图在调用resume之前锁定此监视器，则会导致死锁。这种死锁通常表现为“冻结”进程。

`String toString()`

*  返回该线程的字符串表示形式，包括该线程的名称、优先级和线程组

`static void yield()`

*  给调度器的一个提示，说明当前线程愿意提供当前对处理器的使用

#### 从类*java.lang.Object*继承的方法 ####

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

### 字段的细节 ###

> **MIN\_PRIORITY**
> 
> `public static final int MIN_PRIORITY = 1`
> 
> 线程可以拥有的最小优先级。

--------------------

> **NORM\_PRIORITY**
> 
> `public static final int NORM_PRIORITY = 5`
> 
> 分配给线程的默认优先级。

--------------------

> **MAX\_PRIORITY**
> 
> `public static final int MAX_PRIORITY = 10`
> 
> 线程可以拥有的最大优先级。

### 构造函数的细节 ###

> **Thread**
> 
> `public Thread()`
> 
> 分配一个新的线程对象，这个构造函数具有与Thread (null, null, gname)相同的效果，其中gname是一个新生成的名称，自动生成的名称为“Thread-”+n形式，其中n为整数。

--------------------

> **Thread**
> 
> `public Thread(Runnable target)`
> 
> 分配一个新的线程对象，这个构造函数具有与Thread (null, target, gname)相同的效果，其中gname是一个新生成的名称，自动生成的名称为“Thread-”+n形式，其中n为整数。
> 
> **参数**：  
> ***target*** \- 在启动该线程时调用其*run*方法的对象，如果为*null*，这个类*run*方法什么都不做。

--------------------

> **Thread**
> 
> `public Thread(ThreadGroup group, Runnable target)`
> 
> 分配一个新的线程对象，这个构造函数具有与Thread (group, target, gname)相同的效果，其中gname是一个新生成的名称，自动生成的名称为“Thread-”+n形式，其中n为整数。
> 
> **参数**：  
> ***group*** \- 线程组，如果*null*并且有一个安全管理器，那么组由`SecurityManager.getThreadGroup()`决定，如果没有安全管理器或`SecurityManager.getThreadGroup()`返回null，则将组设置为当前线程的线程组。  
> ***target*** \- 在启动该线程时调用其*run*方法的对象，如果为*null*，这个类*run*方法什么都不做。  
> **Throws**:  
> **SecurityException** \- 如果当前线程不能在指定的线程组中创建线程。