生命周期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虛擬機提供的能力，用於在空閑時間以不定時的方式動態回收無任何引用的對象占據的內存空間。