java線程runnable
① java中的Runnable類是什麼意思
在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 stati
② java中Runnable介面含義
Java中實現多線程有兩種途徑:繼承Thread類或者實現Runnable介面.
Runnable介面非常簡單,就定義了一個方法run(),繼承Runnable並實現這個
方法就可以實現多線程了,但是這個run()方法不能自己調用,必須由系統來調用,否則就和別的方法沒有什麼區別了.
先給一個簡單的例子:
public class MultiThread implements Runnable{
public static void main(String[] args){
for(int i=0;i<10;i++){
new Thread(new MultiThread()).start();//correct
//new Thread(new MultiThread()).run 1
//new MultiThread().run() 2
}
}
public void run(){
System.out.println(Thread.currentThread().getName());
}
}
運行後應該啟動了10個新的線程,加上主線程一共11個線程,應該輸出是Thread-1知道10.
這里要注意啟動線程的方式是調用了Thread的start()方法,而不是run方法,如果
用注釋里的1或者2輸入都是10個main,因為這個時候run()方法還原了,和普通方法一樣了.
我們也可以得出一個結論:所有的線程在運行時都是一個Thread實例,雖然可以不用繼承Thread
實現多線程,但是最終還是Thread的一個實例.
③ Java中Runnable和Thread的區別
區別：Thread是類，而Runnable是介面。
抽象類和介面的區別如下：
① 在類來繼承抽象類時，只需實現部分具體方法和全部抽象方法，而實現介面則要實現裡面的全部方法。
②在介面中無成員變數，而抽象類中可有成員變數。
在Java中引進介面主要是為了解決多繼承的問題。
實現多線程主要繼承Thread 類和實現Runnable介面。
④ java runnable線程如何傳參
Runnable裡面沒有傳參函數，所以得自己造一個
0.自定義一個介面，繼承Runnable，新增一個傳參方法
{
publicMyRunnablesetParam(String...param);
}實現這個自定義介面
MyRunnablesendMessage=newMyRunnable(){
Stringmessage;
@Override
publicMyRunnablesetParam(String...param){
message=param[0];
returnthis;
}
@Override
publicvoidrun(){
sendMessage(message);
}
};2.初始化線程池，運行Runnable
=Executors.newCachedThreadPool();
cachedThreadPool.execute(sendMessage.setParam("Iamservice"));
如上所示，線程池調用的一個runnable實例，這個runnable實例傳入了一個字元串參數
⑤ Java中Runnable和Thread的區別是什麼
在java中可有兩種方式實現多線程，一種是繼承Thread類，一種是實現Runnable介面；
Thread類是在java.lang包中定義的。一個類只要繼承了Thread類同時覆寫了本類中的run()方法就可以實現多線程操作了，但是一個類只能繼承一個父類，這是此方法的局限。
⑥ 舉例說明java中的runnable 介面實現線程,並啟動線程的方法.
publicclassRunnableDemo{
publicstaticvoidmain(String[]args)throwsException{
longstatTime=System.currentTimeMillis();
SimpleRunnablerunnable1=newSimpleRunnable();
SimpleRunnablerunnable2=newSimpleRunnable();
//每個Thread（線程）可以接受一個Runnable的實現類做參數
//線程啟動時會去運行你實現的run()方法
Threadthread1=newThread(runnable1);
Threadthread2=newThread(runnable2);
thread1.start();//啟動線程1
thread2.start();//啟動線程2
thread1.join();//等待線程1運行結束
thread2.join();//等待線程2運行結束
longendTime=System.currentTimeMillis();
doubletime=(endTime-statTime)/1000.0;
System.out.println("程序運行時間："+time+"秒");
//每個任務運行時間都應該是2秒，但是因為你每個任務都用了一個線程去運行
//所以這兩個線程是同時（並發）進行的，所以這個程序只需要2秒左右就可以結束
}
}
//寫一個實現Runnable介面的類，並實現run()方法
{
@Override
publicvoidrun(){
runTask();//運行你的任務
}
privatevoidrunTask(){
try{
Thread.sleep(2000);//假設你的任務需要兩秒完成
}catch(InterruptedExceptionex){
ex.printStackTrace(System.err);
}
}
}
⑦ 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介面來實現。
⑧ java中Runnable介面含義
java中Runnable介面：是一個介面，它裡面只有一個run()方法，沒有start()方法，繼承Runnable並實現這個方法就可以實現多線程了，但是這個run()方法不能自己調用，必須由系統來調用。
舉例如下：
[java] view plain
public interface Runnable{
public void run();
}
所以，即使實現了Runnable介面，那也無法啟動線程，必須依託其他類。
而Thread類，有一個構造方法，參數是Runnable對象，也就是說可以通過Thread類來啟動Runnable實現的多線程。
[java] view plain
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
所以，實現Runnable介面後，需要使用Thread類來啟動。