Java领域中的线程机制-线程（四）

　　生命周期

　　在 Java 领域，实现并发程序的主要手段就是多线程。线程是本身就是操作系统里的一个概念，不同的开发语言如 Java、C# 等都对其进行了封装，但是万变不离操作系统。

　　Java 语言里的线程本质上就是操作系统的线程，它们是一一对应的。

　　在操作系统层面，线程也有“生老病死”，专业的说法叫有生命周期。对于有生命周期的事物，要学好它，思路非常简单，只要能搞懂生命周期中各个节点的状态转换机制即可。

　　虽然不同的开发语言对于操作系统线程进行了不同的封装，但是对于线程的生命周期这部分，基本上是雷同的。

　　通用的线程生命周期基本上可以用 初始状态、可运行状态、运行状态、休眠状态和终止状态等“五态模型”来描述。

　　Java 语言中线程共有六种状态，分别是：NEW(初始化状态)RUNNABLE(可运行 / 运行状态)BLOCKED(阻塞状态)WAITING(无时限等待)TIMED_WAITING(有时限等待)TERMINATED(终止状态)。

　　其实在操作系统层面，Java 线程中的 BLOCKED、WAITING、TIMED_WAITING 是一种状态，即前面我们提到的休眠状态。也就是说只要 Java 线程处于这三种状态之一，那么这个线程就永远没有 CPU 的使用权。

　　其中，BLOCKED、WAITING、TIMED_WAITING 可以理解为线程导致休眠状态的三种原因。那具体是哪些情形会导致线程从 RUNNABLE 状态转换到这三种状态呢?而这三种状态又是何时转换回 RUNNABLE 的呢?以及 NEW、TERMINATED 和 RUNNABLE 状态是如何转换的?

　　1. RUNNABLE 与 BLOCKED 的状态转换

　　只有一种场景会触发这种转换，就是线程等待 synchronized 的隐式锁。synchronized 修饰的方法、代码块同一时刻只允许一个线程执行，其他线程只能等待，这种情况下，等待的线程就会从 RUNNABLE 转换到 BLOCKED 状态。而当等待的线程获得 synchronized 隐式锁时，就又会从 BLOCKED 转换到 RUNNABLE 状态。

　　2. RUNNABLE 与 WAITING 的状态转换

　　总体来说，有三种场景会触发这种转换，其中：

　　第一种场景，获得 synchronized 隐式锁的线程，调用无参数的 Object.wait() 方法。其中，wait() 方法我们在上一篇讲解管程的时候已经深入介绍过了，这里就不再赘述。

　　第二种场景，调用无参数的 Thread.join() 方法。其中的 join() 是一种线程同步方法，例如有一个线程对象 thread A，当调用 A.join() 的时候，执行这条语句的线程会等待 thread A 执行完，而等待中的这个线程，其状态会从 RUNNABLE 转换到 WAITING。当线程 thread A 执行完，原来等待它的线程又会从 WAITING 状态转换到 RUNNABLE。

　　第三种场景，调用 LockSupport.park() 方法。其中的 LockSupport 对象，也许你有点陌生，其实 Java 并发包中的锁，都是基于它实现的。调用 LockSupport.park() 方法，当前线程会阻塞，线程的状态会从 RUNNABLE 转换到 WAITING。调用 LockSupport.unpark(Thread thread) 可唤醒目标线程，目标线程的状态又会从 WAITING 状态转换到 RUNNABLE。

　　3. RUNNABLE 与 TIMED_WAITING 的状态转换

　　有五种场景会触发这种转换，其中：

　　调用带超时参数的 Thread.sleep(long millis) 方法。

　　获得 synchronized 隐式锁的线程，调用带超时参数的 Object.wait(long timeout) 方法。

　　调用带超时参数的 Thread.join(long millis) 方法。

　　调用带超时参数的 LockSupport.parkNanos(Object blocker, long deadline) 方法。

　　调用带超时参数的 LockSupport.parkUntil(long deadline) 方法。

　　4. 从 NEW 到 RUNNABLE 的状态

