【多线程】线程状态

线程的所有状态

• NEW：创建了Thread对象，但是还没有调用start方法，也就是操作系统内核中还没有创建对应的PCB。
• TERMINATED：表示操作系统内核中的PCB已经执行完毕了，但是Thread对象还在。
• RUNNABLE：可运行的（包含正在CPU上运行的或者在就绪队列中，随时可以去CPU上执行的。这两种统一称为可运行的，原因则是因为无法准确区分这两种状态）。
• WAITING
• TIMED_WAITING
• BLOCKED

后三个都是阻塞，即PCB正处于阻塞队列中，只不过阻塞的原因不同。

  // 线程的状态是一个枚举类型，Thread.State  
  public static void main(String[] args) {
        for (Thread.State state : Thread.State.values()) {
            System.out.println(state);
        }
    }

状态转移

线程对象刚刚创建，PCB还没有创建，也就是还没调用start方法，这时的状态为NEW状态。调用start方法之后，操作系统内核中创建该线程的PCB，并且该线程参与调用执行，此时进入RUNNABLE状态。

如果一切顺利的话，线程执行run方法，然后PCB释放，但是此时线程对象还在，此时进入TERMINATED状态。

反之，执行过程中还可能进入阻塞状态。TIMED_WAITING，表示具有指定等待时间的等待线程，例如sleep导致的阻塞。WAITING，表示线程正在等待另一个线程进行特定操作，简单来说就是线程需要等待其他人进行通知，通知之后才可以进入运行状态。BLOCKED，表示其他线程进行加锁操作，需要等到锁解除之后，才可以进入运行状态。

下图表示线程由于调用下述方法而进入WAITING状态。

下图表示线程由于调用下述方法而进入TIME_WAITING状态。

状态演示

NEW、RUNNABLE以及TERMINATED状态的演示

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for(int i = 0; i < 1000000; i++) {

            }
        });
        System.out.println(thread.getState()); // 线程对象创建但是还没有调用start方法，此时为NEW状态
        thread.start();
        System.out.println(thread.getState()); // 调用start方法之后，并且此时没有任何阻塞，因此处于RUNNABLE状态
        thread.join();
        System.out.println(thread.getState()); // 此时run方法执行完毕，进入TERMINATED状态
    }

TIMED_WAITING状态的演示 

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(100000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        thread.start();
        Thread.sleep(1000);
        System.out.println(thread.getState()); // 调用start方法之后，线程内部调用sleep方法，此时进入TIMED_WAITING
    }

WAITING状态的演示 

    public static void main(String[] args) throws InterruptedException {

        Thread a = new Thread(() -> {
            try {
                Thread.sleep(100000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        Thread b = new Thread(() -> {
            try {
                a.join();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        a.start();
        b.start();
        Thread.sleep(1000);
        System.out.println(b.getState()); // 调用start方法之后，线程内部调用join方法，此时进入WAITING方法
    }

BLOCKED状态的演示 

    public static void main(String[] args) throws InterruptedException {

        Lock lock = new Lock();

        Thread a = new Thread(() -> {
            try {
                synchronized (lock) {
                    Thread.sleep(10000);
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        Thread b = new Thread(() -> {
            synchronized (lock) {
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        a.start();
        b.start();
        Thread.sleep(1000);
        System.out.println(b.getState()); 
        // 调用start方法之后，b线程想要对lock对象进行加锁
        // 但是a对象此时已经加锁完成，因此此时b对象进入BLOCKED状态
    }