Java 线程的几种状态

最新推荐文章于 2025-11-24 14:38:27 发布

原创最新推荐文章于 2025-11-24 14:38:27 发布 · 894 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

本文需要用到JDK提供的工具 jconsole.exe 通过该工具有我们可以知道线程的信息，包括不限于线程的状态，具体路径在安装的idea的路径的JDK\bin中可以找到，再不济就下载一个everything；

NEW状态
TERMINATED状态
RUNNABLE 就绪状态
阻塞（WAITING,TIMED_WAITING,BLOCKED）

1.NEW状态

Thread对象已经有了，还没有调用start，系统内部的线程还没有创建

public class demo12 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("1");
            }
        });
        System.out.println(t.getState());//获取线程的状态
        t.start();
    }
}

执行结果：

2.TERMINATED状态

表示该线程已经执行完毕，终止了，内核中的线程已经销毁了，但是Thread对象还在；

public class demo12 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("1");
            }
        });
        System.out.println(t.getState());
        t.start();
        t.join();//确保t线程执行结束
        System.out.println(t.getState());
    }
}

执行结果：

3.RUNNABLE 就绪状态

表示该线程正在cpu上执行，或者该线程没有在cpu上执行，但是随时可以调度到cpu上执行；

有的课本会分成两种状态，RUNNING表示该线程在cpu上执行，RUNNABLE表示该线程没有在cpu上执行，但是随时可以调度到cpu上执行；

但是在Java上没有必要分成两种情况，主要是分清楚了也无法改变，所以java就合并两种为一种，统称为RUNNABLE就绪状态；

4.阻塞状态

4.1 WAITING（死等，进入的阻塞），

t线程就是一直在执行，一个死循环

public class demo12 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
               while(true){
                   System.out.println(1);
               }
            }
        });
        System.out.println(t.getState());
        t.start();
        t.join();//确保t线程执行结束
    }
}

执行结果：main线程就处于一个WAITING状态

4.2 TIMED_WAITING（超时间等待，进入的阻塞）

join线程设置了等待时间，t线程就是一直在执行，一个死循环

public class demo12 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
               while(true){
                   System.out.println(1);
                   try {
                       Thread.sleep(1000);
                   } catch (InterruptedException e) {
                       throw new RuntimeException(e);
                   }
               }
            }
        });
        System.out.println(t.getState());
        t.start();
        t.join(3600*1000);//设置主线程等待t线程的时间
    }
}

执行结果：可以看到该线程正处在TIMED_WAITING

值得注意的是，不止join可以时线程处在TIMED_WAITING状态，sleep方法也可以，可以看到thread线程就因为卡在sleep而处于TIMED_WAITING状态，sleep方法也是一个效果

4.3 BLOCKED(锁竞争产生的阻塞)

在 Java 中，线程状态中的 BLOCKED 表示线程因为竞争锁而被阻塞。当一个线程在等待获取一个对象的锁时，如果该锁已经被其他线程持有，则该线程就会进入 BLOCKED 状态，直到锁被释放为止。
以下是一个示例，演示了锁竞争导致线程进入 BLOCKED 状态的情况：

public class BlockedThreadExample {
    private static Object lock = new Object();

    public static void main(String[] args) {
        Thread thread0 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println("Thread 0 acquired the lock");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println("Thread 1 acquired the lock");
                }
            }
        });

        thread0.start();
        try {
            // 等待一段时间，确保线程0先启动并获得锁
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        thread1.start();
    }
}

在这个示例中，两个线程 thread1 和 thread2 都试图获取 lock 对象的锁。由于 thread1 先启动并获取了锁，因此 thread2 在尝试获取锁时会被阻塞，并进入 BLOCKED 状态。只有当 thread1 释放了锁后，thread2 才能获取锁并继续执行。