java线程的几种状态

一、线程的状态

Java中的线程有以下几种状态：

1. 新建状态（New）：当线程对象被创建但还没有被调用start()方法时，线程处于新建状态。

2. 运行状态（Runnable）：当线程启动后，线程处于运行状态。在运行状态下的线程，可能正在执行任务，也可能等待系统资源或其他线程的唤醒。

3. 阻塞状态（Blocked）：当线程处于阻塞状态时，它暂时停止执行。线程在等待某个条件满足（如获取锁）或者等待阻塞的IO操作完成时进入阻塞状态。

4. 等待状态（Waiting）：线程进入等待状态是因为它在等待另一个线程执行特定的操作。线程进入等待状态时可以指定一个超时时间，在超时时间到达前，线程会一直等待，直到被唤醒。

5. 计时等待状态（Timed Waiting）：线程进入计时等待状态是因为它在等待另一个线程执行特定的操作，但等待时间有限。线程进入计时等待状态时，会在指定的时间内等待，超过指定时间后会自动唤醒。

6. 终止状态（Terminated）：线程执行完任务或者发生异常导致线程终止时，线程处于终止状态。

在Java中，线程的状态会随着线程的执行和调度而转换。可以使用Thread类提供的方法来获取和管理线程的状态。

二、线程的状态和转移

使用 getState（）方法可以获取到线程的状态。

1. NEW (新建) 和 RUNNABLE (可运行) 和 TERMINATED (终止)

public class ThreadDemo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{

        });
         //线程没执行前是NEW状态。
        System.out.println(t1.getState());
        t1.start();
        //线程执行中是RUNNABLE状态。
        System.out.println(t1.getState());
        t1.join();
        //线程执行完后是TERMINATED状态。
        System.out.println(t1.getState());
    }
}

2. WAITING (等待)

public class ThreadDemo1 {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (locker){
               locker.notify();
            }
        });

        Thread t2 = new Thread(()->{
            synchronized (locker){
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
        Thread.sleep(1000);
        //线程在wait的时候是WAITING
        System.out.println(t2.getState());
        t1.join();
        t2.join();
    }
}

3. 阻塞状态（Blocked）

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Thread t1 = new Thread(()->{
            synchronized (locker1){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker2){
 
                }
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (locker2){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker1){
 
                }
            }
        });
 
        t1.start();
        Thread.sleep(100);
        t2.start();
        Thread.sleep(1500);
        //死锁的时候是BLOCKED状态
        System.out.println(t2.getState());
        t1.join();
        t2.join();
 
    }
}

4.计时等待状态（Timed Waiting）

public class demo2 {
 
    public static void main(String[] args) throws InterruptedException {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t2.start();
        Thread.sleep(100);
         //线程在sleep的时候是Timed Waiting状态。
        System.out.println(t2.getState());
    }
    }