Java
线程最终会映射为系统内核原生线程,所以Java
线程调度最终取决于系操作系统,而目前主流的操作系统内核线程调度基本都是使用抢占式线程调度。也就是可以死记硬背一下:「Java线程是使用抢占式线程调度方式进行线程调度的」。
很多操作系统都提供线程优先级的概念,但是由于平台特性的问题,Java中的线程优先级和不同平台中系统线程优先级并不匹配,所以Java线程优先级可以仅仅理解为“「建议优先级」”,通俗来说就是java.lang.Thread#setPriority(int newPriority)
并不一定生效,「有可能Java线程的优先级会被系统自行改变」。
Java线程的状态切换
Java
线程的状态可以从java.lang.Thread
的内部枚举类java.lang.Thread$State
得知:
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}
这些状态的描述总结成图如下:
「线程状态之间关系切换」图如下:
下面通过API注释和一些简单的代码例子分析一下Java线程的状态含义和状态切换。
NEW状态
「API注释」:
/**
* Thread state for a thread which has not yet started.
*
*/
NEW,
一个刚创建而尚未启动(尚未调用Thread#start()
方法)的Java线程实例的就是处于NEW
状态。
public class ThreadState {
public static void main(String[] args) throws Exception {
Thread thread = new Thread();
System.out.println(thread.getState());
}
}
// 输出结果
NEW
RUNNABLE状态
「API注释」:
/**
* 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,
当Java线程实例调用了Thread#start()
之后,就会进入RUNNABLE
状态。RUNNABLE
状态可以认为包含两个子状态:READY
和RUNNING
。
当Java线程实例Thread#yield()
方法被调用时或者由于线程调度器的调度,线程实例的状态有可能由RUNNING
转变为READY
,但是从线程状态Thread#getState()
获取到的状态依然是RUNNABLE
。例如:
public class ThreadState1 {
public static void main(String[] args) throws Exception {
Thread thread = new Thread(()-> {
while (true){
Thread.yield();
}
});
thread.start();
Thread.sleep(2000);
System.out.println(thread.getState());
}
}
// 输出结果
RUNNABLE
WAITING状态
「API注释」:
/**
* 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 {@code Object.wait()}
* on an object is waiting for another thread to call
* {@code Object.notify()} or {@code Object.notifyAll()} on
* that object. A thread that has called {@code Thread.join()}
* is waiting for a specified thread to terminate.
*/
WAITING,
WAITING
是「无限期的等待状态」,这种状态下的线程不会被分配CPU执行时间。当一个线程执行了某些方法之后就会进入无限期等待状态,直到被显式唤醒,被唤醒后,线程状态由WAITING
更变为RUNNABLE
然后继续执行。
其中Thread#join()
方法相对比较特殊,它会阻塞线程实例直到线程实例执行完毕,可以观察它的源码如下:
public final void join() throws InterruptedException {
join(0);
}
public final synchronized void join(long millis)throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
可见Thread#join()
是在线程实例存活的时候总是调用Object#wait()
方法,也就是必须在线程执行完毕isAlive()
为false(意味着线程生命周期已经终结)的时候才会解除阻塞。
基于WAITING
状态举个例子:
public class ThreadState3 {
public static void main(String[] args) throws Exception {
Thread thread = new Thread(()-> {
LockSupport.park();
while (true){
Thread.yield();
}
});
thread.start();
Thread.sleep(50);
System.out.println(thread.getState());
LockSupport.unpark(thread);
Thread.sleep(50);
System.out.println(thread.getState());
}
}
// 输出结果
WAITING
RUNNABLE
TIMED WAITING状态
「API注释」:
/**
* 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,
TIMED WAITING
就是「有限期等待状态」,它和WAITING
有点相似,这种状态下的线程不会被分配CPU执行时间,不过这种状态下的线程不需要被显式唤醒,只需要等待超时限期到达就会被VM
唤醒,有点类似于现实生活中的闹钟。
举个例子:
public class ThreadState4 {
public static void main(String[] args) throws Exception {
Thread thread = new Thread(()-> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
//ignore
}
});
thread.start();
Thread.sleep(50);
System.out.println(thread.getState());
Thread.sleep(1000);
System.out.println(thread.getState());
}
}
// 输出结果
TIMED_WAITING
TERMINATED
BLOCKED状态
「API注释」:
/**
* 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,
BLOCKED
状态也就是阻塞状态,该状态下的线程不会被分配CPU执行时间。线程的状态为BLOCKED
的时候有两种可能的情况:
更加详细的描述可以参考笔者之前写过的一篇文章:深入理解Object提供的阻塞和唤醒API
针对上面的场景1举个简单的例子:
public class ThreadState6 {
private static final Object MONITOR = new Object();
public static void main(String[] args) throws Exception {
Thread thread1 = new Thread(()-> {
synchronized (MONITOR){
try {
Thread.sleep(Integer.MAX_VALUE);
} catch (InterruptedException e) {
//ignore
}
}
});
Thread thread2 = new Thread(()-> {
synchronized (MONITOR){
System.out.println("thread2 got monitor lock...");
}
});
thread1.start();
Thread.sleep(50);
thread2.start();
Thread.sleep(50);
System.out.println(thread2.getState());
}
}
// 输出结果
BLOCKED
针对上面的场景2举个简单的例子:
public class ThreadState7 {
private static final Object MONITOR = new Object();
private static final DateTimeFormatter F = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
public static void main(String[] args) throws Exception {
System.out.println(String.format("[%s]-begin...", F.format(LocalDateTime.now())));
Thread thread1 = new Thread(() -> {
synchronized (MONITOR) {
System.out.println(String.format("[%s]-thread1 got monitor lock...", F.format(LocalDateTime.now())));
try {
Thread.sleep(1000);
MONITOR.wait();
} catch (InterruptedException e) {
//ignore
}
System.out.println(String.format("[%s]-thread1 exit waiting...", F.format(LocalDateTime.now())));
}
});
Thread thread2 = new Thread(() -> {
synchronized (MONITOR) {
System.out.println(String.format("[%s]-thread2 got monitor lock...", F.format(LocalDateTime.now())));
try {
MONITOR.notify();
Thread.sleep(2000);
} catch (InterruptedException e) {
//ignore
}
System.out.println(String.format("[%s]-thread2 releases monitor lock...", F.format(LocalDateTime.now())));
}
});
thread1.start();
thread2.start();
// 这里故意让主线程sleep 1500毫秒从而让thread2调用了Object#notify()并且尚未退出同步代码块,确保thread1调用了Object#wait()
Thread.sleep(1500);
System.out.println(thread1.getState());
System.out.println(String.format("[%s]-end...", F.format(LocalDateTime.now())));
}
}
// 某个时刻的输出如下:
[2019-06-20 00:30:22]-begin...
[2019-06-20 00:30:22]-thread1 got monitor lock...
[2019-06-20 00:30:23]-thread2 got monitor lock...
BLOCKED
[2019-06-20 00:30:23]-end...
[2019-06-20 00:30:25]-thread2 releases monitor lock...
[2019-06-20 00:30:25]-thread1 exit waiting...
场景2中:
这三点看起来有点绕,多看几次多思考一下应该就能理解。
TERMINATED状态
「API注释」:
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;
TERMINATED
状态表示线程已经终结。一个线程实例只能被启动一次,准确来说,只会调用一次Thread#run()
方法,Thread#run()
方法执行结束之后,线程状态就会更变为TERMINATED
,意味着线程的生命周期已经结束。
举个简单的例子:
public class ThreadState8 {
public static void main(String[] args) throws Exception {
Thread thread = new Thread(() -> {
});
thread.start();
Thread.sleep(50);
System.out.println(thread.getState());
}
}
// 输出结果
TERMINATED
上下文切换
多线程环境中,当一个线程的状态由RUNNABLE
转换为非RUNNABLE
(BLOCKED
、WAITING
或者TIMED_WAITING
)时,相应线程的上下文信息(也就是常说的Context
,包括CPU
的寄存器和程序计数器在某一时间点的内容等等)需要被保存,以便线程稍后恢复为RUNNABLE
状态时能够在之前的执行进度的基础上继续执行。而一个线程的状态由非RUNNABLE
状态进入RUNNABLE
状态时可能涉及恢复之前保存的线程上下文信息并且在此基础上继续执行。这里的对「线程的上下文信息进行保存和恢复的过程」就称为上下文切换(Context Switch
)。
线程的上下文切换会带来额外的性能开销,这包括保存和恢复线程上下文信息的开销、对线程进行调度的CPU
时间开销以及CPU
缓存内容失效的开销(线程所执行的代码从CPU
缓存中访问其所需要的变量值要比从主内存(RAM
)中访问响应的变量值要快得多,但是「线程上下文切换会导致相关线程所访问的CPU缓存内容失效,一般是CPU的L1 Cache
和L2 Cache
」,使得相关线程稍后被重新调度到运行时其不得不再次访问主内存中的变量以重新创建CPU
缓存内容)。
在Linux
系统中,可以通过vmstat
命令来查看全局的上下文切换的次数,例如:
$ vmstat 1
对于Java
程序的运行,在Linux
系统中也可以通过perf
命令进行监视,例如:
$ perf stat -e cpu-clock,task-clock,cs,cache-reference,cache-misses java YourJavaClass
参考资料中提到Windows
系统下可以通过自带的工具perfmon
(其实也就是任务管理器)来监视线程的上下文切换,实际上笔者并没有从任务管理器发现有任何办法查看上下文切换,通过搜索之后发现了一个工具:Process Explorer。运行Process Explorer
同时运行一个Java
程序并且查看其状态:
因为打了断点,可以看到运行中的程序的上下文切换一共7000多次,当前一秒的上下文切换增量为26(因为笔者设置了Process Explorer
每秒刷新一次数据)。
监控线程状态
如果项目在生产环境中运行,不可能频繁调用Thread#getState()
方法去监测线程的状态变化。JDK本身提供了一些监控线程状态的工具,还有一些开源的轻量级工具如阿里的Arthas,这里简单介绍一下。
使用jvisualvm
jvisualvm
是JDK自带的堆、线程等待JVM指标监控工具,适合使用于开发和测试环境。它位于JAVA_HOME/bin
目录之下。
其中线程Dump
的按钮类似于下面要提到的jstack
命令,用于导出所有线程的栈信息。
使用jstack
jstack
是JDK自带的命令行工具,功能是用于获取指定PID的Java进程的线程栈信息。例如本地运行的一个IDEA
实例的PID
是11376,那么只需要输入:
jstack 11376
然后控制台输出如下:
另外,如果想要定位具体Java进程的PID
,可以使用jps
命令。
使用JMC
JMC
也就是Java Mission Control
,它也是JDK自带的工具,提供的功能要比jvisualvm
强大,包括MBean的处理、线程栈已经状态查看、飞行记录器等等。
小结
理解Java线程状态的切换和一些监控手段,更有利于日常开发多线程程序,对于生产环境出现问题,通过监控线程的栈信息能够快速定位到问题的根本原因(通常来说,目前比较主流的MVC
应用(准确来说应该是Servlet
容器如Tomcat
)都是通过一个线程处理一个单独的请求,当请求出现阻塞的时候,导出对应处理请求的线程基本可以定位到阻塞的精准位置,如果使用消息队列例如RabbitMQ
,消费者线程出现阻塞也可以利用相似的思路解决)。
(本文完 e-a-20200804 c-3-d)
本文分享自微信公众号 - Throwable文摘(throwable-doge)。
如有侵权,请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”,欢迎正在阅读的你也加入,一起分享。