Java的线程状态

在我们平时写code的时候，经常会使用到多线程。其中线程所处的状态就是我们需要进程思考的问题。

1. 线程有哪些状态

NEW: 一个线程刚被创建，但是没有被使用就是处于这个状态

RUNNABLE: 一个线程正在jvm虚拟机中被执行就是处于这个状态

BLOCKED：一个线程等待一个moniter，就是处于这个状态.

WAITING：一个线程无休止的等待另一个线程就是处于这个状态

TIMED_WAITING：一个线程等待林一个线程，但是有具体的timeout，就是处理这个状态

TERMINATED：一个线程执行结束了，就是处于这个状态

public class Hello {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Object lock2 = new Object();
//      NEW
        Thread test = new Thread();
//      RUNNABLE
        Thread test1 = new Thread(() -> {
            int i = 0;
            synchronized (lock){
                while (true) {
                    i++;
                }
            }
        });
//      BLOCK
        Thread test2 = new Thread(() -> {
            int i = 0;
            synchronized (lock){
                while (true) {
                    i++;
                }
            }
        });

//      Waiting
        Thread test3 = new Thread(() -> {
            int i = 0;
            synchronized (lock2){
                try {
                    lock2.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }

        });
//      Time_waiting  -----3s-->  TERMINATED
        Thread test4 = new Thread(() -> {
            int i = 0;
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        test1.start();
        test2.start();
        test3.start();
        test4.start();
        Thread.sleep(1000);
        System.out.println(test1.getState());
        System.out.println(test2.getState());
        System.out.println(test3.getState());
        System.out.println(test4.getState());
        Thread.sleep(3000);
        System.out.println(test4.getState());
    }
}

1. 状态的转换

• BLOCKED： 进入同步块/方法，等待获取monitor。或者调用Object.wait之后被notify唤醒，但是没有获取monitor。
• Waiting:
  1. Object.wait with no timeout
  2. Thread.join with no timeout
  3. LockSupport.park
• Timed_waiting:
  1. Thread.sleep
  2. Object.wait with timeout
  3. Thread.join with timeout
  4. LockSupport.parkNanos
  5. LockSupport.parkUntil

package com.hardy.pojo;

public class Hello {

    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();

        Thread test1 = new Thread(() -> {
            synchronized (lock){
                try {
                    System.out.println("test1");
                    lock.wait();
                    Thread.sleep(10000);
                    System.out.println("test1 end");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("end");
            }
        });

        Thread test2 = new Thread(() -> {
            synchronized (lock){
                System.out.println("test2");
                try {
                    lock.wait();
                    Thread.sleep(10000);
                    System.out.println("test2 end");
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
                System.out.println("end");
            }
        });

        Thread test3 = new Thread(() -> {
            int i = 0;
            synchronized (lock){
                try {
                    System.out.println("test3");
                    lock.notifyAll(); // 这里是notifyAll会唤醒所有的wait线程。但是线程都是需要monitor的，monitor只能被一个线程持有。所以notifyAll之后，一个线程变成Runable,一个线程变成Block
                    System.out.println("test3 end");
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
                System.out.println("end");
            }
        });

        test1.start();
        test2.start();
        Thread.sleep(1000);
        test3.start();
        Thread.sleep(1000);
        System.out.println(test1.getState());
        System.out.println(test2.getState());
        System.out.println(test3.getState());

    }
}

思考：如果notifyAll变成notify，那么另外两个线程的状态如何改变？