java并发编程-线程状态

六种状态

在Java程序中，一个线程对象只能调用一次start()方法启动新线程，并在新线程中执行run()方法。一旦run()方法执行完毕，线程就结束了。因此，Java线程的状态有以下几种：

• New：新创建的线程，尚未执行；
• Runnable：运行中的线程，正在执行run()方法的Java代码；
• Blocked：运行中的线程，因为某些操作被阻塞而挂起；
• Waiting：运行中的线程，因为某些操作在等待中；
• Timed Waiting：运行中的线程，因为执行sleep()方法正在计时等待；
• Terminated：线程已终止，因为run()方法执行完毕。

如果想要确定线程当前的状态，可以通过 getState() 方法，并且线程在任何时刻只可能处于 1 种状态。

1.New 新创建

New 表示线程被创建但尚未启动的状态

二、Runnable：运行中

线程调用start（）后，

Java 中的 Runable 状态对应操作系统线程状态中的两种状态，分别是 Running 和 Ready

• Running：Java 中处于 Runnable 状态的线程有可能正在执行
• Ready：正在等待被分配 CPU 资源。

如果一个正在运行的线程是 Runnable 状态，当它运行到任务的一半时，执行该线程的 CPU 被调度去做其他事情，导致该线程暂时不运行，它的状态依然不变，还是 Runnable，可能随时被调度回来继续执行任务。

三、Blocked：阻塞

阻塞状态包括三种状态，分别是 Blocked(被阻塞）、Waiting(等待）、Timed Waiting(计时等待）

Runnable -> Blocked ：就是进入 synchronized 保护的代码时没有抢到 monitor 锁。
Blocked -> Runnable：线程抢到 monitor 锁。

四、Waiting：等待

线程进入 Waiting 状态

• 没有设置 Timeout 参数的 Object.wait() 方法。
• 没有设置 Timeout 参数的 Thread.join() 方法。\
• LockSupport.park() 方法

Blocked 与 Waiting 的区别：

• Blocked 在等待其他线程释放 monitor 锁
• Waiting 则是在等待某个条件，比如 join 的线程执行完毕，或 notify()/notifyAll() 。

Waiting 是不限时的，只有当执行了 LockSupport.unpark()，或者 join 的线程运行结束，或者被中断时才进入 Runnable 状态。

如果其他线程调用 notify() 或 notifyAll()来唤醒它，它会直接进入 Blocked 状态
因为唤醒 Waiting 线程的线程如果调用 notify() 或 notifyAll()，要求必须首先持有该 monitor 锁，所以处于 Waiting 状态的线程被唤醒时拿不到该锁，就会进入 Blocked 状态，直到执行了 notify()/notifyAll() 的唤醒它的线程执行完毕并释放 monitor 锁，才可能轮到它去抢夺这把锁，如果它能抢到，就会从 Blocked 状态回到 Runnable 状态。

五、Timed Waiting：计时等待

Timed Waiting 会等待超时，由系统自动唤醒，或者在超时前被唤醒信号唤醒。

线程进入 Timed Waiting 状态：

• 设置了时间参数的 Thread.sleep(long millis) 方法；
• 设置了时间参数的 Object.wait(long timeout) 方法；
• 设置了时间参数的 Thread.join(long millis) 方法；
• 设置了时间参数的 LockSupport.parkNanos(long nanos) 方法和 LockSupport.parkUntil(long deadline) 方法。

如果超时时间到了且能直接获取到锁/join的线程运行结束/被中断/调用了LockSupport.unpark()，会直接恢复到 Runnable 状态，而无需经历 Blocked 状态。

Timed Waiting 中执行 notify() 和 notifyAll() 也是一样的道理，它们会先进入 Blocked 状态，然后抢夺锁成功后，再回到 Runnable 状态。

六、Terminated：已终止

• run() 方法执行完毕，线程正常退出。
• 出现一个没有捕获的异常，终止了 run() 方法，最终导致意外终止。

代码示例

新建 -> 运行 -> 终止

public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread1当前状态" + Thread.currentThread().getState().toString());
                System.out.println("thread1执行了");
            }
        });
        System.out.println("没有调用start方法的thread1线程状态" + thread1.getState().toString());
        thread1.start();
        Thread.sleep(2000);
        System.out.println("等待2秒后线程状态" + thread1.getState().toString());
    }

执行结果

新建 -> 运行 -> 等待 -> 终止

public static void main(String[] args) throws InterruptedException {
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("thread2当前状态" + Thread.currentThread().getState().toString());
            }
        });
        System.out.println("thread2没调用start方法的线程状态" + thread2.getState().toString());
        thread2.start();
        System.out.println("thread2调用start方法后的线程状态" + thread2.getState().toString());
        Thread.sleep(200);
        System.out.println("等待200毫秒thread2的线程状态" + thread2.getState().toString());
        Thread.sleep(1500);
        System.out.println("等待1500毫秒，thread2的线程状态" + thread2.getState().toString());
    }

运行结果

新建 -> 运行 -> 阻塞 -> 运行 -> 终止

public static void main(String[] args) throws InterruptedException {
         Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (ZTMainTest.class) {
                    System.out.println("thread3当前状态" + Thread.currentThread().getState().toString());
                }
            }
        });

        synchronized (ZTMainTest.class) {
            System.out.println("thread3没调用start方法的线程状态" + thread3.getState().toString());
            thread3.start();
            System.out.println("调用start方法后，thread3的线程状态" + thread3.getState().toString());
            Thread.sleep(200);
            System.out.println("等待200毫秒，thread3线程状态" + thread3.getState().toString());
        }
        Thread.sleep(300);
        System.out.println("等待300后，线程状态" + thread3.getState().toString());
    }

运行结果