① java中Runnable和Thread的區別
1. 一種是通過繼承Thread類，同時重寫run()方法。但是java中，只允許單繼承，也就是一個類只能繼承一個父類，使得該方式具有一定的局限性，等下就知道了。
2. 另一種是實現Runnable類介面的run()方法，再結合Thread類來實現多線程。
兩種方式最終都是通過調用start()方法來實現多線程。切記不能直接調用Thread類或Runnable對象的run()方法，因為直接調用run()方法，只會執行同一個線程中的任務，而不會啟動新線程。調用start()方法將會創建一個執行run()方法的線程。
實際開發中我們通常採用Runnable介面來實現多線程。因為實現Runnable介面比繼承Thread類有如下好處：
1. 避免繼承的局限，一個類可以繼承多個介面，但是類只能繼承一個類。
2. Runnable介面實現的線程便於資源共享。而通過Thread類實現，各自線程的資源是獨立的，不方便共享。
② java中runnable和thread的區別
Runnable介面和Thread類是java中實現多線程的兩中方法。
Thread類的構造方法有8個，但常用的只有4個，分別為：
Thread類中的兩個最主要的方法：
（1）run()—包含線程運行時所執行的代碼，即線程需要完成的任務，是線程執行體。
（2）start()—用於啟動線程。
實現Runnable介面的類必須使用Thread類的實例才能創建線程。通過實現Runnable介面來創建並啟動多線程的步驟：
③ java 中Thread 和Runnable有何區別
區別：Thread是類，而Runnable是介面。
抽象類和介面的區別如下：
①
在類來繼承抽象類時，只需實現部分具體方法和全部抽象方法，而實現介面則要實現裡面的全部方法。
②在介面中無成員變數，而抽象類中可有成員變數。
在Java中引進介面主要是為了解決多繼承的問題。
實現多線程主要繼承Thread
類和實現Runnable介面。
④ java中runnable和thread的區別
thread 是繼承了thread 類。runnable是實現了此介面，重寫run方法，因為介面可以實現多個，那用後面的，將來這個類還可以繼承別的類，而重寫run方法，以後要實現其他業務邏輯，就不用new 線程了。
⑤ Java中Runnable和Thread的區別
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");
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才能正確啟動現成，使用run只是方法調用。
這樣程序可以正常完成互動式運行。那麼為啥非要使用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(Runnabletarger)
此構造方法接受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){
結果分析：
1. 使用Runnable對象時，Runnable定義的子類沒有start()方法，只有Thread類中才有，觀察Thread類，有一個構造方法public Thread(Runnable target)，此構造方法接受Runanble的子類實例，也就是說可以通過Thread類來啟動Runnable實現多線程。
2. 每個線程調用的都是同一個MyRunnable對象的run()方法，訪問的是同一個對象中的變數ticket實例。
Runnable和Thread區別
實際開發中我們通常採用Runnable介面來實現多線程。因為實現Runnable介面比繼承Thread類有如下好處：
1. 避免繼承的局限，一個類可以繼承多個介面，但是類只能繼承一個類。
2. Runnable介面實現的線程便於資源共享。而通過Thread類實現，
⑥ Java中Runnable和Thread的區別
在java中可有兩種方式實現多線程，一種是繼承Thread類，一種是實現Runnable介面；Thread類是在java.lang包中定義的。一個類只要繼承了Thread類同時覆寫了本類中的run()方法就可以實現多線程操作了，但是一個類只能繼承一個父類，這是此方法的局限。
下面看例子：
package org.thread.demo; class MyThread extends Thread{ private String name; public MyThread(String name) { super(); this.name = name; } public void run(){ for(int i=0;i<10;i++){ System.out.println("線程開始："+this.name+",i="+i); } } } package org.thread.demo; public class ThreadDemo01 { public static void main(String[] args) { MyThread mt1=new MyThread("線程a"); MyThread mt2=new MyThread("線程b"); mt1.run(); mt2.run(); } } 但是，此時結果很有規律，先第一個對象執行，然後第二個對象執行，並沒有相互運行。在JDK的文檔中可以發現，一旦調用start()方法，則會通過JVM找到run()方法。下面啟動start()方法啟動線程：package org.thread.demo; public class ThreadDemo01 { public static void main(String[] args) { MyThread mt1=new MyThread("線程a"); MyThread mt2=new MyThread("線程b"); mt1.start(); mt2.start(); } }; 這樣程序可以正常完成互動式運行。那麼為啥非要使用start();方法啟動多線程呢？在JDK的安裝路徑下，src.zip是全部的java源程序，通過此代碼找到Thread中的start()方法的定義，可以發現此方法中使用了private native void start0();其中native關鍵字表示可以調用操作系統的底層函數，那麼這樣的技術成為JNI技術（java Native Interface）Runnable介面在實際開發中一個多線程的操作很少使用Thread類，而是通過Runnable介面完成。public interface Runnable{ public void run(); } 例子：package org.runnable.demo; class MyThread implements Runnable{ private String name; public MyThread(String name) { this.name = name; }public void run(){ for(int i=0;i<100;i++){ System.out.println("線程開始："+this.name+",i="+i); } } }; 但是在使用Runnable定義的子類中沒有start()方法，只有Thread類中才有。此時觀察Thread類，有一個構造方法：public Thread(Runnable targer)此構造方法接受Runnable的子類實例，也就是說可以通過Thread類來啟動Runnable實現的多線程。（start()可以協調系統的資源）：package org.runnable.demo; import org.runnable.demo.MyThread; public class ThreadDemo01 { public static void main(String[] args) { MyThread mt1=new MyThread("線程a"); MyThread mt2=new MyThread("線程b"); new Thread(mt1).start(); new Thread(mt2).start(); } } 兩種實現方式的區別和聯系：在程序開發中只要是多線程肯定永遠以實現Runnable介面為主，因為實現Runnable介面相比繼承Thread類有如下好處：避免點繼承的局限，一個類可以繼承多個介面。適合於資源的共享以賣票程序為例，通過Thread類完成：package org.demo.dff; class MyThread extends Thread{ private int ticket=10; public void run(){ for(int i=0;i<20;i++){ if(this.ticket>0){ System.out.println("賣票：ticket"+this.ticket--); } } } }; 下面通過三個線程對象，同時賣票：package org.demo.dff; public class ThreadTicket { public static void main(String[] args) { MyThread mt1=new MyThread(); MyThread mt2=new MyThread(); MyThread mt3=new MyThread(); mt1.start();//每個線程都各賣了10張，共賣了30張票 mt2.start();//但實際只有10張票，每個線程都賣自己的票 mt3.start();//沒有達到資源共享 } } 如果用Runnable就可以實現資源共享，下面看例子：package org.demo.runnable; class MyThread implements Runnable{ private int ticket=10; public void run(){ for(int i=0;i<20;i++){ if(this.ticket>0){ System.out.println("賣票：ticket"+this.ticket--); } } } } package org.demo.runnable; public class RunnableTicket { public static void main(String[] args) { MyThread mt=new MyThread(); new Thread(mt).start();//同一個mt，但是在Thread中就不可以，如果用同一 new Thread(mt).start();//個實例化對象mt，就會出現異常 new Thread(mt).start(); } }; 雖然現在程序中有三個線程，但是一共賣了10張票，也就是說使用Runnable實現多線程可以達到資源共享目的。Runnable介面和Thread之間的聯系：public class Thread extends Object implements Runnable發現Thread類也是Runnable介面的子類。
⑦ Java中Runnable和Thread的區別
進程：每個進程都有獨立的代碼和數據空間（進程上下文），進程間的切換會有較大的開銷，一個進程包含1--n個線程。
線程：同一類線程共享代碼和數據空間，每個線程有獨立的運行棧和程序計數器(PC)，線程切換開銷小。
線程和進程一樣分為五個階段：創建、就緒、運行、阻塞、終止。
多進程是指操作系統能同時運行多個任務（程序）。
多線程是指在同一程序中有多個順序流在執行。
在java中要想實現多線程，有兩種手段，一種是繼續Thread類，另外一種是實現Runable介面
總結：
實現Runnable介面比繼承Thread類所具有的優勢：
1）：適合多個相同的程序代碼的線程去處理同一個資源
2）：可以避免java中的單繼承的限制
3）：增加程序的健壯性，代碼可以被多個線程共享，代碼和數據獨立
⑧ java線程Thread和Runnable的區別
/*
你好,我這兩天也在學這個,剛好卡住這里了,和你交流一下,也順便提醒我一下,我盡量保持通俗,能不能看懂,全看造化了!
首先明白一點.如果你想創建一個線程,少不了Thread這個類的對象,我意思就是說,Thread是Java給我們提供的一個工具,你就暫時這么理解!
就算你用Runnable介面,你也少不了Thread這個類,只有這個類才可以幫助創建自定義的線程!
Thread相當於一個寫好的工具放在那裡,你可以直接拿來就用,Runnable相當於這個工具的擴展!
這個已經做好的工具,可以直接用,但是功能受到一些限制,加上這個介面功能就強大很多了!
自定義線程兩種方式都離不開Thread!
第一就是:
繼承他,做他的子類,子類就是一個線程類了,對象已建立就算有了線程了,然後啟動即可!
第二就是:
自定義一個類去實現runnable介面,因為Thread也實現了這個介面,這就相當於,你自定義的類,和Thread都擁有相同的一個介面,你可以理解成規則!
Thread的構造函數接受runnable這種"規則"的類,這個沒理由,這個是Java設計的,這點是死的!
Java用start啟動就是在啟動操作系統,幫你分配!
然後你可以創建一個Thread的對象,把你自定義的類對象,丟進去,然後啟動,他幫你執行!
區別就是:在資源共享上面,你的自定義類,用實現介面的方式,很輕松的操控!
當然還有別的,比如說,線程休眠,喚醒,等等..我就不在例舉了......
其實吧,繼承thread也可以實現資源共享,這里我就不說靜態變數了,其實還有別的辦法!
網路上,你可以看看,千篇一律都是照著教程寫的文字,我也不敢說自己總結的就很好!
多線程很重要,不要貪快!
不足之處還請指點!!!
*/
⑨ Java中Runnable和Thread的區別
1、在java中可有兩種方式實現多線程，一種是繼承Thread類，一種是實現Runnable介面；
2、Thread類是在java.lang包中定義的。一個類只要繼承了Thread類同時覆寫了本類中的run()方法就可以實現多線程操作了，但是一個類只能繼承一個父類，這是此方法的局限。
3、Runnable介面
在實際開發中一個多線程的操作很少使用Thread類，而是通過Runnable介面完成。
4、在程序開發中只要是多線程肯定永遠以實現Runnable介面為主，因為實現Runnable介面相比繼承Thread類有如下好處：
避免點繼承的局限，一個類可以繼承多個介面。
適合於資源的共享