Java多线程状态切换

原创转载请注明出处：https://www.cnblogs.com/agilestyle/p/11426573.html

 

线程状态

  • NEW
  • RUNNABLE
  • BLOCKED
  • WAITING
  • TIMED_WAITING
  • TERMINATED

参考JDK源码Thread.java中的State枚举类

 1 /** 
 2  * A thread state.  A thread can be in one of the following states: 
 3  * <ul> 
 4  * <li>{@link #NEW}<br> 
 5  *     A thread that has not yet started is in this state. 
 6  *     </li> 
 7  * <li>{@link #RUNNABLE}<br> 
 8  *     A thread executing in the Java virtual machine is in this state. 
 9  *     </li> 
10  * <li>{@link #BLOCKED}<br> 
11  *     A thread that is blocked waiting for a monitor lock 
12  *     is in this state. 
13  *     </li> 
14  * <li>{@link #WAITING}<br> 
15  *     A thread that is waiting indefinitely for another thread to 
16  *     perform a particular action is in this state. 
17  *     </li> 
18  * <li>{@link #TIMED_WAITING}<br> 
19  *     A thread that is waiting for another thread to perform an action 
20  *     for up to a specified waiting time is in this state. 
21  *     </li> 
22  * <li>{@link #TERMINATED}<br> 
23  *     A thread that has exited is in this state. 
24  *     </li> 
25  * </ul> 
26  * 
27  * <p> 
28  * A thread can be in only one state at a given point in time. 
29  * These states are virtual machine states which do not reflect 
30  * any operating system thread states. 
31  * 
32  * @since   1.5 
33  * @see #getState 
34  */  
35 public enum State {  
36     /** 
37      * Thread state for a thread which has not yet started. 
38      */  
39     NEW,  
40   
41     /** 
42      * Thread state for a runnable thread.  A thread in the runnable 
43      * state is executing in the Java virtual machine but it may 
44      * be waiting for other resources from the operating system 
45      * such as processor. 
46      */  
47     RUNNABLE,  
48   
49     /** 
50      * Thread state for a thread blocked waiting for a monitor lock. 
51      * A thread in the blocked state is waiting for a monitor lock 
52      * to enter a synchronized block/method or 
53      * reenter a synchronized block/method after calling 
54      * {@link Object#wait() Object.wait}. 
55      */  
56     BLOCKED,  
57   
58     /** 
59      * Thread state for a waiting thread. 
60      * A thread is in the waiting state due to calling one of the 
61      * following methods: 
62      * <ul> 
63      *   <li>{@link Object#wait() Object.wait} with no timeout</li> 
64      *   <li>{@link #join() Thread.join} with no timeout</li> 
65      *   <li>{@link LockSupport#park() LockSupport.park}</li> 
66      * </ul> 
67      * 
68      * <p>A thread in the waiting state is waiting for another thread to 
69      * perform a particular action. 
70      * 
71      * For example, a thread that has called <tt>Object.wait()</tt> 
72      * on an object is waiting for another thread to call 
73      * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on 
74      * that object. A thread that has called <tt>Thread.join()</tt> 
75      * is waiting for a specified thread to terminate. 
76      */  
77     WAITING,  
78   
79     /** 
80      * Thread state for a waiting thread with a specified waiting time. 
81      * A thread is in the timed waiting state due to calling one of 
82      * the following methods with a specified positive waiting time: 
83      * <ul> 
84      *   <li>{@link #sleep Thread.sleep}</li> 
85      *   <li>{@link Object#wait(long) Object.wait} with timeout</li> 
86      *   <li>{@link #join(long) Thread.join} with timeout</li> 
87      *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li> 
88      *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li> 
89      * </ul> 
90      */  
91     TIMED_WAITING,  
92   
93     /** 
94      * Thread state for a terminated thread. 
95      * The thread has completed execution. 
96      */  
97     TERMINATED;  
98 }

线程状态切换图

Note：

阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

  1. 等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)
  2. 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
  3. 其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。 

 

posted @ 2019-08-28 21:17  李白与酒  阅读(240)  评论(0)  编辑  收藏  举报