java.lang.runnable（javalangrunnable是介面）

• 1、java.lang.Thread 和 java.lang.Runnable的區別
• 2、JAVA 認證問題 （java.lang.Runnable 和 java.lang.Cloneable）
• 3、java中的Runnable類是什麼意思？
• 4、Runnable介面詳解？

thread是類

runnable是介面

實現多線程有兩種方式：

1.繼承Thread，然後重寫他的run方法

2.實現Runnable介面，並實現他的run方法

啟動線程時也有區別

繼承Thread的類直接調用start方法即可

實現Runnable介面要這樣啟動

runab ：是實現Runnable介面類的對象

Thread thr = new Thread(runab);

thr.start()

A的錯誤在於：

A. public class Session

implements Runnable, cloneable {

public void run(); //沒有方法體

public Object clone(); //沒有方法體

}

正確寫法應該是：

public void run(){ ….}

public Object clone(){…}

D之所以正確，是因為abstract類的性質。如果類中哪怕有一個方法是抽象方法，則類「必須」被定義為抽象類。但反過來說，一個類被定義為抽象類，並不要求裡面一定有抽象方法。

所以，抽象類並不是說裡面的方法「全部」是抽象方法。只有一個或幾個，甚至沒有抽象方法都可以。所以D是正確的。

在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;i10;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;i100;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;i20;i++){

if(this.ticket0){

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;i20;i++){

if(this.ticket0){

System.out.println(“賣票：ticket”+this.ticket–);

}

}

}

}

package org.demo.runnable;

public class RunnableTicket {

public stati

在Java中，「線程」指兩件不同的事情：

1、java.lang.Thread類的一個實例；

2、線程的執行。

使用java.lang.Thread類或者java.lang.Runnable介面編寫代碼來定義、實例化和啟動新線程。

一個Thread類實例只是一個對象，像Java中的任何其他對象一樣，具有變數和方法，生死於堆上。

Java中，每個線程都有一個調用棧，即使不在程序中創建任何新的線程，線程也在後台運行著。

一個Java應用總是從main()方法開始運行，mian()方法運行在一個線程內，它被稱為主線程。

一旦創建一個新的線程，就產生一個新的調用棧。

線程總體分兩類：用戶線程和守候線程。

當所有用戶線程執行完畢的時候，JVM自動關閉。但是守候線程卻不獨立於JVM，守候線程一般是由操作系統或者用戶自己創建的。