javarunnablethread

『壹』 java中線程的幾種可用狀態有哪些請大家解釋一下。

線程在執行過程中，可以處於下面幾種狀態：
1、就緒(Runnable):線程准備運行，不一定立馬就能開始執行。
2、運行中(Running)：進程正在執行線程的代碼。
3、等待中(Waiting):線程處於阻塞的狀態，等待外部的處理結束。
4、睡眠中(Sleeping)：線程被強制睡眠。
5、I/O阻塞(BlockedonI/O)：等待I/O操作完成。
6、同步阻塞(BlockedonSynchronization)：等待獲取鎖。
7、死亡(Dead)：線程完成了執行。

『貳』 Java中Runnable和Thread的區別

線程的起動並不是簡單的調用了你的RUN方法,而是由一個線程調度器來分別調用你的所有線程的RUN方法,
我們普通的RUN方法如果沒有執行完是不會返回的,也就是會一直執行下去,這樣RUN方法下面的方法就不可能會執行了,可是線程里的RUN方法卻不一樣,它只有一定的CPU時間,執行過後就給別的線程了,這樣反復的把CPU的時間切來切去,因為切換的速度很快,所以我們就感覺是很多線程在同時運行一樣.

你簡單的調用run方法是沒有這樣效果的,所以你必須調用Thread類的start方法來啟動你的線程.所以你啟動線程有兩種方法
一是寫一個類繼承自Thread類,然後重寫裡面的run方法,用start方法啟動線程
二是寫一個類實現Runnable介面,實現裡面的run方法,用newThread(Runnabletarget).start()方法來啟動

這兩種方法都必須實現RUN方法,這樣線程起動的時候,線程管理器好去調用你的RUN方法.

你的TestThread沒有繼承自Thread類,怎麼可能會有start方法呢?


在java中可有兩種方式實現多線程，一種是繼承Thread類，一種是實現Runnable介面；
Thread類是在java.lang包中定義的。一個類只要繼承了Thread類同時覆寫了本類中的
run()方法就可以實現多線程操作了，但是一個類只能繼承一個父類，這是此方法的局限，
下面看例子：
packageorg.thread.demo;
classMyThreadextendsThread{
privateStringname;
publicMyThread(Stringname){
super();
this.name=name;
}
publicvoidrun(){
for(inti=0;i<10;i++){
System.out.println("線程開始："+this.name+",i="+i);
}
}
}
packageorg.thread.demo;
publicclassThreadDemo01{
publicstaticvoidmain(String[]args){
MyThreadmt1=newMyThread("線程a");
MyThreadmt2=newMyThread("線程b");
//thread1，thread2，按順序進行
mt1.run();
mt2.run();
}
}
但是，此時結果很有規律，先第一個對象執行，然後第二個對象執行，並沒有相互運行。在JDK的文檔中可以發現，一旦調用start()方法，則會通過JVM找到run()方法。下面啟動
start()方法啟動線程：
packageorg.thread.demo;
publicclassThreadDemo01{
publicstaticvoidmain(String[]args){
MyThreadmt1=newMyThread("線程a");
MyThreadmt2=newMyThread("線程b");
//亂序進行
mt1.start();
mt2.start();
}
};
這樣程序可以正常完成互動式運行。那麼為啥非要使用start()方法啟動多線程呢？
在JDK的安裝路徑下，src.zip是全部的java源程序，通過此代碼找到Thread中的start()方法的定義，可以發現此方法中使用了privatenativevoidstart0();其中native關鍵字表示可以調用操作系統的底層函數，那麼這樣的技術成為JNI技術（javaNativeInterface）
·Runnable介面
在實際開發中一個多線程的操作很少使用Thread類，而是通過Runnable介面完成。
publicinterfaceRunnable{
publicvoidrun();
}
例子：
packageorg.runnable.demo;
{
privateStringname;
publicMyThread(Stringname){
this.name=name;
}
publicvoidrun(){
for(inti=0;i<100;i++){
System.out.println("線程開始："+this.name+",i="+i);
}
}
};


