java线程状态详解

最新推荐文章于 2024-10-10 09:29:22 发布
最新推荐文章于 2024-10-10 09:29:22 发布
阅读量1.1k 收藏 4
点赞数
分类专栏： java基础 java线程 文章标签： java java线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fzczjlsdx/article/details/81230761
版权

线程状态

状态值

  1. NEW ：未启动的。不会出现在Dump中。
  2. RUNNABLE：在虚拟机内执行的。
  3. BLOCKED：受阻塞并等待监视器锁。
  4. WATING：无限期等待另一个线程执行特定操作。
  5. TIMED_WATING：有时限的等待另一个线程的特定操作。
  6. TERMINATED：已退出的。

状态转换图

线程转换图

状态详解

thread dump中会显示这些状态，java命令jstack就可以显示出前系统的java进程情况，通过对这些状态的分析，能够得出线程的运行状况，进而发现可能存在的问题。

线程的状态在Thread.State这个枚举类型中定义：

   public enum State {
       /**
        * Thread state for a thread which has not yet started.
        */
       NEW,

       /**
        * Thread state for a runnable thread.  A thread in the runnable
        * state is executing in the Java virtual machine but it may
        * be waiting for other resources from the operating system
        * such as processor.
        */
       RUNNABLE,

       /**
        * Thread state for a thread blocked waiting for a monitor lock.
        * A thread in the blocked state is waiting for a monitor lock
        * to enter a synchronized block/method or
        * reenter a synchronized block/method after calling
        * {@link Object#wait() Object.wait}.
        */
       BLOCKED,

       /**
        * Thread state for a waiting thread.
        * A thread is in the waiting state due to calling one of the
        * following methods:
        * <ul>
        *   <li>{@link Object#wait() Object.wait} with no timeout</li>
        *   <li>{@link #join() Thread.join} with no timeout</li>
        *   <li>{@link LockSupport#park() LockSupport.park}</li>
        * </ul>
        *
        * <p>A thread in the waiting state is waiting for another thread to
        * perform a particular action.
        *
        * For example, a thread that has called <tt>Object.wait()</tt>
        * on an object is waiting for another thread to call
        * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
        * that object. A thread that has called <tt>Thread.join()</tt>
        * is waiting for a specified thread to terminate.
        */
       WAITING,

       /**
        * Thread state for a waiting thread with a specified waiting time.
        * A thread is in the timed waiting state due to calling one of
        * the following methods with a specified positive waiting time:
        * <ul>
        *   <li>{@link #sleep Thread.sleep}</li>
        *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
        *   <li>{@link #join(long) Thread.join} with timeout</li>
        *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
        *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
        * </ul>
        */
       TIMED_WAITING,

       /**
        * Thread state for a terminated thread.
        * The thread has completed execution.
        */
       TERMINATED;
   }
NEW

每一个线程刚创建的时候：Thread t = new Thread()，在堆内存存在一个Thread对象。这个时候线程就处在NEW状态，在未调用start()方法之前，它其实就是堆内存中一个普通的java对象。

RUNNABLE

该状态表示线程具备所有运行条件，在运行队列中准备操作系统的调度，或者正在运行。就是线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法，等待被线程调度选中，获取CPU使用权。 这个状态的线程比较正常，但如果线程长时间停留在在这个状态就不正常了，这说明线程运行的时间很长（存在性能问题），或者是线程一直得不得执行的机会（存在线程饥饿的问题）。

BLOCKED

阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。

PS：需要注意的是，当阻塞结束时，该线程将迚入 Runnable 状态，而非直接迚入 Running 状态

阻塞的情况分两种：
1. 同步阻塞：线程正在等待获取java对象的内置锁。即运行(running)的线程进入了一个synchronized方法或者代码块，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
2. 其他阻塞：运行(running)的线程发出了I/O请求时或者执行Thread.sleep(long ms)或t.join()方法，JVM会把该线程置为阻塞状态。当I/O处理完毕时，或者sleep()转台超时、join()等待线程终止或者超时线程重新转入可运行(runnable)状态。

Dead

线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。需要注意的是，不要试图对一个已经死亡的线程调用 start()方法，线程死亡后将丌能再次作为线程执行，系统会抛出 IllegalThreadStateException 异常

以下是Thread.State内的状态，也做一下解释。PS：可以看到Dead是不在Thread.State里面的。

WAITING

等待运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。有的时候也会把这种情况当成阻塞。
处在该线程的状态，正在等待某个事件的发生，只有特定的条件满足，才能获得执行机会。而产生这个特定的事件，通常都是另一个线程。也就是说，如果不发生特定的事件，那么处在该状态的线程一直等待，不能获取执行的机会。比如说，A线程调用了obj对象的obj.wait()方法，如果没有线程调用obj.notify或obj.notifyAll，那么A线程就没有办法恢复运行；如果A线程调用了LockSupport.park()，没有别的线程调用LockSupport.unpark(A)，那么A没有办法恢复运行。

