java中线程的生命周期
文章目录
- java中Thread的状态
- NEW
- Runnable
- BLOCKED
- WAITING
- TIMED_WAITING
- TERMINATED
java中线程的生命周期
线程是java中绕不过去的一个话题, 今天本文将会详细讲解java中线程的生命周期,希望可以给大家一些启发。
java中Thread的状态
java中Thread有6种状态,分别是:
- NEW - 新创建的Thread,还没有开始执行
- RUNNABLE - 可运行状态的Thread,包括准备运行和正在运行的。
- BLOCKED - 正在等待资源锁的线程
- WAITING - 正在无限期等待其他线程来执行某个特定操作
- TIMED_WAITING - 在一定的时间内等待其他线程来执行某个特定操作
- TERMINATED - 线程执行完毕
我们可以用一个图来直观的表示:
JDK代码中的定义如下:
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;}
NEW
NEW 表示线程创建了,但是还没有开始执行。我们看一个NEW的例子:
public class NewThread implements Runnable{public static void main(String[] args) {Runnable runnable = new NewThread();Thread t = new Thread(runnable);log.info(t.getState().toString());}@Overridepublic void run() {}
}
上面的代码将会输出:
NEW
Runnable
Runnable表示线程正在可执行状态。包括正在运行和准备运行两种。
为什么这两种都叫做Runnable呢?我们知道在多任务环境中,CPU的个数是有限的,所以任务都是轮循占有CPU来处理的,JVM中的线程调度器会为每个线程分配特定的执行时间,当执行时间结束后,线程调度器将会释放CPU,以供其他的Runnable线程执行。
我们看一个Runnable的例子:
public class RunnableThread implements Runnable {@Overridepublic void run() {}public static void main(String[] args) {Runnable runnable = new RunnableThread();Thread t = new Thread(runnable);t.start();log.info(t.getState().toString());}
}
上面的代码将会输出:
RUNNABLE
BLOCKED
BLOCKED表示线程正在等待资源锁,而目前该资源正在被其他线程占有。
我们举个例子:
public class BlockThread implements Runnable {@Overridepublic void run() {loopResource();}public static synchronized void loopResource() {while(true) {//无限循环}}public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(new BlockThread());Thread t2 = new Thread(new BlockThread());t1.start();t2.start();Thread.sleep(1000);log.info(t1.getState().toString());log.info(t2.getState().toString());System.exit(0);}
}
上面的例子中,由于t1是无限循环,将会一直占有资源锁,导致t2无法获取资源锁,从而位于BLOCKED状态。
我们会得到如下结果:
12:40:11.710 [main] INFO com.flydean.BlockThread - RUNNABLE
12:40:11.713 [main] INFO com.flydean.BlockThread - BLOCKED
WAITING
WAITING 状态表示线程正在等待其他的线程执行特定的操作。有三种方法可以导致线程处于WAITTING状态:
- object.wait()
- thread.join()
- LockSupport.park()
其中1,2方法不需要传入时间参数。
我们看下使用的例子:
public class WaitThread implements Runnable{public static Thread t1;@Overridepublic void run() {Thread t2 = new Thread(()->{try {Thread.sleep(10000);} catch (InterruptedException e) {Thread.currentThread().interrupt();log.error("Thread interrupted", e);}log.info("t1"+t1.getState().toString());});t2.start();try {t2.join();} catch (InterruptedException e) {Thread.currentThread().interrupt();log.error("Thread interrupted", e);}log.info("t2"+t2.getState().toString());}public static void main(String[] args) {t1 = new Thread(new WaitThread());t1.start();}
}
在这个例子中,我们调用的t2.join(),这会使调用它的t1线程处于WAITTING状态。
我们看下输出结果:
12:44:12.958 [Thread-1] INFO com.flydean.WaitThread - t1 WAITING
12:44:12.964 [Thread-0] INFO com.flydean.WaitThread - t2 TERMINATED
TIMED_WAITING
TIMED_WAITING状态表示在一个有限的时间内等待其他线程执行特定的某些操作。
java中有5中方式来达到这种状态:
- thread.sleep(long millis)
- wait(int timeout) 或者 wait(int timeout, int nanos)
- thread.join(long millis)
- LockSupport.parkNanos
- LockSupport.parkUntil
我们举个例子:
public class TimedWaitThread implements Runnable{@Overridepublic void run() {try {Thread.sleep(5000);} catch (InterruptedException e) {Thread.currentThread().interrupt();log.error("Thread interrupted", e);}}public static void main(String[] args) throws InterruptedException {TimedWaitThread obj1 = new TimedWaitThread();Thread t1 = new Thread(obj1);t1.start();// The following sleep will give enough time for ThreadScheduler// to start processing of thread t1Thread.sleep(1000);log.info(t1.getState().toString());}
}
上面的例子中我们调用了Thread.sleep(5000)来让线程处于TIMED_WAITING状态。
看下输出:
12:58:02.706 [main] INFO com.flydean.TimedWaitThread - TIMED_WAITING
那么问题来了,TIMED_WAITING和WAITTING有什么区别呢?
TIMED_WAITING如果在给定的时间内没有等到其他线程的特定操作,则会被唤醒,从而进入争夺资源锁的队列,如果能够获取到锁,则会变成Runnable状态,如果获取不到锁,则会变成BLOCKED状态。
TERMINATED
TERMINATED表示线程已经执行完毕。我们看下例子:
public class TerminatedThread implements Runnable{@Overridepublic void run() {}public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(new TerminatedThread());t1.start();// The following sleep method will give enough time for// thread t1 to completeThread.sleep(1000);log.info(t1.getState().toString());}
}
输出结果:
13:02:38.868 [main] INFO com.flydean.TerminatedThread - TERMINATED
本文的例子可以参考https://github.com/ddean2009/learn-java-concurrency/tree/master/thread-lifecycle
更多精彩内容且看:
- 区块链从入门到放弃系列教程-涵盖密码学,超级账本,以太坊,Libra,比特币等持续更新
- Spring Boot 2.X系列教程:七天从无到有掌握Spring Boot-持续更新
- Spring 5.X系列教程:满足你对Spring5的一切想象-持续更新
- java程序员从小工到专家成神之路(2020版)-持续更新中,附详细文章教程
更多教程请参考 flydean的博客
java中线程的生命周期相关推荐
- java中线程的生命周期_Java中的线程生命周期– Java中的线程状态
java中线程的生命周期 Understanding Thread Life Cycle in Java and Thread States are very important when you a ...
- Java中线程的生命周期-图解
线程的生命周期:当一个线程被创建之后,进入新建状态,JVM则给他分配内存空间,并进行初始化操作.当线程对象调用了start()方法,该线程就处于就绪状态(可执行状态),JVM会为其创建方法调用栈.和程 ...
- java for(o t :object) 获取顺序号_java中线程的生命周期
线程是java中绕不过去的一个话题, 今天本文将会详细讲解java中线程的生命周期,希望可以给大家一些启发. java中Thread的状态 java中Thread有6种状态,分别是: NEW – 新创 ...
- java中的的一些生命周期,Java中对象的生命周期
Java中对象的生命周期 (1) 对象生命周期的开始 对象生命周期开始时,需要为对象分配内存,并且初始化它的实例变量: 对象生命周期结束 Java虚拟机的垃圾回收线程回收对象的内存. (2) 创建一个 ...
- java 中 bean 的生命周期
java 中 bean 的生命周期 本篇中会对涉及到的知识点皆做出描述: 首先,我们先了解先虚拟机的类加载机制: 虚拟机把描述类的数据从Class 文件中加载到内存,并对数据进行校验.转换解析和初始化 ...
- Java并发 - 线程的生命周期
线程的生命周期 1. 补充 Java中的线程分为两类:守护线程.用户线程(默认). 它们几乎在每个方面都是相同的,唯一的区别是判断JVM何时离开.意思就是,只要当前JVM实例中尚存任何一个非守护线程没 ...
- Java 多线程— 线程的生命周期及方法
2019独角兽企业重金招聘Python工程师标准>>> 这篇博客介绍线程的生命周期. 线程是一个动态执行的过程,它也有从创建到死亡的过程. 线程的几种状态 在 Thread 类中,有 ...
- 11.3-全栈Java笔记:线程的生命周期
一个线程对象在它的生命周期内,需要经历5个状态. 新生状态(New) 用new关键字建立一个线程对象后,该线程对象就处于新生状态.处于新生状态的线程有自己的内存空间,通过调用start方法进入就绪状态 ...
- pthread_create函数阻塞了主线程_5个状态,Python 中线程的生命周期
编 程 的 朝 圣 之 路 ---------------------------------------- 当程序中包含多个线程时,CPU 不是一直被特定的线程霸占,而是轮流执行各个线程. 那么,C ...
最新文章
- 当思想与机器融合:脑机接口与人类的现在、困境与未来
- 超参数momentum与weight-decay的作用
- 【Android 内存优化】Java 引用类型 ( 强引用 | 软引用 | 弱引用 | 虚引用 )
- C++ dynamic_cast操作符
- Windows APC学习笔记(一)—— APC的本质备用APC队列
- windows 下XAMPP 使用Nginx替代apache作为服务器
- 专科 java转go 翱翔之路(一)基础语法:变量声明,匿名函数,结构体,函数,map
- 七大你可能不知道的 Chrome 使用技巧
- c语言链表贪吃蛇教程,编《贪吃蛇》最简单的算法,链表法
- 笔记4:Tensorflow2.0实现VGG13
- 好程序员大数据教学点睛:Hadoop基础篇
- java oom分析_记录一次OOM分析过程
- 阻止YouTube视频在Chrome中自动播放
- 一键快速设置图层lisp程序_CAD快速切换图层LISP代码问题
- HC-05/06蓝牙模块的原理及使用方法
- liunx 红帽6.8、 oracle11g 安装指南
- Excel根据身份证号自动识别性别
- thinkphp生成guid 唯一识别码
- 最新版网页浏览器Flash插件离线版安装程序下载
- Linux下yum安装MySQL yum安装MySQL指定版本