这么理解线程生命周期,是不是很简单?

| 好看请赞,养成习惯

  • 你有一个思想,我有一个思想,我们交换后,一个人就有两个思想
  • If you can NOT explain it simply, you do NOT understand it well enough

现陆续将Demo代码和技术文章整理在一起 Github实践精选 ,方便大家阅读查看,本文同样收录在此,觉得不错,还请Star??

为什么要了解线程的生命周期?

之前写过 Spring Bean 生命周期三部曲:

  1. Spring Bean生命周期之缘起
  2. Spring Bean生命周期之缘尽
  3. Spring Aware 到底是什么?

有朋友留言说:“了解了它们的生命周期后,使用 Spring Bean 好比看到它们的行动轨迹,现在使用就一点都不慌了”。我和他一样,了解事物的生命周期目的很简单,唯【不慌】也

Java 并发系列 已经写了很多,从来还没提起过那个它【Java线程生命周期】。有了前序理论图文的铺垫,在走进源码世界之前,谈论它的时机恰好到了。因为,编写并发程序的核心之一就是正确的摆弄线程状态

线程生命周期的几种状态

刚接触线程生命周期时,我总是记不住,也理解不了他们的状态,可以说是比较混乱,更别说它们之间是如何进行状态转换的了。原因是我把操作系统通用线程状态编程语言封装后的线程状态 概念混淆在一起了

操作系统通用线程状态

个人觉得通用线程状态更符合我们的思考习惯。其状态总共有 5 种 (如下图)。对于经常写并发程序的同学来说,其嘴里经常念的都是操作系统中的这些通用线程状态,且看

除去生【初始状态】死【终止状态】,其实只是三种状态的各种转换,听到这句话是不是心情放松了很多呢?

为了更好的说明通用线程状态Java 语言中的线程状态,这里还是先对前者进行简短的说明

初始状态

线程已被创建,但是还不被允许分配CPU执行。注意,这个被创建其实是属于编程语言层面的,实际在操作系统里,真正的线程还没被创建, 比如 Java 语言中的 new Thread()。

可运行状态

线程可以分配CPU执行,这时,操作系统中线程已经被创建成功了

运行状态

操作系统会为处在可运行状态的线程分配CPU时间片,被 CPU 临幸后,处在可运行状态的线程就会变为运行状态

休眠状态

如果处在运行状态的线程调用某个阻塞的API等待某个事件条件可用,那么线程就会转换到休眠状态,注意:此时线程会释放CPU使用权,休眠的线程永远没有机会获得CPU使用权,只有当等待事件出现后,线程会从休眠状态转换到可运行状态

终止状态

线程执行完或者出现异常 (被interrupt那种不算的哈,后续会说)就会进入终止状态,正式走到生命的尽头,没有起死回生的机会

接下来就来看看你熟悉又陌生,面试又经常被问到的Java 线程生命周期吧

Java语言线程状态

在 Thread 的源码中,定义了一个枚举类 State,里面清晰明了的写了Java语言中线程的6种状态:

  1. NEW
  2. RUNNABLE
  3. BLOCKED
  4. WAITING
  5. TIMED_WAITING
  6. TERMINATED

这里要做一个小调查了,你有查看过这个类和读过其注释说明吗?(欢迎留言脚印哦)

耳边响起五环之歌,Java中线程状态竟然比通用线程状态的 5 种多1种,变成了 6 种。这个看似复杂,其实并不是你想的那样,Java在通用线程状态的基础上,有裁剪,也有丰富,整体来说是少一种。再来看个图,注意颜色区分哦

Java 语言中

  • 将通用线程状态的可运行状态运行状态合并为 Runnable
  • 休眠状态细分为三种 (BLOCKED/WAITING/TIMED_WAITING); 反过来理解这句话,就是这三种状态在操作系统的眼中都是休眠状态,同样不会获得CPU使用权

看上图右侧【Java语言中的线程状态】,进一步简洁的说,除去线程生死,我们只要玩转 RUNNABLE休眠状态的转换就可以了,编写并发程序也多数是这两种状态的转换。所以我们需要了解,有哪些时机,会触发这些状态转换