但是在使用Runnable定義的子類中沒有start()方法，只有Thread類中才有。此時觀察Thread類，有一個構造方法：publicThread(Runnabletarget)
此構造方法接受Runnable的子類實例，也就是說可以通過Thread類來啟動Runnable實現的多
線程。（start()可以協調系統的資源）:
packageorg.runnable.demo;
importorg.runnable.demo.MyThread;
publicclassThreadDemo01{
publicstaticvoidmain(String[]args){
MyThreadmt1=newMyThread("線程a");
MyThreadmt2=newMyThread("線程b");
newThread(mt1).start();
newThread(mt2).start();
}
}
·兩種實現方式的區別和聯系：
在程序開發中只要是多線程肯定永遠以實現Runnable介面為主，因為實現Runnable介面相比
繼承Thread類有如下好處：
->避免點繼承的局限，一個類可以繼承多個介面。
->適合於資源的共享
以賣票程序為例，通過Thread類完成：
packageorg.demo.dff;
classMyThreadextendsThread{
privateintticket=10;
publicvoidrun(){
for(inti=0;i<20;i++){
if(this.ticket>0){
System.out.println("賣票：ticket"+this.ticket--);
}
}
}
};
下面通過三個線程對象，同時賣票：
packageorg.demo.dff;
publicclassThreadTicket{
publicstaticvoidmain(String[]args){
MyThreadmt1=newMyThread();
MyThreadmt2=newMyThread();
MyThreadmt3=newMyThread();
mt1.start();//每個線程都各賣了10張，共賣了30張票
mt2.start();//但實際只有10張票，每個線程都賣自己的票
mt3.start();//沒有達到資源共享
}
}
如果用Runnable就可以實現資源共享，下面看例子：
packageorg.demo.runnable;
{
privateintticket=10;
publicvoidrun(){
for(inti=0;i<20;i++){
if(this.ticket>0){
System.out.println("賣票：ticket"+this.ticket--);
}
}
}
}
packageorg.demo.runnable;
publicclassRunnableTicket{
publicstaticvoidmain(String[]args){
MyThreadmt=newMyThread();
newThread(mt).start();//同一個mt，但是在Thread中就不可以，如果用同一
newThread(mt).start();//個實例化對象mt，就會出現異常
newThread(mt).start();
}
};
雖然現在程序中有三個線程，但是一共賣了10張票，也就是說使用Runnable實現多線程可以達到資源共享目的。
Runnable介面和Thread之間的聯系：

發現Thread類也是Runnable介面的子類。

『叄』 在Java 中多線程的實現方法有哪些，如何使用～～～～～～～～～～～～～～～～～～急

1、 認識Thread和Runnable

Java中實現多線程有兩種途徑：繼承Thread類或者實現Runnable介面。Runnable是介面，建議用介面的方式生成線程，因為介面可以實現多繼承，況且Runnable只有一個run方法，很適合繼承。在使用Thread的時候只需繼承Thread，並且new一個實例出來，調用start()方法即可以啟動一個線程。

Thread Test = new Thread();

Test.start();

在使用Runnable的時候需要先new一個實現Runnable的實例，之後啟動Thread即可。

Test impelements Runnable;

Test t = new Test();

Thread test = new Thread(t);

test.start();

總結：Thread和Runnable是實現java多線程的2種方式，runable是介面，thread是類，建議使用runable實現java多線程，不管如何，最終都需要通過thread.start()來使線程處於可運行狀態。

2、 認識Thread的start和run

1） start：

用start方法來啟動線程，真正實現了多線程運行，這時無需等待run方法體代碼執行完畢而直接繼續執行下面的代碼。通過調用Thread類的start()方法來啟動一個線程，這時此線程處於就緒（可運行）狀態，並沒有運行，一旦得到spu時間片，就開始執行run()方法，這里方法run()稱為線程體，它包含了要執行的這個線程的內容，Run方法運行結束，此線程隨即終止。

2） run：

