线程的状态与中断

一、线程的状态

线程是操作系统的一个概念，不同语言对其做了不同封装。Java线程和操作系统线程进行对应，完成相应操作。

1. 通用线程状态

• 初始状态
• 可运行状态
• 运行状态
• 休眠状态
• 终止状态

2. Java线程状态
位于java.lang.Thread.State枚举类中

状态名称	说明
NEW	初始状态
RUNNABLE	线程处于就绪状态或者运行状态
BLOCK	阻塞状态，尝试获取同步锁
WAITTING	等待状态，调用wait,join,park方法
TIME_WAITTING	调用sleep(timeout)、wait(timeout)等操作操作进入超时等待状态
TERMINATED	线程终止

Java线程状态将就绪和运行状态合并成Runnable，同时将休眠状态分成Block，Waitting，Time_Waitting

二、线程的生命周期

NEW 到 RUNNABLE 状态

Java刚创建出来的 Thread 对象就是 NEW 状态，不会被操作系统调度，调用线程的start()方法就可以将状态转换成Runnable.

RUNNABLE 到 BLOCKED 的状态转换

只有一种场景会触发这种转换，就是线程获取同步锁synchronized失败，进入Blocked状态。

RUNNABLE 到 WAITING 的状态转换

• 获得synchronized的线程调用wait方法
• 调用Thread.join()方法
• 调用LockSupport.park()方法

RUNNABLE 到 TIMED_WAITING 的状态转换

1. 调用带超时参数的 Thread.sleep(long millis) 方法；
2. 获得 synchronized 隐式锁的线程，调用带超时参数的 Object.wait(long timeout) 方法；
3. 调用带超时参数的 Thread.join(long millis) 方法；
4. 调用带超时参数的 LockSupport.parkNanos(Object blocker, long deadline) 方法；
5. 调用带超时参数的 LockSupport.parkUntil(long deadline) 方法

RUNNABLE 到 TERMINATED 状态

• 调用线程stop方法，stop方法会直接杀死线程，如果线程持有synchronized锁，那么锁不会被释放，不建议使用，类似的方法还有suspend() 和 resume()方法。
• 推荐调用线程的interrupt()方法

三、线程中断

使用interrupt方法抛出异常，不使用stop方法。

• stop()方法，调用stop()方法时会抛出java.lang.ThreadDeath异常，但是通常情况下，此异常不需要显示地捕捉

  • stop()方法强制让线程停止有可能使一些清理性的工作得不到完成
  • stop()方法对锁定的对象进行了解锁，导致数据得不到同步的处理，出现数据不一致的问题

• interrupt方法，将线程中断状态标志设置为true，并不是立即中断线程 ，在抛出中断异常后会重置标志位

• this.interrupted()，测试当前线程是否已经中断，指的是调用这段代码的当前线程，一般指主线程，和前面this无关

• this.isInterrupted()，测试线程是否已经中断，由前面this指定线程

RUNNABLE状态

仅仅设置中断标志位，不会中断线程，线程应该在运行过程中合适的位置检查中断标志位。

伪代码：

	@Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            // ... 具体处理逻辑
        }
        System.out.println("done ");
    }

WAITING/TIMED_WAITING状态

在这些状态时，对线程对象调用interrupt()会使得该线程抛出InterruptedException，同时抛出异常后中断标志位会被清空。

伪代码：

 @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
        	// 必须对异常进行处理，throw / try catch
            try {
                // 模拟任务代码
                Thread.sleep(2000);
            } catch (InterruptedException e) {
               	// 终止线程抑或其它逻辑
               	return
            }
        }
    }

BLOCKED状态

线程等待获取同步锁，处于等待队列，这时iterrrupt并不会中断线程，如果线程拿不到锁会一直处于阻塞状态，不会结束。

示例代码：

public class InterruptSynchronizedDemo {
    private static Object lock = new Object();//monitor
    private static class A extends Thread {
        @Override
        public void run() {
        	//等待lock锁
            synchronized (lock) {
            		//等待标志位被置为true
                while (!Thread.currentThread().isInterrupted()) {
                }
            }
            System.out.println("exit");
        }
    }
    public static void test() throws InterruptedException {
        synchronized (lock) {//获取锁
            A a = new A();
            a.start();
            Thread.sleep(1000);
			//a在等待lock锁，interrupt 无法中断
            a.interrupt();
            //a线程加入当前线程，等待执行完毕
            a.join();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        test();
    }
}

非常简单的一段代码，主线程获取lock锁，在test方法中创建a线程，启动a线程，调用a线程中断方法，使用join方法让主线程等待a线程结束。

由于主线程持有lock锁，导致a线程拿不到锁，此时就算a线程调用interrupt方法也不能中断。

注：synchronized关键字获取锁的过程中不响应中断请求
Lock.lockInterruptibly() 可以抛出中断异常，显示响应锁中断

NEW/TERMINATE状态

这两者状态调用interrup方法没有任何意义。

四、阻塞和等待

• 阻塞：当一个线程试图获取对象锁时，发现该锁已被其它线程持有，则该线程进入阻塞状态，进入同步队列，这里的锁指的是sychronized关键字锁住的同步资源。阻塞状态不响应中断

• 等待： 当一个线程让出CPU，释放锁时，等待调度条件满足，进入等待队列，等待其它线程唤醒，等待过程中响应中断。例如：Object.wait()、Thread.join()以及等待Lock或Condition

• synchronized和JUC里的Lock都实现锁的功能，但线程进入的状态是不一样的。synchronized会让线程进入阻塞态

• JUC里的Lock是用LockSupport.park()/unpark()来实现阻塞/唤醒的，会让线程进入等待态(WAITTING )