高性能编程-1.1.2线程状态

6个状态定义：java.lang.Thread.State 1.New:尚未启动的线程的线程状态 2.Runnable：可运行线程的线程状态，等待CPU调度。 3.Blocked:线程阻塞等待监视器锁定的线程状态。处于synchronized同步代码块或者方法中被阻塞。 4.Waiting：等待线程的线程状态。下列不带超时的方式：Object.wait、Thread.join、LockSupport.park 5.Timed Waiting:具有指定等待时间的等待线程的线程状态。下列带超时的方式：Thread.sleep、Object.wait、Thread.join、LockSupport.parkNanos、LockSupport.parkUtil 6.Terminated:终止线程的线程状态，线程正常完成执行或者出现异常。

public class Demo2 {
    public static Thread thread1;
    public static Demo2 obj;

    public static void main(String[] args) throws InterruptedException {
//        第一种状态切换 - 新建->运行->终止
        System.out.println("##########第一种状态切换  - 新建 -> 运行 -> 终止#############");
        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(2000L);  //等待线程1执行结束再看看状态
        System.out.println("等待2秒，thread1当前状态：" + thread1.getState().toString());

//        thread1.start();//线程终止之后，再进行调用，会抛出IllegalThreadStateException
        System.out.println();

        System.out.println("##########第二种状态切换  - 新建 -> 运行 -> 等待 ->  运行 -> 终止(sleep方式)#############");

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try { //将线程2移动到等待状态，1500后自动唤醒
                    Thread.sleep(1500);
                } catch (Exception 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(new Runnable() {
            @Override
            public void run() {
                synchronized (Demo2.class) {
                    System.out.println("thread3当前状态：" + Thread.currentThread().getState().toString());
                    System.out.println("thread3执行了");
                }
            }
        });

        synchronized (Demo2.class) {
            System.out.println("没调用start方法，thread3当前状态："+thread3.getState().toString());

            thread3.start();
            System.out.println("调用start方法，thread3当前状态"+thread3.getState().toString());
            Thread.sleep(200L);
            System.out.println("等待200毫秒，在看thread3当前装填"+thread3.getState().toString());
        }
        Thread.sleep(3000L);
        System.out.println("等待3秒，让thread3抢到锁，在看thread3当前状态："+thread3.getState().toString());
    }
}

执行结果：

##########第一种状态切换  - 新建 -> 运行 -> 终止#############
没调用start方法，thread1当前状态：NEW
thread1 挡墙状态RUNNABLE
thread1 执行了
等待2秒，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
Disconnected from the target VM, address: '127.0.0.1:50045', transport: 'socket'

Process finished with exit code 0

结语：

本文主要是通过api的方式控制各个线程状态的切换。根据上图状态图，可知。线程之间存在可控。