TIMED_WAITING

我们知道J.U.C中很多与线程相关类，都提供了限时版本和不限时版本的API。TIMED_WAITING意味着线程调用了限时版本的API，正在等待时间流逝；当等待时间过去后，线程一样可以恢复运行。如果线程进入了WAITING状态，一定要特定的事件发生才能恢复运行；而处在TIMED_WAITING的线程，如果特定的事件发生或者是时间流逝完毕，都会恢复运行。回到runnable状态

TERMINATED

线程执行完毕，执行完run方法正常返回，或者抛出了运行时异常而结束，线程都会停留在这个状态。这个时候线程只剩下Thread对象了，没有什么用了

状态值例子

显示NEW状态

直接就输出线程的状态NEW

    public static void main(String[] args) {     
          Thread t = new Thread ();
           System. out.println(t.getState());
    }
显示BLOCKED状态

用while循环卡在这里，让先进入synchronize同步模块的线程占用5分钟，另外一个线程处于阻塞状态。

public class BlockedState {
    public static Object object  = new Object();
    public static void main(String[] args) {
        Runnable task = new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                     long begin = System.currentTimeMillis();
                     long end = System.currentTimeMillis();
                     while((end - begin) <=5*60*1000) {
                         System.out.println("还没有过5分钟了");
                     }
                }
            }

        };
        new Thread(task,"t1").start();
        new Thread(task,"t2").start();
    }
}

用java命令jps看看进程的pid是什么，然后在用jstack打印出进程信息。可以看到t2线程处于运行状态，而t1处于Blocked状态。

BlockState

显示TIMED_WAITING状态

稍微修改一下blocked代码，加上了每10秒运行的线程等待一次。

public class TimedWaitingState {
    public static Object object  = new Object();
    public static void main(String[] args) {
        Runnable task = new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                     long begin = System.currentTimeMillis();
                     long end = System.currentTimeMillis();
                     while((end - begin) <=5*60*1000) {
                         try {
                            Thread.sleep(10*1000);
                            System.out.println("10秒动一次");
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                         System.out.println("还没有过5分钟了");
                     }
                }
            }

        };
        new Thread(task,"t1").start();
        new Thread(task,"t2").start();
    }
}

可以看到程序重新运行，PID已经发生变化，这个是因为进程运行PID是随机的，他只是暂时的一个身份标识

可以看到当程序运行到这里时Thread.sleep(10*1000);，就会进入TIMED_WAITING状态，当10秒到了，就回到runnable状态。

TIMED_WAITING

显示WAITING 状态

将blocked例子修改，改成调用wait()方法。

public class WaitingState
{
    private static Object object = new Object();
    public static void main(String[] args){
        Runnable task = new Runnable() {
            @Override
            public void run(){
                synchronized (object){
                    long begin = System.currentTimeMillis();
                    long end = System.currentTimeMillis();
                    while ((end - begin) <= 5 * 60 * 1000){
                        try{
                            // 进入等待的同时,会进入释放监视器
                            System.out.println(Thread.currentThread().getName()+"进入等待");
                            object.wait();
                            System.out.println(Thread.currentThread().getName()+"等待结束");
                        } catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }
                }
            }
        };
        new Thread(task, "t1").start();
        new Thread(task, "t2").start();
    }
}

可以看到输出的结果为如下，t1或者t2某一个抢到CPU进入运行，遇到wait()就停止等待，另外一个线程就获得CPU运行，遇到wait()也等待
输出结果
用jstack打印出线程目前的状态如下：
WAITING

显示TERMINATED状态

运行完run会打印出TERMINATED

public class TERMINATEDState {
    public static void main(String[] args){
         Thread t1 = new Thread();
         t1.start();
         System. out.println(t1.getState());
          try {
             Thread. sleep(1000L);
         } catch (InterruptedException e) {
         }
         System. out.println(t1.getState());
    }
}

结果如下：
TERMINATED

但是由于线程的start方法是异步启动的, 所以在其执行后立即获取状态有可能才刚进入RUN方法且还未执行完毕

简单修改一下代码，重写run，添加一个for循环。

public class TERMINATEDState {
    public static void main(String[] args){
         Thread t1 = new Thread() {
             public void run() {
                 for(int i = 0;i<1000;i++)
                 System.out.println(i);
             }
         };
         t1.start();
         System. out.println(t1.getState());
          try {
             Thread. sleep(1000L);
         } catch (InterruptedException e) {
         }
         System. out.println(t1.getState());
    }
}

