Java线程状态详解-优快云博客

总结

　　线程被阻塞可能是由于下面五方面的原因：（《Thinking in Java》）

　　1.调用sleep(毫秒数)，使线程进入睡眠状态。在规定时间内，这个线程是不会运行的。

　　2.用suspend()暂停了线程的执行。除非收到resume()消息，否则不会返回“可运行”状态。

　　3.用wait()暂停了线程的执行。除非线程收到notify()或notifyAll()消息，否则不会变成“可运行”状态。

　　4.线程正在等候一些IO操作完成。

　　5.线程试图调用另一个对象的“同步”方法，但那个对象处于锁定状态，暂时无法使用。

所以其实仍然可以使用第一张图来概括性地说明线程的生命周期及各个状态。只不过线程被阻塞的情况分为很多种，后面的图是细化说明。

　　所涉及到的两种池：

　　Wait pool 等待池

　　Lock pool 锁池

####################详细讲解线程状态####################

java thread的运行周期中, 有几种状态, 在 java.lang.Thread.State 中有详细定义和说明:

NEW 状态是指线程刚创建, 尚未启动

RUNNABLE 状态是线程正在正常运行中, 当然可能会有某种耗时计算/IO等待的操作/CPU时间片切换等, 这个状态下发生的等待一般是其他系统资源, 而不是锁, Sleep等

BLOCKED 这个状态下, 是在多个线程有同步操作的场景, 比如正在等待另一个线程的synchronized 块的执行释放, 或者可重入的 synchronized块里别人调用wait() 方法, 也就是这里是线程在等待进入临界区

WAITING 这个状态下是指线程拥有了某个锁之后, 调用了他的wait方法, 等待其他线程/锁拥有者调用 notify / notifyAll 一遍该线程可以继续下一步操作, 这里要区分 BLOCKED 和 WATING 的区别, 一个是在临界点外面等待进入, 一个是在理解点里面wait等待别人notify, 线程调用了join方法 join了另外的线程的时候, 也会进入WAITING状态, 等待被他join的线程执行结束

TIMED_WAITING 这个状态就是有限的(时间限制)的WAITING, 一般出现在调用wait(long), join(long)等情况下, 另外一个线程sleep后, 也会进入TIMED_WAITING状态

TERMINATED 这个状态下表示该线程的run方法已经执行完毕了, 基本上就等于死亡了(当时如果线程被持久持有, 可能不会被回收)

下面谈谈如何让线程进入以上几种状态:

1. NEW, 这个最简单了,

     static void NEW() {
          Thread t = new Thread ();
         System. out.println(t.getState());
    }

输出NEW

2. RUNNABLE, 也简单, 让一个thread start, 同时代码里面不要sleep或者wait等

   private static void RUNNABLE() {
         Thread t = new Thread(){
             
              public void run(){
                  for(int i=0; i<Integer.MAX_VALUE; i++){
                      System. out.println(i);
                 }
             }
             
         };
         
         t.start();
    }

3. BLOCKED, 这个就必须至少两个线程以上, 然后互相等待synchronized 块

     private static void BLOCKED() {
         
          final Object lock = new Object();
         
         Runnable run = new Runnable() {
             
              @Override
              public void run() {
                  for(int i=0; i<Integer.MAX_VALUE; i++){
                      
                       synchronized (lock) {
                          System. out.println(i);
                      }
                      
                 }
             }
         };
         
         Thread t1 = new Thread(run);
         t1.setName( “t1″);
         Thread t2 = new Thread(run);
         t2.setName( “t2″);
         
         t1.start();
         t2.start();
         
    }

这时候, 一个在RUNNABLE, 另一个就会在BLOCKED (等待另一个线程的 System.out.println.. 这是个IO操作, 属于系统资源, 不会造成WAITING等)

4. WAITING, 这个需要用到生产者消费者模型, 当生产者生产过慢的时候, 消费者就会等待生产者的下一次notify

     private static void WAITING() {
 
          final Object lock = new Object();
         Thread t1 = new Thread(){
              @Override
              public void run() {
                 
                  int i = 0;
                 
                  while(true ){
                       synchronized (lock) {
                           try {
                               lock.wait();
                          } catch (InterruptedException e) {
                          }
                          System. out.println(i++);
                      }
                 }
             }
         };
         
         Thread t2 = new Thread(){
              @Override
              public void run() {
                 
                  while(true ){
                       synchronized (lock) {
                           for(int i = 0; i< 10000000; i++){
                              System. out.println(i);
                          }
                          lock.notifyAll();
                      }
                      
                 }
             }
         };
         
         t1.setName( “^^t1^^”);
         t2.setName( “^^t2^^”);
         
         t1.start();
         t2.start();
    }

5. TIMED_WAITING, 这个仅需要在4的基础上, 在wait方法加上一个时间参数进行限制就OK了.

把4中的synchronized 块改成如下就可以了.

synchronized (lock) {
   try {
      lock.wait(60 * 1000L);
   } catch (InterruptedException e) {
   }
   System. out .println(i++);
 }

另外看stack的输出, 他叫 TIMED_WAITING(on object monitor) , 说明括号后面还有其他的情况, 比如sleep, 我们直接把t2的for循环改成sleep试试:

synchronized (lock) {
    
    try {
          sleep(30*1000L);
    } catch (InterruptedException e) {
    }
    lock.notifyAll();
}

看到了吧, t2的state是 TIMED_WAITING( sleeping), 而t1依然是on object monitor , 因为t1还是wait在等待t2 notify, 而t2是自己sleep

另外, join操作也是进入 on object monitor

6. TERMINATED, 这个状态只要线程结束了run方法, 就会进入了…

    private static void TERMINATED() {
         Thread t1 = new Thread();
         t1.start();
         System. out.println(t1.getState());
          try {
             Thread. sleep(1000L);
         } catch (InterruptedException e) {
         }
         System. out.println(t1.getState());
    }

输出:

RUNNABLE

TERMINATED

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

废话了这么多, 了解线程的状态究竟有什么用?

所以说这是个钓鱼贴么…

好吧, 一句话, 在找到系统中的潜在性能瓶颈有作用.

当java系统运行慢的时候, 我们想到的应该先找到性能的瓶颈, 而jstack等工具, 通过jvm当前的stack可以看到当前整个vm所有线程的状态, 当我们看到一个线程状态经常处于

WAITING 或者 BLOCKED的时候, 要小心了, 他可能在等待资源经常没有得到释放(当然, 线程池的调度用的也是各种队列各种锁, 要区分一下, 比如下图)