　　Java 刚创建出来的 Thread 对象就是 NEW 状态，而创建 Thread 对象主要有两种方法：

　　首先，第一种方式是继承 Thread 对象，重写 run() 方法

　　// 自定义线程对象

　　class ApplicationThread extends Thread {

　　public void run() {

　　// 线程需要执行的代码

　　......

　　}

　　}

　　// 创建线程对象

　　ApplicationThread applicationThread = new ApplicationThread();

　　其次，另一种方式是实现 Runnable 接口，重写 run() 方法，并将该实现类作为创建 Thread 对象的参数

　　// 实现Runnable接口

　　class ApplicationThread implements Runnable {

　　@Override

　　public void run() {

　　// 线程需要执行的代码

　　......

　　}

　　}

　　// 创建线程对象

　　Thread thread = new Thread(new ApplicationThread());

　　NEW 状态的线程，不会被操作系统调度，因此不会执行。Java 线程要执行，就必须转换到 RUNNABLE 状态。从 NEW 状态转换到 RUNNABLE 状态很简单，只要调用线程对象的 start() 方法即可。

　　5. 从 RUNNABLE 到 TERMINATED

　　线程执行完 run() 方法后，会自动转换到 TERMINATED 状态，当然如果执行 run() 方法的时候异常抛出，也会导致线程终止。有时候我们需要强制中断 run() 方法的执行。

　　一般来说， run() 方法访问一个很慢的网络，我们等不下去了，想终止怎么办呢?

　　Java 的 Thread 类里面倒是有个 stop() 方法，不过已经标记为 @Deprecated，所以不建议使用了。正确的姿势其实是调用 interrupt() 方法。

　　那么，stop() 和 interrupt() 方法的主要区别是什么呢?

　　stop() 方法会真的杀死线程，不给线程喘息的机会，如果线程持有 ReentrantLock 锁，被 stop() 的线程并不会自动调用 ReentrantLock 的 unlock() 去释放锁，那其他线程就再也没机会获得 ReentrantLock 锁，这实在是太危险了。所以该方法就不建议使用了，类似的方法还有 suspend() 和 resume() 方法，这两个方法同样也都不建议使用。

　　interrupt() 方法仅仅是通知线程，线程有机会执行一些后续操作，同时也可以无视这个通知。

　　被 interrupt 的线程，是怎么收到通知的呢?

　　一种是异常：

　　线程 A 处于 WAITING、TIMED_WAITING 状态时，如果其他线程调用线程 A 的 interrupt() 方法，会使线程 A 返回到 RUNNABLE 状态，同时线程 A 的代码会触发 InterruptedException 异常。上面我们提到转换到 WAITING、TIMED_WAITING 状态的触发条件，都是调用了类似 wait()、join()、sleep() 这样的方法，我们看这些方法的签名，发现都会 throws InterruptedException 这个异常。这个异常的触发条件就是：其他线程调用了该线程的 interrupt() 方法。

　　当线程 A 处于 RUNNABLE 状态时，并且阻塞在 java.nio.channels.InterruptibleChannel 上时，如果其他线程调用线程 A 的 interrupt() 方法，线程 A 会触发 java.nio.channels.ClosedByInterruptException 这个异常;而阻塞在 java.nio.channels.Selector 上时，如果其他线程调用线程 A 的 interrupt() 方法，线程 A 的 java.nio.channels.Selector 会立即返回。

　　另一种是主动检测：

　　如果线程处于 RUNNABLE 状态，并且没有阻塞在某个 I/O 操作上，例如中断计算圆周率的线程 A，这时就得依赖线程 A 主动检测中断状态了。

　　如果其他线程调用线程 A 的 interrupt() 方法，那么线程 A 可以通过 isInterrupted() 方法，检测是不是自己被中断。

　　更多关于“java培训”的问题，欢迎咨询千锋教育在线名师。千锋教育多年办学，课程大纲紧跟企业需求，更科学更严谨，每年培养泛IT人才近2万人。不论你是零基础还是想提升，都可以找到适合的班型，千锋教育随时欢迎你来试听。