结果如下;可以看到打印runnable在run还没运行完的时候，然后在最后，还是会打印出TERMINATED
线程start顺序

参考博客文章

学习java线程状态和看懂thread dump文件中的线程信息

结语

接下来会写一篇jstack介绍一下打印出来的除了线程状态，其他的是什么信息。

fzczjlsdx
关注
专栏目录
java线程状态图
09-30
java线程从新建到死亡所能经历的各种状态之间的流转。包括运行到阻塞、进入锁池、等待队列，全面而清晰的一张图
Java多线程:线程状态
清风小阁
03-04 4万+
一. 线程状态类型 1. 新建状态（New）：新创建了一个线程对象。 2. 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。 3. 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。 4. 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂
线程6种状态
最新发布
夕拾的博客
10-10 1108
线程的状态有哪几种？他们之间是如何转换的？
Java线程的6种状态及切换(透彻讲解)
热门推荐
潘建南的博客
12-24 26万+
Java中线程的状态分为6种。 1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。 2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。 线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状...
Java多线程
ldsfsm的博客
05-08 198
了解进程和线程: 几乎所有的操作系统都支持进程的概念，所有运行中的任务通常对应一个进程（Process）。当一个程序 进入内存运行时，即变成一个进程。进程是处于运行过程中的程序，并且具有一定的独立功能，进程是 系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。 独立性：进程是系统中独立存在的实体，它可以拥有自己独立的资源，每一个进程都拥有自己私有 的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空 间。 动态性：进程与程序的区别在于，程序只是一个静态的指
Java线程状态
枣面包的博客
05-31 502
Java的线程状态定义在Thread.State枚举里，源码如下： public enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; } 源码显示总共有六种线程状态： 状态 解释 NEW 新建状态 RUNNABLE 可运行状...
Java多线程详解及示例
07-20
Java提供了ExecutorService和ThreadPoolExecutor类来管理线程，创建线程池可以有效控制并发线程的数量，减少线程的创建和销毁开销。线程池的基本使用如下： ```java ExecutorService executor = Executors....
基于java 线程的几种状态(详解)
08-29
基于Java线程的几种状态详解 Java线程的状态是一个复杂的概念，它们之间的转换关系也非常重要。下面我们将详细解释Java线程的六种状态：New、Runnable、Blocked、Waiting、Timed waiting和Terminated。 1. 新创建...
Java多线程 线程状态原理详解
08-25
线程状态的理解对于编写高效、稳定的并发程序至关重要。在Java中，`java.lang.Thread.State`枚举类定义了线程的六种状态，分别是： 1. **NEW**：新建状态，线程被创建但尚未调用`start()`方法。 2. **RUNNABLE**：...
java 线程详解及线程与进程的区别
08-31
Java线程详解与进程的区别是理解多任务并发执行的关键。在计算机系统中，进程和线程是两种不同的执行单元。 1. **进程**：每个进程都有独立的内存空间，这意味着不同进程之间的数据不能直接共享。例如，当你打开多...
Java-并发-Java线程中断与停止线程详解
12-22
  Java 中的线程中断是一种线程间的协作模式，通过设置线程的中断标志并不能直接终止该线程的执行，而是被中断的线程根据中断状态自行处理。即“线程中断”并不是字面意思——线程真的中断了，而是设置了中断标志...
Java 线程的状态
柚咖小窝
03-24 456
线程状态   Java 中我们说的线程状态在代码中的实现其实就是一个变量的值，这个变量是 Thread 类中的变量——threadStatus。 /* Java thread status for tools, * initialized to indicate thread 'not yet started' */ private volatile int threadStatus = 0;   因为 threadStatus 是个整型数据，不形象，因此 Thread 将 threadStatus.
Java中线程的状态
m0_72466001的博客
10-08 396
Java中线程的状态
java线程状态
inspiredbh的博客
02-09 399
线程一般具有五中状态：新建，就绪，运行，阻塞，死亡 新建状态(new)： 在程序中创建了一个线程对象之后，线程便处于新建状态，已经分配了相应内存空间和其他资源，但是处于不可运行的状态 就绪状态(Runnable)： 线程对象调用了start()方法后，便启动了线程，线程启动后由创建状态转为就绪状态，j就绪状态相当于等待执行，进入线程队列排队，等待cpu执行，已经具备了执行资格 运行sta
Java线程状态（超详细）
小电玩
04-06 1015
当我们在编写多线程程序时，了解线程状态是非常重要的，因为它能够帮助我们理解线程在执行过程中的行为，从而更好地控制和管理线程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值