java线程状态详解

最新推荐文章于 2023-07-05 13:59:32 发布

fzczjlsdx

最新推荐文章于 2023-07-05 13:59:32 发布

阅读量1.1k

点赞数

分类专栏： java基础 java线程文章标签： java java线程

本文链接：https://blog.csdn.net/fzczjlsdx/article/details/81230761

版权

java基础同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

java线程

1 篇文章 0 订阅

订阅专栏

线程状态

状态值

NEW ：未启动的。不会出现在Dump中。
RUNNABLE：在虚拟机内执行的。
BLOCKED：受阻塞并等待监视器锁。
WATING：无限期等待另一个线程执行特定操作。
TIMED_WATING：有时限的等待另一个线程的特定操作。
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

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
java线程状态详解

线程状态状态值状态转换图状态详解NEWRUNNABLEBLOCKED线程状态状态值NEW ：未启动的。不会出现在Dump中。RUNNABLE：在虚拟机内执行的。BLOCKED：受阻塞并等待监视器锁。WATING：无限期等待另一个线程执行特定操作。TIMED_WATING：有时限的等待另一个线程的特定操作。TERMINATED：已退出的。...
复制链接

扫一扫

专栏目录