Java多线程基础（2）线程状态

java.lang.Thread.State枚举定义了6种线程状态。

1. NEW: 尚未启动（start）的线程的线程状态
2. RUNNABLE: 运行状态，但线程可能正在JVM中执行，也可能在等待CPU调度
3. BLOCKED: 线程阻塞,等待监视器锁以进入同步代码块/方法
4. WAITING: 等待状态。使用以下不带超时的方式时会进入：Object.wait、Thread.join、LockSupport.park。等待状态的线程需要另一个线程激活。
5. TIMED_WAITING: 具有指定等待时间的等待状态，使用以下带超时的方式：Thread.sleep、Object.wait、Thread.join、LockSupport.parkNanos、LockSupport.parkUntil。
6. TERMINATED: 终止状态。线程正常执行完毕或者发生异常。

状态切换

状态	条件	状态	条件	状态
NEW	-(启动)-》	RUNNABLE	-(等待锁)-》	BLOCKED
		RUNNABLE	《-(拿到锁)-	BLOCKED
		RUNNABLE	-(等待其他线程通知)-》	WAITING
		RUNNABLE	《-(收到其他线程通知)-	WAITING
		RUNNABLE	-(有超时时间的，等待其他线程通知)-》	TIMED_WAITING
		RUNNABLE	《-(收到其他线程通知，或者等待超时)-	TIMED_WAITING
		RUNNABLE	-(执行结束)-》	TERMINATED

线程切换代码示例

/**
 * 多线程运行状态切换示例
 */
public class Demo2 {

    public static void main(String[] args) throws Exception{
        //第一种状态切换 新建->运行->终止
        System.out.println("###第一种状态切换 新建->运行->终止###");
        Thread thread1 = new Thread(()->{
            System.out.println("thread1当前状态：" + Thread.currentThread().getState());
            System.out.println("thread1执行完毕");
        });
        System.out.println("调用start之前，thread1当前状态：" + thread1.getState());
        thread1.start();
        Thread.sleep(2000L);    //等待thread1执行结束
        System.out.println("等待thread1执行结束，当前状态：" + thread1.getState());
        System.out.println();
//        thread1.start();        //此时会抛出java.lang.IllegalThreadStateException

        //第二种状态切换 新建->运行->等待->运行->终止
        System.out.println("###第二种状态切换 新建->运行->等待->运行->终止###");
        Thread thread2 = new Thread(()->{
            try {
                Thread.sleep(1500L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("thread2当前状态：" + Thread.currentThread().getState());
            System.out.println("thread2执行完毕");
        });
        System.out.println("调用start之前，thread2当前状态：" + thread2.getState());
        thread2.start();
        System.out.println("调用start之后，thread2当前状态：" + thread2.getState());
        Thread.sleep(200L);    //等待一段时间令thread2进入sleep方法
        System.out.println("调用start之后，等待200毫秒，thread2当前状态：" + thread2.getState());
        Thread.sleep(2000L);    //等待thread2执行结束
        System.out.println("等待thread2执行结束，当前状态：" + thread2.getState());
        System.out.println();

        //第三种状态切换 新建->运行->阻塞->运行->终止
        System.out.println("###第三种状态切换 新建->运行->阻塞->运行->终止###");
        Thread thread3 = new Thread(()->{
            synchronized (Demo2.class){
                System.out.println("thread3当前状态：" + Thread.currentThread().getState());
                System.out.println("thread3执行完毕");
            }
        });
        synchronized (Demo2.class){
            System.out.println("调用start之前，thread3当前状态：" + thread3.getState());
            thread3.start();
            System.out.println("调用start之后，thread3当前状态：" + thread3.getState());
            Thread.sleep(200L);
            System.out.println("等待200毫秒，thread3等待获取锁，thread3当前状态：" + thread3.getState());
        }
        Thread.sleep(1000L);        //等待thread3执行完毕
        System.out.println("等待1秒，令thread3获取锁后执行方法，thread3当前状态：" + thread3.getState());
    }
}