Java线程的六种状态及切换

1、线程状态分类

Java线程一共划分为六种状态，同一个时刻线程只能处于其中一种状态，通过线程的getState方法可以获取线程的状态。在Thread类中有一个内部枚举类public enum State，可以看到六种状态的详细介绍

状态	含义	说明
NEW	初始	线程对象已经创建，但尚未启动，既还没有调用start()方法
RUNNABLE	运行	已经调用了线程的start()方法，又分为就绪（Ready）和运行中（Running）两种状态 就绪：该线程等待获取CPU的使用权，出属于就绪状态的线程，随时可能被CPU调度执行； 运行中：获得CPU时间片后变为运行中状态（Running），线程只能从就绪状态进入到运行中状态
BLOCKED	阻塞	表示线程阻塞于锁，等待获取锁进入同步块/方法
WAITING	等待	处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。
TIMED_WAITING	超时等待	该状态不同于WAITING，它可以在达到一定时间后自动唤醒
TERMINATED	终止	表示该线程已经执行完毕，既run()方法执行结束

2、状态之间的转换状态图

3、线程状态代码示例

3.1、NEW

NEW状态只存在于线程刚创建，未调用start()方法之前

	public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(10 * 1000);//休眠10秒钟，让出CPU
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("内部做了10秒钟的事!");
            }
        });

        System.out.println(thread.getState());

    }

此时打印出来的状态就是：NEW

3.2、RUNNABLE

这个状态的线程，其正在JVM中执行，但是这个"执行"，不一定是真的在运行， 也有可能是在等待CPU资源(Ready状态）

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(10 * 1000);//休眠10秒钟，让出CPU
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("内部做了10秒钟的事!");
            }
        });
        thread.start();
        System.out.println(thread.getState());
    }

此时打印出来的状态就是：RUNNABLE

3.3、BLOCKED

当线程等待获取一个锁，来继续执行下一步的操作，在未获取之前其线程的状态就是BLOCKED状态。比较经典的就是synchronized关键字，如果线程长时间处于这种状态下，我们就得当心看是否出现死锁的问题了。

package com.demo;

public class ThreadStateTest {

    public static void main(String[] args) {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                ClassA.methodA();
                System.out.println("thread1 调用 methodA() 方法结束!");
            }
        });
        thread1.start();
        try {
            Thread.sleep(2 * 1000);//休眠2秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("thread1 State：" + thread1.getState());

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                ClassA.methodA();
                System.out.println("thread2 调用 methodA() 方法结束!");
            }
        });
        thread2.start();
        try {
            Thread.sleep(2 * 1000);//休眠2秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //打印thread2的线程状态
        System.out.println("thread2 State：" + thread2.getState());
    }

    /**
     * 内部类
     */
    static class ClassA {
        public static synchronized void methodA() {
            try {
                Thread.sleep(10 * 1000);//休眠10秒钟，让出CPU
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("内部做了10秒钟的事!");
        }
    }

}

此时打印出来的状态就是：BLOCKED

3.4、WAITING

一个线程会进入WAITING状态，一定是执行了以下代码

• Object.wait()
• Thread.join()
• LockSupport.park()

这种WAITING状态等待的时间是永久的，即必须等到某个条件符合才能继续往下走，否则线程不会被唤醒。

    public static void main(String[] args) {
        Object object = new Object();
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("开始执行线程。。。");
                System.out.println("进入等待状态。。。");
                synchronized (object) {
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("线程结束。。。");
            }
        });

        thread.start();
        System.out.println("1 thread State：" + thread.getState());

        try {
            Thread.sleep(2 * 1000);//休眠2秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("2 thread State：" + thread.getState());

        synchronized (object) {
            object.notify();//调用notify方法，唤醒线程
        }

        try {
            Thread.sleep(2 * 1000);//休眠2秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("3 thread State：" + thread.getState());
    }

此时打印出来的状态就是：WAITING

3.5、TIMED_WAITING

这个状态和WAITING状态的区别就是，这个状态的等待是有一定时效的。当执行如下代码的时候，对应的线程会进入到TIMED_WAITING状态

• Thread.sleep(long)
• Object.wait(long)
• Thread.join(long)
• LockSupport.parkNanos()
• LockSupport.parkUntil()

还是参考3.3、BLOCKED的代码示例，thread1进入methodA()方法后，其线程状态已经变为TIMED_WAITING

此时打印出来的状态就是：TIMED_WAITING

3.6、TERMINATED

TERMINATED即为线程执行结束之后的状态，也就是run方法执行结束后的一个状态

	public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(10 * 1000);//休眠10秒钟，让出CPU
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("内部做了10秒钟的事!");
            }
        });
        thread.start();
        thread.join();//等待线程运行结束
        System.out.println(thread.getState());
	}

此时打印出来的状态就是：TERMINATED