Java 多線程——Thread類和Runable介面

標籤：

在java中可有兩種方式實現多線程，一種是繼承Thread類，一種是實現Runnable介面；
Thread類是在java.lang包中定義的。一個類只要繼承了Thread類同時覆寫了本類中的
run()方法就可以實現多線程操作了，但是一個類只能繼承一個父類，這是此方法的局限，

下面看例子：

[java] view plaincopy

1. package org.thread.demo;  

2. class MyThread extends Thread{  

3. private String name;  

4. public MyThread(String name) {  

5. super();  

6. this.name = name;  

7. }  

8. public void run(){  

9. for(int i=0;i<10;i++){  

10. System.out.println("線程開始："+this.name+",i="+i);  

11. }  

12. }  

13. }  

14. package org.thread.demo;  

15. public class ThreadDemo01 {  

16. public static void main(String[] args) {  

17. MyThread mt1=new MyThread("線程a");  

18. MyThread mt2=new MyThread("線程b");  

19. mt1.run();  

20. mt2.run();  

21. }  

22. }  

但是，此時結果很有規律，先第一個對象執行，然後第二個對象執行，並沒有相互運行。在JDK的文檔中可以發現，一旦調用start()方法，則會通過JVM找到run()方法。下面啟動start()方法啟動線程：

[java] view plaincopy

1. package org.thread.demo;  

2. public class ThreadDemo01 {  

3. public static void main(String[] args) {  

4. MyThread mt1=new MyThread("線程a");  

5. MyThread mt2=new MyThread("線程b");  

6. mt1.start();  

7. mt2.start();  

8. }  

這樣程式可以正常完成互動式運行。那麼為啥非要使用start();方法啟動多線程呢？
在JDK的安裝路徑下，src.zip是全部的java來源程式，通過此代碼找到Thread中的start()方法的定義，可以發現此方法中使用了 private native void start0();其中native關鍵字表示可以叫用作業系統的底層函數，那麼這樣的技術稱為JNI技術（java Native Interface）

·Runnable介面
在實際開發中一個多線程的操作很少使用Thread類，而是通過Runnable介面完成。

[java] view plaincopy

1. package org.runnable.demo;  

2. class MyThread implements Runnable{  

3. private String name;  

4. public MyThread(String name) {  

5. this.name = name;  

6. }  

7. public void run(){  

8. for(int i=0;i<100;i++){  

9. System.out.println("線程開始："+this.name+",i="+i);  

10. }  

11. }  

12. }  

但是在使用Runnable定義的子類中沒有start()方法，只有Thread類中才有。此時觀察Thread類，有一個構造方法：public Thread(Runnable targer)
此構造方法接受Runnable的子類執行個體，也就是說可以通過Thread類來啟動Runnable實現的多線程。（start()可以協調系統的資源）:

[java] view plaincopy

1. package org.runnable.demo;  

2. import org.runnable.demo.MyThread;  

3. public class ThreadDemo01 {  

4. public static void main(String[] args) {  

5. MyThread mt1=new MyThread("線程a");  

6. MyThread mt2=new MyThread("線程b");  

7. new Thread(mt1).start();  

8. new Thread(mt2).start();  

9. }  

10. }  

兩種實現方式的區別和聯絡：
在程式開發中只要是多線程肯定永遠以實現Runnable介面為主，因為實現Runnable介面相比
繼承Thread類有如下好處：
->避免點繼承的局限，一個類可以繼承多個介面。
->適合於資源的共用

以賣票程式為例，通過Thread類完成：

[java] view plaincopy

1. //使用Thread實現線程不能實現資源共用  

2. class MyThread extends Thread  

3. {     

4.     private int ticket=10;  

5.     private String name;  

6.     public MyThread(String name ){  

7.         this.name=name;  

8.     }  

9.     public void run(){  

10.         for(int i=0;i<10;i++){  

11.             if(ticket>0){  

12.                 System.out.println("線程"+name+"賣票"+(ticket--));  

13.             }  

14.         }  

15.       

16.     }  

17. }  

18.   

19. public class ThreadTicket  

20. {  

21.     public static void main(String args[]){  

22.         MyThread A = new MyThread("A");    

23.         MyThread B = new MyThread("B");  

24.         A.start();  

25.         B.start();  

26.     }  

27. }  

28.   

29. //使用Runnable實現線程可以實現資源共用  

30. class MyThread implements Runnable  

31. {  

32.     private int ticket=10;  

33.     private String name;  

34.     public MyThread(String name){  

35.         this.name=name;  

36.     }  

37.     public void run(){  

38.         for(int i=1;i<=10;i++){  

39.             if(ticket>0){  

40.                 System.out.println("線程"+name+"賣票"+(ticket--));  

41.                 }  

42.         }  

43.     }  

44. }  

45. public class ThreadTicket  

46. {  

47.     public static void main(String args[]){  

48.         MyThread A = new MyThread("A");  //執行個體化線程要執行的任務  

49.         Thread Ta = new Thread(A);    //執行個體兩個線程對象，實際傳遞的是一個任務  

50.         Thread Tb = new Thread(A);    //因為兩個線程執行的是一個任務，所以資源是共用的  

51.         Ta.start();  

52.         Tb.start();  

53.     }  

54. }  

雖然現在程式中有兩個個線程，但是一共賣了10張票，也就是說使用Runnable實現多線程可以達到資源共用目的。

Runnable介面和Thread之間的聯絡：public class Thread extends Object implements Runnable
容易看出Thread類是Runnable介面的子類。

Java 多線程——Thread類和Runable介面