java线程状态详解

线程状态

状态值

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:
        * 

        *   
{@link Object#wait() Object.wait} with no timeout
        *   
{@link #join() Thread.join} with no timeout
        *   
{@link LockSupport#park() LockSupport.park}
        * 
        *
        * 
A thread in the waiting state is waiting for another thread to
        * perform a particular action.
        *
        * For example, a thread that has called Object.wait()
        * on an object is waiting for another thread to call
        * Object.notify() or Object.notifyAll() on
        * that object. A thread that has called Thread.join()
        * 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:
        * 

        *   
{@link #sleep Thread.sleep}
        *   
{@link Object#wait(long) Object.wait} with timeout
        *   
{@link #join(long) Thread.join} with timeout
        *   
{@link LockSupport#parkNanos LockSupport.parkNanos}
        *   
{@link LockSupport#parkUntil LockSupport.parkUntil}
        * 
        */
       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状态。

显示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状态。

显示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打印出线程目前的状态如下：

显示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());
    }
}

结果如下：

---

但是由于线程的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

参考博客文章

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

结语

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