生命周期java
❶ 【java基础】线程生命周期有哪些阶段
Java线程具有五中基本状态
新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();
就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；
运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就 绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；
阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：
1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；
3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
❷ 辅以图示简述Java线程的生命周期
//这是线程被中断，同生命周期的代码，希望帮到你啦！
class MyThread implements Runnable {
@Override
public void run() {
System.out.println("1、进入run()方法休眠");
try {
System.out.println("2、线程休眠20秒");
Thread.sleep(20000);//这里休眠20秒
System.out.println("3、线程正常休眠完毕");
} catch (InterruptedException e) {
System.out.println("4、线程发生异常休眠被中断");
return;//返回方法调用处
}
System.out.println("5、线程正常结束run()方法体");
}
}
public class InterruptDemo {
public static void main(String[] args) {
MyThread mt = new MyThread();
Thread t = new Thread(mt,"线程A");
t.start();//启动线程
//========================================================
try {
Thread.sleep(2000); //保证线程至少执行2秒
} catch (InterruptedException e) {
e.printStackTrace();
}
//========================================================
t.interrupt();//中断线程
}
}
❸ 初学Java多线程：线程的生命周期
与人有生老病死一样 线程也同样要经历开始（等待） 运行 挂起和停止四种不同的状态 这四种状态都可以通过Thread类中的方法进行控制 下面给出了Thread类中和这四种状态相关的方法
// 开始线程
public void start( );
public void run( );
// 挂起和唤醒线程
public void resume( ); // 不建议使用
public void suspend( ); // 不建议使用
public static void sleep(long millis);
public static void sleep(long millis int nanos);
// 终止线程
public void stop( ); // 不建议使用
public void interrupt( );
// 得到线程状态
public boolean isAlive( );
public boolean isInterrupted( );
public static boolean interrupted( );
// join方法
public void join( ) throws InterruptedException;
一 创建并运行线程
线程在建立后并不马上执行run方法中的代码 而是处于等待状态 线程处于等待状态时 可以通过Thread类的方法来设置线程不各种属性 如线程的优先级（setPriority） 线程名(setName)和线程的类型（setDaemon）等
当调用start方法后 线程开始执行run方法中的代码 线程进入运行状态 可以通过Thread类的isAlive方法来判断线程是否处于运行状态 当线程处于运行状态时 isAlive返回true 当isAlive返回false时 可能线程处于等待状态 也可能处于停止状态 下面的代码演示了线程的创建 运行和停止三个状态之间的切换 并输出了相应的isAlive返回值
package chapter ;
public class LifeCycle extends Thread
{
public void run()
{
int n = ;
while ((++n) < );
}
public static void main(String[] args) throws Exception
{
LifeCycle thread = new LifeCycle();
System out println( isAlive: + thread isAlive());
thread start();
System out println( isAlive: + thread isAlive());
thread join(); // 等线程thread 结束后再继续执行
System out println( thread 已经结束! );
System out println( isAlive: + thread isAlive());
}
}
要注意一下 在上面的代码中使用了join方法 这个方法的主要功能是保证线程的run方法完成后程序才继续运行 这个方法将在后面的文章中介绍
上面代码的运行结果
isAlive: false
isAlive: true
thread 已经结束!
isAlive: false
二 挂起和唤醒线程
一但线程开始执行run方法 就会一直到这个run方法执行完成这个线程才退出 但在线程执行的过程中 可以通过两个方法使线程暂时停止执行 这两个方法是suspend和sleep 在使用suspend挂起线程后 可以通过resume方法唤醒线程 而使用sleep使线程休眠后 只能在设定的时间后使线程处于就绪状态（在线程休眠结束后 线程不一定会马上执行 只是进入了就绪状态 等待着系统进行调度）
虽然suspend和resume可以很方便地使线程挂起和唤醒 但由于使用这两个方法可能会造成一些不可预料的事情发生 因此 这两个方法被标识为deprecated(抗议)标记 这表明在以后的jdk版本中这两个方法可能被删除 所以尽量不要使用这两个方法来操作线程 下面的代码演示了sleep suspend和resume三个方法的使用
package chapter ;
public class MyThread extends Thread
{
class SleepThread extends Thread
{
public void run()
{
try
{
sleep( );
}
catch (Exception e)
{
}
}
}
public void run()
{
while (true)
System out println(new java util Date() getTime());
}
public static void main(String[] args) throws Exception
{
MyThread thread = new MyThread();
SleepThread sleepThread = thread new SleepThread();
sleepThread start(); // 开始运行线程sleepThread
sleepThread join(); // 使线程sleepThread延迟 秒
thread start();
boolean flag = false;
while (true)
{
sleep( ); // 使主线程延迟 秒
flag = !flag;
if (flag)
thread suspend();
else
thread resume();
}
}
}
从表面上看 使用sleep和suspend所产生的效果类似 但sleep方法并不等同于suspend 它们之间最大的一个区别是可以在一个线程中通过suspend方法来挂起另外一个线程 如上面代码中在主线程中挂起了thread线程 而sleep只对当前正在执行的线程起作用 在上面代码中分别使sleepThread和主线程休眠了 秒和 秒 在使用sleep时要注意 不能在一个线程中来休眠另一个线程 如main方法中使用thread sleep( )方法是无法使thread线程休眠 秒的 而只能使主线程休眠 秒
在使用sleep方法时有两点需要注意
sleep方法有两个重载形式 其中一个重载形式不仅可以设毫秒 而且还可以设纳秒( 纳秒等于 毫秒) 但大多数操作系统平台上的Java虚拟机都无法精确到纳秒 因此 如果对sleep设置了纳秒 Java虚拟机将取最接近这个值的毫秒
在使用sleep方法时必须使用throws或try{ }catch{ } 因为run方法无法使用throws 所以只能使用try{ }catch{ } 当在线程休眠的过程中 使用interrupt方法（这个方法将在 中讨论）中断线程时sleep会抛出一个InterruptedException异常 sleep方法的定义如下
public static void sleep(long millis) throws InterruptedException
public static void sleep(long millis int nanos) throws InterruptedException
三 终止线程的三种方法
有三种方法可以使终止线程
使用退出标志 使线程正常退出 也就是当run方法完成后线程终止
使用stop方法强行终止线程（这个方法不推荐使用 因为stop和suspend resume一样 也可能发生不可预料的结果）
使用interrupt方法中断线程
使用退出标志终止线程
当run方法执行完后 线程就会退出 但有时run方法是永远不会结束的 如在服务端程序中使用线程进行监听客户端请求 或是其他的需要循环处理的任务 在这种情况下 一般是将这些任务放在一个循环中 如while循环 如果想让循环永远运行下去 可以使用while(true){ }来处理 但要想使while循环在某一特定条件下退出 最直接的方法就是设一个boolean类型的标志 并通过设置这个标志为true或false来控制while循环是否退出 下面给出了一个利用退出标志终止线程的例子
package chapter ;
public class ThreadFlag extends Thread
{
public volatile boolean exit = false;
public void run()
{
while (!exit);
}
public static void main(String[] args) throws Exception
{
ThreadFlag thread = new ThreadFlag();
thread start();
sleep( ); // 主线程延迟 秒
thread exit = true; // 终止线程thread
thread join();
System out println( 线程退出! );
}
}
在上面代码中定义了一个退出标志exit 当exit为true时 while循环退出 exit的默认值为false 在定义exit时 使用了一个Java关键字volatile 这个关键字的目的是使exit同步 也就是说在同一时刻只能由一个线程来修改exit的值
使用stop方法终止线程
使用stop方法可以强行终止正在运行或挂起的线程 我们可以使用如下的代码来终止线程
thread stop();
虽然使用上面的代码可以终止线程 但使用stop方法是很危险的 就象突然关闭计算机电源 而不是按正常程序关机一样 可能会产生不可预料的结果 因此 并不推荐使用stop方法来终止线程
使用interrupt方法终止线程
使用interrupt方法来终端线程可分为两种情况
（ ）线程处于阻塞状态 如使用了sleep方法
（ ）使用while(!isInterrupted()){ }来判断线程是否被中断
在第一种情况下使用interrupt方法 sleep方法将抛出一个InterruptedException例外 而在第二种情况下线程将直接退出 下面的代码演示了在第一种情况下使用interrupt方法
package chapter ;
public class ThreadInterrupt extends Thread
{
public void run()
{
try
{
sleep( ); // 延迟 秒
}
catch (InterruptedException e)
{
System out println(e getMessage());
}
}
public static void main(String[] args) throws Exception
{
Thread thread = new ThreadInterrupt();
thread start();
System out println( 在 秒之内按任意键中断线程! );
System in read();
thread interrupt();
thread join();
System out println( 线程已经退出! );
}
}
上面代码的运行结果如下
在 秒之内按任意键中断线程!
sleep interrupted
线程已经退出!
在调用interrupt方法后 sleep方法抛出异常 然后输出错误信息 sleep interrupted
注意 在Thread类中有两个方法可以判断线程是否通过interrupt方法被终止 一个是静态的方法interrupted() 一个是非静态的方法isInterrupted() 这两个方法的区别是interrupted用来判断当前线是否被中断 而isInterrupted可以用来判断其他线程是否被中断 因此 while (!isInterrupted())也可以换成while (!Thread interrupted())
lishixin/Article/program/Java/gj/201311/27574
❹ JAVA三大框架中的生命周期是什么意思
从创建到消毁的一个过程，比如一个人，整个生命周期就是从出生到死亡
❺ JAVA:线程的生命周期是什么
1、一个线程的的生命周期可以分成两阶段：生存周期和死亡周期，其中生存周期又包括运行状态和等待状态.当创建一个新线程后，这个线程就进入了排队状态,当线程中的方法start()被调用时，线程就进入生存周期，这时它的方法isAlive()始终返回真值，直至线程进入死亡状态。
2、有两种方法可以实现线程，一种是扩展java.lang.Thread类，另一种是通过java.lang.Runnable接口
3、范例
import java.awt.*;
class Sample1{
public static void main(String[] args){
Mythread test1=new Mythread(1);
Mythread test2=new Mythread(2);
test1.start();
test2.start();
}
}
class Mythread extends Thread {
int id;
Mythread(int i)
{ id=i;}
public void run() {
int i=0;
while(id+i==1){
try {sleep(1000);
} catch(InterruptedException e) {}
}
System.out.println(“The id is ”+id);
}
❻ java spring框架中,bean的生命周期是什么
Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean。
❼ java线程的生命周期有哪些
生命周期的五种状态
新建（new Thread）
当创建Thread类的一个实例（对象）时，此线程进入新建状态（未被启动）。
例如：Thread t1=new Thread();
就绪（runnable）
线程已经被启动，正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源。例如：t1.start();
运行（running）
线程获得CPU资源正在执行任务（run()方法），此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入，线程将一直运行到结束。
死亡（dead）
当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行。
自然终止：正常运行run()方法后终止
异常终止：调用stop()方法让一个线程终止运行
堵塞（blocked）
由于某种原因导致正在运行的线程让出CPU并暂停自己的执行，即进入堵塞状态。
正在睡眠：用sleep(long t) 方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。
正在等待：调用wait()方法。（调用motify()方法回到就绪状态）
被另一个线程所阻塞：调用suspend()方法。（调用resume()方法恢复）
❽ Java类的生命周期包括哪几个阶段
加载：查找并加载类的二进制数据
连接：分为三个小阶段：
验证：确保被加载的类的正确性
准备：为类的静态变量分配内存，并将其初始 化为默认值
解析：把类中的符号引用转换为直接引用
初始化：为类的静态变量赋予正确的初始值
使用：又分为主动使用和被动使用。
卸载：由JVM自带的类加载器所加载的类，在JVM的生命周期中，始终不会被卸载。但是由用户自定义的类加载器所加载的类是可以被卸载的。
以上只是做部分说明。 要细说的话，内容还是很多的。
❾ java中的对象生命周期和回收机制
Java中对象的生命周期
Java对象的生命周期包括三个阶段：对象的创建，对象的使用，对象的清除。
回收机制
Java的垃圾回收机制是Java虚拟机提供的能力，用于在空闲时间以不定时的方式动态回收无任何引用的对象占据的内存空间。