Java - 多线程的六种状态
多线程的六种状态引入
——————————————————
查看 Thread 类的相关源码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98/**
* A thread state. A thread can be in one of the following states:
*
*
{@link #NEW}
* A thread that has not yet started is in this state.
*
*
{@link #RUNNABLE}
* A thread executing in the Java virtual machine is in this state.
*
*
{@link #BLOCKED}
* A thread that is blocked waiting for a monitor lock
* is in this state.
*
*
{@link #WAITING}
* A thread that is waiting indefinitely for another thread to
* perform a particular action is in this state.
*
*
{@link #TIMED_WAITING}
* A thread that is waiting for another thread to perform an action
* for up to a specified waiting time is in this state.
*
*
{@link #TERMINATED}
* A thread that has exited is in this state.
*
*
*
*
* A thread can be in only one state at a given point in time.
* These states are virtual machine states which do not reflect
* any operating system thread states.
*
* @since 1.5
* @see #getState
*/
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;
}
由上面的相关源码可以看出,Java 的线程其实是分为六种状态的(操作系统一般分为三种),java.lang.Thread.State 枚举类中定义了六种线程的状态:NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED,可以调用线程Thread中的 getState() 方法获取当前线程的状态
线程状态详解
————————————
线程六种状态:
线程状态
解释
NEW
刚刚创建的线程,这种线程还没有开始执行
RUNNABLE
表示线程所需的一切资源都已经准备好了
BLOCKED
线程暂停执行,直到获得请求的锁
WAITING
进入一个无时间限制的等待状态
TIMED_WAITING
进入一个有时间限制的等待状态
TERMINATED
线程完成执行,结束
《Java并发编程艺术》中的线程状态图:
《实战Java高并发程序设计》线程状态示意图:
一、新建状态 (NEW)
NEW状态表示刚刚创建的线程,这种线程还没有开始执行,等到线程的 start() 方法调用时,才表示线程开始执行
二、运行状态(RUNNABLE)
表示线程所需的一切资源都已经准备好了
就绪状态:
当线程对象调用了 start () 方法之后,线程处于就绪状态,就绪意味着该线程可以执行,但具体啥时候执行将取决于 JVM 里线程调度器的调度
注意:
在 start () 方法的源码注释中,规定了对 start () 方法的使用
1It is never legal to start a thread more than once. In particular, a thread may not be restarted once it has completed execution.
不允许对一个线程多次使用start,线程执行完成之后,不能试图用start将其唤醒
其他状态 → 就绪状态
线程调用 start () ,新建状态转化为就绪状态
线程 sleep(long) 时间到,等待状态转化为就绪状态
阻塞式 IO 操作结果返回,线程变为就绪状态
其他线程调用 join() 方法,结束之后转化为就绪状态
线程对象拿到对象锁之后,也会进入就绪状态
运行状态(RUNNING):
处于就绪状态的线程获得了CPU之后,真正开始执行run()方法的线程执行体时,意味着该线程就已经处于运行状态,需要注意的是,对于单处理器,一个时刻只能有一个线程处于运行状态,对于抢占式策略的系统来说,系统会给每个线程一小段时间处理各自的任务,时间用完之后,系统负责夺回线程占用的资源,下一段时间里,系统会根据一定规则,再次进行调度
运行状态转变为就绪状态的情形:
线程失去处理器资源。多线程一般是分配时间段,而不是一直执行完成,调用yield()静态方法,暂时暂停当前线程,让系统的线程调度器重新调度一次,它自己完全有可能再次运行。
yieId () 方法的的源码注释
1A hint to the scheduler that the current thread is willing to yield its current use of a processor. The scheduler is free to ignore this hint.
提示调度程序,当前线程愿意放弃当前对处理器的使用。这时,当前线程将会被置为就绪状态,和其他线程一样等待调度,这时候根据不同优先级决定的概率,当前线程完全有可能再次抢到处理器资源。
三、阻塞状态(BLOCKED)
线程暂停运行,直到获得请求的锁
以下场景线程将会阻塞:
线程等待进入synchronized同步方法
线程等待进入synchronized同步代码块
线程取得锁,就会从阻塞状态转变为就绪状态
四、等待状态(WAITING)
进入一个无时间限制的等待状态
运行 → 等待
当前线程运行过程中,其他线程调用join()方法,当前线程将会进入等待状态
当前线程对象调用wait()方法
等待 → 就绪
等待的线程被其他线程对象唤醒,notify () 和 notifyAll ()
五、超时等待状态(TIMED_WAITING)
进入一个有时间限制的等待状态
运行 → 超时等待
调用静态方法Thread.sleep(long)
线程对象调用wait(long)方法
其他线程调用指定时间的join(long)
sleep() 和 yield() 的不同之处:
sleep(long) 方法会使线程转入超时等待状态,时间到了之后才会转入就绪状态,而yield()方法不会将线程转入等待,而是强制线程进入就绪状态
使用 sleep(long) 方法需要处理异常,而 yield() 不用
超时等待 → 就绪
同样的,等待的线程被其他线程对象唤醒,notify() 和 notifyAll()
六、消亡状态(TERMINATED)
即线程的终止,表示线程已经执行完毕
消亡的原因
run()和call()线程执行体中顺利执行完毕,线程正常终止
线程抛出一个没有捕获的Exception或Error
需要注意的是:主线成和子线程互不影响,子线程并不会因为主线程结束就结束
注意:
从NEW状态出发后,线程就不能回到NEW状态,同理,处于TERMINATED状态的线程也不能再回到RUNNABLE状态