run()方法只是類的一個普通方法而已，如果直接調用Run方法，程序中依然只有主線程這一個線程，其程序執行路徑還是只有一條，還是要順序執行，還是要等待run方法體執行完畢後才可繼續執行下面的代碼，這樣就沒有達到寫線程的目的。

總結：調用start方法方可啟動線程，而run方法只是thread的一個普通方法調用，還是在主線程里執行。

3、 線程狀態說明

線程狀態從大的方面來說，可歸結為：初始狀態、可運行狀態、不可運行狀態和消亡狀態，具體可細分為上圖所示7個狀態，說明如下：

1） 線程的實現有兩種方式，一是繼承Thread類，二是實現Runnable介面，但不管怎樣，當我們new了thread實例後，線程就進入了初始狀態；

2） 當該對象調用了start()方法，就進入可運行狀態；

3） 進入可運行狀態後，當該對象被操作系統選中，獲得CPU時間片就會進入運行狀態；

4） 進入運行狀態後case就比較多，大致有如下情形：

·run()方法或main()方法結束後，線程就進入終止狀態；

·當線程調用了自身的sleep()方法或其他線程的join()方法，就會進入阻塞狀態(該狀態既停止當前線程，但並不釋放所佔有的資源)。當sleep()結束或join()結束後，該線程進入可運行狀態，繼續等待OS分配時間片；

·當線程剛進入可運行狀態(注意，還沒運行)，發現將要調用的資源被鎖牢(synchroniza,lock)，將會立即進入鎖池狀態，等待獲取鎖標記(這時的鎖池裡也許已經有了其他線程在等待獲取鎖標記，這時它們處於隊列狀態，既先到先得)，一旦線程獲得鎖標記後，就轉入可運行狀態，等待OS分配CPU時間片；

·當線程調用wait()方法後會進入等待隊列(進入這個狀態會釋放所佔有的所有資源，與阻塞狀態不同)，進入這個狀態後，是不能自動喚醒的，必須依靠其他線程調用notify()或notifyAll()方法才能被喚醒(由於notify()只是喚醒一個線程，但我們由不能確定具體喚醒的是哪一個線程，也許我們需要喚醒的線程不能夠被喚醒，因此在實際使用時，一般都用notifyAll()方法，喚醒有所線程)，線程被喚醒後會進入鎖池，等待獲取鎖標記。

·當線程調用stop方法，即可使線程進入消亡狀態，但是由於stop方法是不安全的，不鼓勵使用，大家可以通過run方法里的條件變通實現線程的stop。

『肆』 java創建線程的幾種方式，了解一下

第一種方式：使用Runnable介面創建線程

第二種方式：直接繼承Thread類創建對象

使用Runnable介面創建線程

1.可以將CPU，代碼和數據分開，形成清晰的模型

2.線程體run()方法所在的類可以從其它類中繼承一些有用的屬性和方法

3.有利於保持程序的設計風格一致

直接繼承Thread類創建對象

1.Thread子類無法再從其它類繼承（java語言單繼承）。

2.編寫簡單，run()方法的當前對象就是線程對象，可直接操作。

在實際應用中，幾乎都採取第一種方式

『伍』 java 多線程 繼承Thread和實現Runnable的區別

Java中線程的創建有兩種方式：

1、 通過繼承Thread類，重寫Thread的run()方法，將線程運行的邏輯放在其中

2、 通過實現Runnable介面，實例化Thread類

Runnable
介面只有一個方法 run()，我們聲明自己的類實現 Runnable
介面並提供這一方法，將我們的線程代碼寫入其中，就完成了這一部分的任務。但是 Runnable 介面並沒有任何對線程的支持，我們還必須創建
Thread 類的實例，這一點通過 Thread 類的構造函數public Thread(Runnable target);來實現。

3、繼承Thread實現的模式是 定義多個線程,各自完成各自的任務.

4、實現Runnable實現的模式是 定義多個線程,實現一個任務.

總結：一個是多個線程分別完成自己的任務，一個是多個線程共同完成一個任務。其實，在實現一個任務用多個線程來做也可以用繼承Thread類來實現，只是比較麻煩，一般我們用實現Runnable介面來實現。