Java Thread 状态 Block, Waiting

最新推荐文章于 2024-02-18 12:34:34 发布

crystalpan163

最新推荐文章于 2024-02-18 12:34:34 发布

阅读量1k

点赞数 1

分类专栏： Java 多线程文章标签： Java Thread Blocked Waiting

本文链接：https://blog.csdn.net/crystalpan163/article/details/76191678

版权

1 篇文章 0 订阅

订阅专栏

  Java JDK 中 Thread的状态共有5个，分别为： 

  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; 

}

  其中Blocked 、Waiting 两个状态理解有些费劲。写一段小的代码验证。 

  测试代码1： 

  package com.iflytek.com; 

  public class ThreadStateDemo { 

  private Object locker = new Object(); 

  public static void main(String[] args) { 

  new ThreadStateDemo().testThreadState(); 

}

  public void testThreadState(){ 

  Thread t1 = new Thread(new TestTask(),"Thread1"); 

  Thread t2 = new Thread(new TestTask(),"Thread2"); 

  t1.start(); 

  try { 

  Thread.sleep(100); 

  } catch (InterruptedException e) { 

  e.printStackTrace(); 

}

  t2.start(); 

}

  class TestTask implements Runnable{ 

  @Override 

  public void run() { 

  synchronized (locker) { 

  //do something 

  try { 

  Thread.sleep(1000 * 1100); 

  } catch (InterruptedException e) { 

  e.printStackTrace(); 

}

}

}

}

}

  测试结果： 

  Thread2， 

  Thread1 

  可以看出：Thread2 在等待Thread1 拿到锁locker，因此状态处于Blocked的状态，而Thread1 因为执行了Sleep的操作，因此状态为TIMED_WAITING. 

  测试代码2： 

  package com.iflytek.com; 

  public class ThreadStateDemo { 

  private Object locker = new Object(); 

  public static void main(String[] args) { 

  new ThreadStateDemo().testThreadState(); 

}

  public void testThreadState(){ 

  Thread t1 = new Thread(new TestTask(),"Thread1"); 

  Thread t2 = new Thread(new TestTask(),"Thread2"); 

  t1.start(); 

  try { 

  Thread.sleep(100); 

  } catch (InterruptedException e) { 

  e.printStackTrace(); 

}

  t2.start(); 

}

  class TestTask implements Runnable{ 

  @Override 

  public void run() { 

  synchronized (locker) { 

  //do something 

  try { 

  locker.wait(); 

  } catch (InterruptedException e) { 

  e.printStackTrace(); 

}

}

}

}

}

  测试结果： 

  Thread1 , 状态：Waiting 

  Thread2，状态：Waiting 

  可以看出：因为Thread1 和Thread2 因为先后获得锁后放弃，所以同时进入WAITING 状态。 

  结论： 

  在知乎上的参考写的很好，Blocked的状态等待获取锁的状态，而Waiting 的状态一般是调用了Object的wait（）方法，或者Thread.join 方法。 

  参考链接： 