傳統的線程技術

線程並不是java1.5以後的新技術，在（java1.5之前）傳統的線程創建有兩種方式：1）繼承Thread類；2）實現Runnable介面。

1）繼承Thread類：

 1 　　　　Thread thread1 = new Thread(){
 2             @Override
 3             public void run() {
 4                 while(true){
 5                     try {
 6                         Thread.sleep(500);
 7                     } catch (InterruptedException e) {
 8                         // TODO Auto-generated catch block
 9                         e.printStackTrace();
10                     }
11                         System.out.println(Thread.currentThread().getId());
12                 }
13             }
14         };
15         thread1.start();

這種方式是創建Thread的子類，並且覆蓋Thread類的run方法。當調用thread的start方法時會執行run方法內的內容。

2）實現Runnable介面：

 1 　　　　　Thread thread2 = new Thread(new Runnable() {    
 2             @Override
 3             public void run() {
 4                 while(true){
 5                     try {
 6                         Thread.sleep(500);
 7                     } catch (InterruptedException e) {
 8                         // TODO Auto-generated catch block
 9                         e.printStackTrace();
10                     }
11                     System.out.println(Thread.currentThread().getName());
12                 }
13             }
14         });
15         thread2.start();

在查看Thread的源碼的時候，發現Thread類的實現源代碼會發現Thread類是實現了Runnable介面，其run方式實現如下：

1  @Override
2     public void run() {
3         if (target != null) {
4             target.run();
5         }
6     }

run方法中的target對象在Thread的構造方法中引入：

1 public Thread(Runnable target) {
2         init(null, target, "Thread-" + nextThreadNum(), 0);
3 }

所以繼承runnable方法調用的也是run方法。

3）線程創建的擴展：

如果將線程子線程同時覆蓋run方法和設置runnable參數如下：

 1 　　　　　　Thread thread3 = new Thread(new Runnable() {
 2             
 3             @Override
 4             public void run() {
 5                 while(true){
 6                     try {
 7                         Thread.sleep(500);
 8                     } catch (InterruptedException e) {
 9                         // TODO Auto-generated catch block
10                         e.printStackTrace();
11                     }
12                     System.out.println("runnable"+Thread.currentThread().getName());
13                 }
14             }
15         }){
16 
17             @Override
18             public void run() {
19                 while(true){
20                     try {
21                         Thread.sleep(500);
22                     } catch (InterruptedException e) {
23                         // TODO Auto-generated catch block
24                         e.printStackTrace();
25                     }
26                     System.out.println("thread"+Thread.currentThread().getName());
27                 }
28             }
29             
30         };
31         thread3.start();

線上程執行中會執行run方法，因為run方法是Thread的子類覆蓋父類的方法，於父類run方法沒有關係，所有會執行子類的run方法，如果子類沒有覆蓋父類的run方法，那麼就會去執行runnable的run方法。

註意：run方法直接調用並不會創建新的線程，而是在主線程中直接運行run方法，跟普通的方法調用沒有任何區別。在實際應用中，實現runnable介面的方式更加常用，因為直接繼承Thread類的話，可能比實現Runnable介面看起來更加簡潔，但是由於Java只允許單繼承，所以如果自定義類需要繼承其他類，則只能選擇實現Runnable介面。並且實現runnable介面更加符合面向對象編程時思想。