远看看轮廓, 近看看细节。我们将上面Java语言中的图进行细化,将触发的节点放到图中 (这看似复杂的图,其实三句话就能分解的,所以别慌),且看:

RUNNABLE与BLOCKED状态转换

当且仅有(just only)一种情况会从 RUNNABLE 状态进入到 BLOCKED 状态,就是线程在等待 synchronized 内置隐式锁;如果等待的线程获取到了 synchronized 内置隐式锁,也就会从 BLOCKED 状态变为 RUNNABLE 状态了

注意:

上面提到,以操作系统通用状态来看,线程调用阻塞式 API,会变为休眠状态(释放CPU使用权),但在JVM层面,Java线程状态不会发生变化,也就是说Java线程的状态依旧会保持在 RUNNABLE 状态。JVM并不关心操作系统调度的状态。在JVM看来,等待CPU使用权(操作系统里是处在可执行状态)与等待I/O(操作系统是处在休眠状态),都是等待某个资源,所以都归入了RUNNABLE 状态

? —— 摘自《Java并发编程实战》

RUNNABLE与WAITING状态转换

调用不带时间参数的等待API,就会从RUNNABLE状态进入到WAITING状态;当被唤醒就会从WAITING进入RUNNABLE状态

RUNNABLE与 TIMED-WAITING 状态转换

调用带时间参数的等待API,自然就从 RUNNABLE 状态进入 TIMED-WAITING 状态;当被唤醒或超时时间到就会从TIMED_WAITING进入RUNNABLE状态

看图中的转换 API 挺多的,其实不用担心,后续分析源码章节,自然就会记住的,现在有个印象以及知道状态转换的节点就好了



相信到这里,你看Java线程生命周期的眼神就没那么迷惑了,重点就是RUNNABLE与休眠状态的切换,接下来我们看一看,如何查看线程中的状态,以及具体的代码触发点

如何查看线程处在什么状态

程序中调用 getState() 方法

Thread 类中同样存在 getState() 方法用于查看当前线程状态,该方法就是返回上面提到的枚举类 State

NEW

就是上面提到, 编程语言中特有的,通过继承 Thread 或实现 Runnable 接口定义线程后,这时的状态都是 NEW

Thread thread = new Thread(() -> {});
System.out.println(thread.getState());

RUNNABLE

调用了 start() 方法之后,线程就处在 RUNNABLE 状态了

Thread thread = new Thread(() -> {});
thread.start();
//Thread.sleep(1000);
System.out.println(thread.getState());

BLOCKED

等待 synchronized 内置锁,就会处在 BLOCKED 状态

public class ThreadStateTest {

	public static void main(String[] args) throws InterruptedException {
		Thread t1 = new Thread(new DemoThreadB());
		Thread t2 = new Thread(new DemoThreadB());

		t1.start();
		t2.start();

		Thread.sleep(1000);

		System.out.println((t2.getState()));
		System.exit(0);
	}
}

class DemoThreadB implements Runnable {
	@Override
	public void run() {
		commonResource();
	}

	public static synchronized void commonResource() {
		while(true) {

		}
	}
}

WAITING

调用线程的 join() 等方法,从 RUNNABLE 变为 WAITING 状态

public static void main(String[] args) throws InterruptedException {
		Thread main = Thread.currentThread();

		Thread thread2 = new Thread(() -> {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
        Thread.currentThread().interrupt();
				e.printStackTrace();
			}
			System.out.println(main.getState());
		});
		thread2.start();
		thread2.join();
	}

TIMED-WAITING

调用了 sleep(long) 等方法,线程从 RUNNABLE 变为 TIMED-WAITING 状态

public static void main(String[] args) throws InterruptedException {
		Thread thread3 = new Thread(() -> {
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
        // 为什么要调用interrupt方法?
				Thread.currentThread().interrupt();
				e.printStackTrace();
			}
		});
		thread3.start();

		Thread.sleep(1000);
		System.out.println(thread3.getState());
	}

TERMINATED

