震惊!!!原来线程的状态这么简单???

1:NEW

Thread对象已经有了,但还没调用start()方法,系统内部的线程还未创建.

public class Demo1 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {

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

2:TERMINATED

线程已经终止了,内核中的线程已经销毁了,Thread对象还在.

public class Demo2 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            System.out.println("hello");
        });
        thread.start();
        System.out.println(thread.getState());
        thread.join();//确保thread线程执行完
        System.out.println(thread.getState());
    }
}

3:RUNNABLE

就绪状态:RUNNABLE.指的是这个线程"随叫随到",有两种情况.
(1)这个线程正在CPU上执行.
(2)这个线程虽然没在CPU上执行,但可以随时调度到CPU上执行.

4:阻塞状态:

4.1:WAITING

因死等进入的阻塞状态.

public class Demo2 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            for (int i = 0; i <100 ; i++) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();

        thread.join();//确保thread线程执行完
        System.out.println(thread.getState());
    }
}

4.2:TIMED_WAITING

带有超时时间的等待.

public class Demo2 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            for (int i = 0; i <100 ; i++) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();

        thread.join(50000);//确保thread线程执行完
        System.out.println(thread.getState());
    }
}

4.3 BLOCKED

进行锁竞争的时候产生的等待.

public class Demo3 {
    public static void main(String[] args) {
        Object locker = new Object();
        Object locker2 = new Object();
        Thread t1=new Thread(()->{
            synchronized(locker){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (locker2){
                    System.out.println("锁竞争引起的等待");
                }

            }
        });
        Thread t2=new Thread(()->{
            synchronized (locker2){
                synchronized (locker){

                }
            }
        });
        t1.start();
        t2.start();

        

    }
}