一、（并发编程）线程的状态与线程终止

一、线程的状态

1. New :尚未启动的线程的状态
2. Runnable：可运行的线程状态、正在执行或等待CUP调度
3. Blocked 阻塞状态登台监视器锁定的线程状态，处于Synchronized同步代码块或方法中被阻塞
4. Waiting 等待的线程状态 Object.wait()、 Thread.join()、LockSupport.park()
5. Timed Waiting 等待的线程状态 带超时时间
6. Terminated 终止状态 线程正常执行完成或出现异常

示例：

/**
 * @author haopeng
 * @date 2020-07-25 19:59
 */
public class ThreadState {

    public static void main(String[] args) throws Exception {
        // 第一种状态切换 - 新建 -> 运行 -> 终止
        System.out.println("#######第一种状态切换  - 新建 -> 运行 -> 终止################################");
        Thread thread1 = new Thread(() -> {
            System.out.println("thread1当前状态：" + Thread.currentThread().getState().toString());
            System.out.println("thread1 执行了");
        });
        System.out.println("没调用start方法，thread1当前状态：" + thread1.getState().toString());
        thread1.start();
        Thread.sleep(2000L); // 等待thread1执行结束，再看状态
        System.out.println("等待两秒，再看thread1当前状态：" + thread1.getState().toString());
        // thread1.start(); TODO 注意，线程终止之后，再进行调用，会抛出IllegalThreadStateException异常

        System.out.println();
        System.out.println("############第二种：新建 -> 运行 -> 等待 -> 运行 -> 终止(sleep方式)###########################");
        Thread thread2 = new Thread(() -> {
            try {// 将线程2移动到等待状态，1500后自动唤醒
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("thread2当前状态：" + Thread.currentThread().getState().toString());
            System.out.println("thread2 执行了");
        });
        System.out.println("没调用start方法，thread2当前状态：" + thread2.getState().toString());
        thread2.start();
        System.out.println("调用start方法，thread2当前状态：" + thread2.getState().toString());
        Thread.sleep(200L); // 等待200毫秒，再看状态
        System.out.println("等待200毫秒，再看thread2当前状态：" + thread2.getState().toString());
        Thread.sleep(3000L); // 再等待3秒，让thread2执行完毕，再看状态
        System.out.println("等待3秒，再看thread2当前状态：" + thread2.getState().toString());

        System.out.println();
        System.out.println("############第三种：新建 -> 运行 -> 阻塞 -> 运行 -> 终止###########################");
        Thread thread3 = new Thread(() -> {
            synchronized (ThreadState.class) {
                System.out.println("thread3当前状态：" + Thread.currentThread().getState().toString());
                System.out.println("thread3 执行了");
            }
        });
        synchronized (ThreadState.class) {
            System.out.println("没调用start方法，thread3当前状态：" + thread3.getState().toString());
            thread3.start();
            System.out.println("调用start方法，thread3当前状态：" + thread3.getState().toString());
            Thread.sleep(200L); // 等待200毫秒，再看状态
            System.out.println("等待200毫秒，再看thread3当前状态：" + thread3.getState().toString());
        }
        Thread.sleep(3000L); // 再等待3秒，让thread3执行完毕，再看状态
        System.out.println("等待3秒，让thread3抢到锁，再看thread3当前状态：" + thread2.getState().toString());

    }
}

运行结果：

#######第一种状态切换  - 新建 -> 运行 -> 终止################################
没调用start方法，thread1当前状态：NEW
thread1当前状态：RUNNABLE
thread1 执行了
等待两秒，再看thread1当前状态：TERMINATED

############第二种：新建 -> 运行 -> 等待 -> 运行 -> 终止(sleep方式)###########################
没调用start方法，thread2当前状态：NEW
调用start方法，thread2当前状态：RUNNABLE
等待200毫秒，再看thread2当前状态：TIMED_WAITING
thread2当前状态：RUNNABLE
thread2 执行了
等待3秒，再看thread2当前状态：TERMINATED

############第三种：新建 -> 运行 -> 阻塞 -> 运行 -> 终止###########################
没调用start方法，thread3当前状态：NEW
调用start方法，thread3当前状态：RUNNABLE
等待200毫秒，再看thread3当前状态：BLOCKED
thread3当前状态：RUNNABLE
thread3 执行了
等待3秒，让thread3抢到锁，再看thread3当前状态：TERMINATED

二、程终止

• stop()由于存在线程安全问题 已经被废弃
• interrupt

示例：

/**
 * @author haopeng
 * @date 2020-07-25 20:06
 */
public class StopTest {
    private static int i = 0;
    private static int j = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread myThread = new Thread(() -> {
            synchronized (StopTest.class) {
                // 增加同步锁，确保线程安全
                ++i;
                try {
                    // 休眠10秒,模拟耗时操作
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ++j;
            }
        });

        myThread.start();

        // 休眠1秒，确保i变量自增成功
        Thread.sleep(1000);
        // 暂停线程
        myThread.stop(); // 错误的终止
        //myThread.interrupt(); // 正确终止
        while (myThread.isAlive()) {
            // 确保线程已经终止
        }
        // 输出结果
        System.out.println("i=" + i + " j=" + j);
    }
}

• 如果使用stop方法发现运行结果为: i=1 j=0
• 使用interrupt()方法 运行结果为: i=1 j=0

总结

• 正确的使用线程终止方法为interrupt()
• 如果目标线程正在调用wait()、wait(long) 、sleep() 方法时被阻塞，那么interrupt会生效，该线程的中断状态会被清除，抛出InterruptedException异常