线程执行完自然就到了 TERMINATED 状态了

Thread thread = new Thread(() -> {});
thread.start();
Thread.sleep(1000);
System.out.println(thread.getState());

以上是程序中查看线程,自己写写测试看看状态还好,现实中的程序怎么可能允许你加这么多无用代码,所以,翠花,上酸菜(jstack

jstack 命令查看

相信你听说过这玩意,jstack 命令就比较强大了,不仅能查看线程当前状态,还能看调用栈,锁等线程栈信息

大家可以随意写一些程序,这里我用了上面 WAITING 状态的代码, 修改睡眠时间 Thread.sleep(100000),然后在终端按照下图标示依次执行下图命令

更多功能还请大家自行查看,后续会单独写文章来教大家如何使用jstack查看线程栈信息

Arthas

这个利器,无须多言吧,线上找茬监控没毛病,希望你可以灵活使用这个工具,攻克疑难杂症

查看线程栈详细信息,非常方便:https://alibaba.github.io/arthas/thread.html

相信你已经和Arthas确认了眼神

关于线程生命周期状态整体就算说完了,编写并发程序时多问一问自己:

调用某个API会将你的线程置为甚么状态?

多问自己几次,自然就记住上面的图了

灵魂追问

  1. 为什么调用 Thread.sleep, catch异常后,调用了Thread.currentThread().interrupt();
  2. 进入 BLOCKED只有一种情况,就是等待 synchronized 监视器锁,那调用 JUC 中的 Lock.lock() 方法,如果某个线程等待这个锁,这个线程状态是什么呢?为什么?
    public class ThreadStateTest {
    
    	public static void main(String[] args) throws InterruptedException {
    		TestLock testLock = new TestLock();
    
    		Thread thread2 = new Thread(() -> {
    			testLock.myTestLock();
    		}, "thread2");
    
    		Thread thread1 = new Thread(() -> {
    				testLock.myTestLock();
    			}, "thread1");
    
    		thread1.start();
    		Thread.sleep(1000);
    
    		thread2.start();
    		Thread.sleep(1000);
    
    		System.out.println("****" + (thread2.getState()));
    
    		Thread.sleep(20000);
    	}
    }
    
    @Slf4j
    class TestLock{
    	private final Lock lock = new ReentrantLock();
    
    	public void myTestLock(){
    		lock.lock();
    		try{
    			Thread.sleep(10000);
    			log.info("testLock status");
    		} catch (InterruptedException e) {
    			log.error(e.getMessage());
    		} finally {
    			lock.unlock();
    		}
    	}
    }
    
  3. synchronized 和 Lock 有什么区别?

参考

感谢前辈们总结的精华,自己所写的并发系列好多都参考了以下资料

  • Java 并发编程实战
  • Java 并发编程之美
  • 码出高效
  • Java 并发编程的艺术
  • ......


我这面也在逐步总结常见的并发面试问题(总结ing......)答案整理好后会通知大家,请持续关注

原文地址:https://www.cnblogs.com/FraserYu/p/12571057.html

时间: 2024-08-13 13:24:29

这么理解线程生命周期,是不是很简单?的相关文章

iOS多线程全套:线程生命周期,多线程的四种解决方案,线程安全问题,GCD的使用,NSOperation的使用

目的 本文主要是分享iOS多线程的相关内容,为了更系统的讲解,将分为以下7个方面来展开描述. 多线程的基本概念 线程的状态与生命周期 多线程的四种解决方案:pthread,NSThread,GCD,NSOperation 线程安全问题 NSThread的使用 GCD的理解与使用 NSOperation的理解与使用 Demo在这里:WHMultiThreadDemo Demo的运行gif图如下: 一.多线程的基本概念 进程:可以理解成一个运行中的应用程序,是系统进行资源分配和调度的基本单位,是操作

Java多线程与并发——线程生命周期和线程池

线程生命周期:  线程池:是预先创建线程的一种技术.线程池在还没有任务到来之前,创建一定数量的线程,放入空闲队列中,然后对这些资源进行复用.减少频繁的创建和销毁对象. java里面线程池的顶级接口是Executor,是一个执行线程的工具. 线程池接口是ExecutorService. java.util.concurrent包:并发编程中很常用的实用工具类 Executor接口:执行已提交的Runnable任务的对象. ExecutorService接口:Executor提供了管理终止的方法,以

多线程(四)线程生命周期和线程池

一.线程生命周期 线程的5种状态: 新建(New) ,就绪(Runnable),运行(Running),阻塞(Blocked),死亡(Dead)     线程生命周期图: 二.线程池 1.为什么要使用线程池: (1).提高性能 系统启动一个新线程的成本是比较高的,而使用线程池避免了频繁的创建和销毁线程,可以很好地提高性能. 线程池在系统启动时即创建大量空闲的线程,程序将一个Runnable对象或Callable对象传给线程池,线程池就会自动 启动一个线程来执行它们的run()或call()方法,

Java学习之==>Java线程生命周期与状态切换

一.Java线程生命周期与状态切换 这些状态的描述可以总结成下图: NEW 一个刚创建但尚未启动的Java线程实例就是处于 NEW 状态 public class App { public static void main(String[] args) { Thread thread = new Thread(); Thread.State state = thread.getState(); System.out.println(state); } } // 输出结果 NEW RUNNABLE

线程生命周期

线程的生命周期:一个线程从创建到消亡的过程 如下图,表示线程生命周期中的各个状态: 线程的生命周期可以分为五个状态: 1.创建状态: 当用new操作符创建一个新的线程对象时,该线程处于创建状态. 处于创建状态的线程只是一个空的线程对象,系统不为它分配资源. 2.可运行状态[runnable]: 执行线程的start()方法将为线程分配必须的系统资源,安排其运行,并调用线程体——run()方法, 这样就使得该线程处于可运行状态(Runnable). 这一状态并不是运行中状态(Running),因为

java基础——线程的常用方法和线程生命周期

线程的常用方法 package thread; /* 测试Thread类中的常用方法: 1.start() 2.run():重写Thread方法,将线程要执行的操作声明在方法中 3.Thread.currentThread():静态方法,返回执行当前代码的线程 4.getName():获取当前线程的名字 5.setName():设置当前线程的名字 6.yield():当前线程交出cpu执行权 7.join():在线程a中调用线程b的join方法,此时线程a进入阻塞态,直到线程b完全执行完后,a才

线程八大基础核心四(线程生命周期)

1.引子 在java多线程并发编程中,有八大基础核心.考考你:看看都有哪八大基础核心呢?它们分别是: 1.创建线程的方式 2.线程启动 3.线程停止 4.线程生命周期 5.线程相关的方法 6.线程相关的属性 7.线程异常处理 8.线程安全 今天我们从第四个基础核心开始:线程生命周期 2.考考你 #前情回顾: 在java编程语言中,从线程创建,到线程执行结束,会经过一系列状态的转化,称为线程的生命周期 #考考你: 1.你知道线程生命周期中有哪些状态吗? 2.你知道各种状态对应的含义吗? 3.一图胜

深刻的理解Fragment生命周期 都在做什么

Fragment用了很久了,接下来讲一下我自己对fragment的理解.部分图片内容参考官方文档. 请各种参考这篇文章:http://blog.csdn.net/wanghao200906/article/details/45561385 先上一个生命周期的图片吧 下面挨个的说一下我平时 都怎么使用 这些 回调函数的 流程: onAttach() 作用:fragment已经关联到activity, 这个是 回调函数 @Override public void onAttach(Activity

10秒钟理解react生命周期

慎点!这是一篇很水很水的文章, 抄自react中文文档, 本文详细介绍了react生命周期函数执行顺序, 以及各生命周期函数的含义和具体作用. 不同阶段生命周期函数执行顺序 挂载(Mounting) 挂载指的是组件被实例化并插入到dom中 顺序如下: constructor -> getDerivedStateFromProps -> render -> componentDidMount 更新(Updating) 当state变化或者props变化会引起更新 顺序如下: getDeri